BranchRecord.cpp

Go to the documentation of this file.

// BranchRecord.cpp: implementation of the BranchRecord class.
//
#if defined(_WIN32)
#include <direct.h>
#include <boost/serialization/export.hpp>
#endif
 
#include "BranchRecord.h"
#include <cstdlib>
#include <filesystem>
#include "../Global/SimulationContext.h"
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(BranchRecord)
using namespace std;
 
extern int nth_branch_muli_process;
// SEQ-FP diagnostic
 
// Construction/Destruction
 
BranchRecord::BranchRecord() {
  type_of_ODM_branch = sim::None;
  type_of_OAT_branch = sim::None;
  type_of_OCT_branch = sim::None;
  total_number_of_branches = 0;
  num_of_ODM_branch = 0;
  num_of_OAT_branch = 0;
  num_of_OCT_branch = 0;
  num_of_HWReliability_branch = 0;
  num_of_SSReliability_branch = 0;
  temp_type_of_consequence = Consequence::Succeed;
  ID_of_recent_generated_branch = -1;//number to be used as PE_N; started from zero including the branch following g_sim.IE
  ID_of_recent_generated_ES = -1;
  ID_of_recent_generated_branch_cluster = -1;
//  ID_of_mother_cluster = -1;
//  ID_of_mother_branch = -1;
  ID_of_mother_cluster = 0;
  ID_of_mother_branch = 0;
  recent_unconditional_branch_probability = 1.0;
  size_of_subfolder = 1000;
}
 
BranchRecord::~BranchRecord() {
  this->clearBranchRecordAll();
}
void BranchRecord::clearBranches() {
//
  ODM_branch.clearBranchUnit();
  OAT_branch.clearBranchUnit();
  OCT_branch.clearBranchUnit();
  HW_reliability_branch.clear();
  SS_reliability_branch.clear();
  system_branch.clear();
  type_of_ODM_branch = sim::None;
  type_of_OAT_branch = sim::None;
  type_of_OCT_branch = sim::None;
  total_number_of_branches = 0;
  num_of_ODM_branch = 0;
  num_of_OAT_branch = 0;
  num_of_OCT_branch = 0;
  num_of_HWReliability_branch = 0;
  num_of_SSReliability_branch = 0;
}
void BranchRecord::clearBranchRecordForRestart() {//for console version
  this->clearBranches();
}
void BranchRecord::addGoal(int _operator, BranchGoal *_bd) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.goal.push_back(shared_ptr<BranchGoal>(_bd));
    type_of_ODM_branch = sim::Decision::Goal;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.goal.push_back(shared_ptr<BranchGoal>(_bd));
    type_of_OAT_branch = sim::Decision::Goal;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.goal.push_back(shared_ptr<BranchGoal>(_bd));
    type_of_OCT_branch = sim::Decision::Goal;
    num_of_OCT_branch++;
  } else {
  }
  return;
}
void BranchRecord::addStrategy(int _operator, BranchStrategy *_bd) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.strategy.push_back(shared_ptr<BranchStrategy>(_bd));
    type_of_ODM_branch = sim::Decision::Strategy;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.strategy.push_back(shared_ptr<BranchStrategy>(_bd));
    type_of_OAT_branch = sim::Decision::Strategy;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.strategy.push_back(shared_ptr<BranchStrategy>(_bd));
    type_of_OCT_branch = sim::Decision::Strategy;
    num_of_OCT_branch++;
  } else {
  }
}
 
void BranchRecord::addSubGoal(int _operator, BranchSubGoal *_bd) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.subgoal.push_back(shared_ptr<BranchSubGoal>(_bd));
    type_of_ODM_branch = sim::Decision::SubGoal;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.subgoal.push_back(shared_ptr<BranchSubGoal>(_bd));
    type_of_OAT_branch = sim::Decision::SubGoal;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.subgoal.push_back(shared_ptr<BranchSubGoal>(_bd));
    type_of_OCT_branch = sim::Decision::SubGoal;
    num_of_OCT_branch++;
  } else {
  }
}
void BranchRecord::addDiagnosis(int _operator, BranchDiagnosis *_bd) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.diagnosis.push_back(shared_ptr<BranchDiagnosis>(_bd));
    type_of_ODM_branch = sim::Decision::Diagnosis;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.diagnosis.push_back(shared_ptr<BranchDiagnosis>(_bd));
    type_of_OAT_branch = sim::Decision::Diagnosis;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.diagnosis.push_back(shared_ptr<BranchDiagnosis>(_bd));
    type_of_OCT_branch = sim::Decision::Diagnosis;
    num_of_OCT_branch++;
  } else {
  }
}
void BranchRecord::addActionObjective(int _operator, BranchActionObjective *_bd) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.action_objective.push_back(shared_ptr<BranchActionObjective>(_bd));
    type_of_ODM_branch = sim::Action::Objective;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.action_objective.push_back(shared_ptr<BranchActionObjective>(_bd));
    type_of_OAT_branch = sim::Action::Objective;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.action_objective.push_back(shared_ptr<BranchActionObjective>(_bd));
    type_of_OCT_branch = sim::Action::Objective;
    num_of_OCT_branch++;
  } else {
  }
}
 
void BranchRecord::addActionPack(int _operator, BranchActionPack *_bd) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.action_pack.push_back(shared_ptr<BranchActionPack>(_bd));
    type_of_ODM_branch = sim::Action::Pack;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.action_pack.push_back(shared_ptr<BranchActionPack>(_bd));
    type_of_OAT_branch = sim::Action::Pack;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.action_pack.push_back(shared_ptr<BranchActionPack>(_bd));
    type_of_OCT_branch = sim::Action::Pack;
    num_of_OCT_branch++;
  } else {
  }
}
void BranchRecord::addAction(int _operator, BranchAction *_bd) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.action.push_back(shared_ptr<BranchAction>(_bd));
    type_of_ODM_branch = sim::Action::Action;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.action.push_back(shared_ptr<BranchAction>(_bd));
    type_of_OAT_branch = sim::Action::Action;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.action.push_back(shared_ptr<BranchAction>(_bd));
    type_of_OCT_branch = sim::Action::Action;
    num_of_OCT_branch++;
  } else {
  }
}
void BranchRecord::addInfoGatherMode(int _operator, BranchInfoGatherMode *_bigm) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.info_gather_mode.push_back(shared_ptr<BranchInfoGatherMode>(_bigm));
    type_of_ODM_branch = sim::Branch::InfoGatherMode;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.info_gather_mode.push_back(shared_ptr<BranchInfoGatherMode>(_bigm));
    type_of_OAT_branch = sim::Branch::InfoGatherMode;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.info_gather_mode.push_back(shared_ptr<BranchInfoGatherMode>(_bigm));
    type_of_OCT_branch = sim::Branch::InfoGatherMode;
    num_of_OCT_branch++;
  } else {
  }
}
void BranchRecord::addMentalBelief(int _operator, BranchExpectedMentalBelief *_bemb) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.mental_belief.push_back(shared_ptr<BranchExpectedMentalBelief>(_bemb));
    type_of_ODM_branch = sim::Branch::MentalBelief;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.mental_belief.push_back(shared_ptr<BranchExpectedMentalBelief>(_bemb));
    type_of_OAT_branch = sim::Branch::MentalBelief;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.mental_belief.push_back(shared_ptr<BranchExpectedMentalBelief>(_bemb));
    type_of_OCT_branch = sim::Branch::MentalBelief;
    num_of_OCT_branch++;
  } else {
  }
}
 
void BranchRecord::addScannedParameter(int _operator, BranchScannedParameter *_bsp) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.scanned_parameter.push_back(shared_ptr<BranchScannedParameter>(_bsp));
    type_of_ODM_branch = sim::ControlAction::ParameterScan;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.scanned_parameter.push_back(shared_ptr<BranchScannedParameter>(_bsp));
    type_of_OAT_branch = sim::ControlAction::ParameterScan;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.scanned_parameter.push_back(shared_ptr<BranchScannedParameter>(_bsp));
    type_of_OCT_branch = sim::ControlAction::ParameterScan;
    num_of_OCT_branch++;
  } else {
  }
}
void BranchRecord::addAlarmState(int _operator, BranchExpectedAlarmState *_bd) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.alarm_state.push_back(shared_ptr<BranchExpectedAlarmState>(_bd));
    type_of_ODM_branch = sim::Comm::AlarmState;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.alarm_state.push_back(shared_ptr<BranchExpectedAlarmState>(_bd));
    type_of_OAT_branch = sim::Comm::AlarmState;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.alarm_state.push_back(shared_ptr<BranchExpectedAlarmState>(_bd));
    type_of_OCT_branch = sim::Comm::AlarmState;
    num_of_OCT_branch++;
  } else {
  }
}
void BranchRecord::addComponentState(int _operator, BranchExpectedComponentState *_bd) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.component_state.push_back(shared_ptr<BranchExpectedComponentState>(_bd));
    type_of_ODM_branch = sim::Comm::ComponentState;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.component_state.push_back(shared_ptr<BranchExpectedComponentState>(_bd));
    type_of_OAT_branch = sim::Comm::ComponentState;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.component_state.push_back(shared_ptr<BranchExpectedComponentState>(_bd));
    type_of_OCT_branch = sim::Comm::ComponentState;
    num_of_OCT_branch++;
  } else {
  }
}
void BranchRecord::addSupportSystemState(int _operator, BranchExpectedSupportSystemState *_bd) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.support_system_state.push_back(shared_ptr<BranchExpectedSupportSystemState>(_bd));
    type_of_ODM_branch = sim::Comm::SupportSystemState;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.support_system_state.push_back(shared_ptr<BranchExpectedSupportSystemState>(_bd));
    type_of_OAT_branch = sim::Comm::SupportSystemState;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.support_system_state.push_back(shared_ptr<BranchExpectedSupportSystemState>(_bd));
    type_of_OCT_branch = sim::Comm::SupportSystemState;
    num_of_OCT_branch++;
  } else {
  }
}
void BranchRecord::addParameterTrend(int _operator, BranchExpectedParameterTrend *_bd) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.parameter_trend.push_back(shared_ptr<BranchExpectedParameterTrend>(_bd));
    type_of_ODM_branch = sim::Comm::ParameterTrend;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.parameter_trend.push_back(shared_ptr<BranchExpectedParameterTrend>(_bd));
    type_of_OAT_branch = sim::Comm::ParameterTrend;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.parameter_trend.push_back(shared_ptr<BranchExpectedParameterTrend>(_bd));
    type_of_OCT_branch = sim::Comm::ParameterTrend;
    num_of_OCT_branch++;
  } else {
  }
}
void BranchRecord::addParameterValue(int _operator, BranchExpectedParameterValue *_bd) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.parameter_value.push_back(shared_ptr<BranchExpectedParameterValue>(_bd));
    type_of_ODM_branch = sim::Comm::ParameterValue;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.parameter_value.push_back(shared_ptr<BranchExpectedParameterValue>(_bd));
    type_of_OAT_branch = sim::Comm::ParameterValue;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.parameter_value.push_back(shared_ptr<BranchExpectedParameterValue>(_bd));
    type_of_OCT_branch = sim::Comm::ParameterValue;
    num_of_OCT_branch++;
  } else {
  }
}
 
void BranchRecord::addParameterDifference(int _operator, BranchExpectedParameterDifference *_bd) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.parameter_difference.push_back(shared_ptr<BranchExpectedParameterDifference>(_bd));
    type_of_ODM_branch = sim::Comm::ParameterDifference;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.parameter_difference.push_back(shared_ptr<BranchExpectedParameterDifference>(_bd));
    type_of_OAT_branch = sim::Comm::ParameterDifference;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.parameter_difference.push_back(shared_ptr<BranchExpectedParameterDifference>(_bd));
    type_of_OCT_branch = sim::Comm::ParameterDifference;
    num_of_OCT_branch++;
  } else {
  }
}
 
void BranchRecord::addProcedureStep(int _operator, BranchProcedureStep *_bd) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.procedure_step.push_back(shared_ptr<BranchProcedureStep>(_bd));
    type_of_ODM_branch = sim::Branch::Procedure;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.procedure_step.push_back(shared_ptr<BranchProcedureStep>(_bd));
    type_of_OAT_branch = sim::Branch::Procedure;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.procedure_step.push_back(shared_ptr<BranchProcedureStep>(_bd));
    type_of_OCT_branch = sim::Branch::Procedure;
    num_of_OCT_branch++;
  } else {
  }
}
void BranchRecord::addInstinctiveResponseProcedure(int _operator, BranchProcedureStep *_bd) {
  if (_operator == sim::Operator::ODM) {
    ODM_branch.instinctive_response_procedure.push_back(shared_ptr<BranchProcedureStep>(_bd));
    type_of_ODM_branch = sim::Strategy::InstinctiveResponse;
    num_of_ODM_branch++;
  } else if (_operator == sim::Operator::OAT) {
    OAT_branch.instinctive_response_procedure.push_back(shared_ptr<BranchProcedureStep>(_bd));
    type_of_OAT_branch = sim::Strategy::InstinctiveResponse;
    num_of_OAT_branch++;
  } else if (_operator == sim::Operator::OCT) {
    OCT_branch.instinctive_response_procedure.push_back(shared_ptr<BranchProcedureStep>(_bd));
    type_of_OCT_branch = sim::Strategy::InstinctiveResponse;
    num_of_OCT_branch++;
  } else {
  }
}
void BranchRecord::addHWReliabilityBranch(BranchSystemAction *_bp1, BranchSystemAction *_bp2) {
  auto container_pt = make_unique<VHWReliabilityUnit>();
  container_pt->push_back(unique_ptr<BranchSystemAction>(_bp1));
  container_pt->push_back(unique_ptr<BranchSystemAction>(_bp2));
  HW_reliability_branch.push_back(std::move(container_pt));
  num_of_HWReliability_branch = 1;
  for (auto &hw : HW_reliability_branch) {
    num_of_HWReliability_branch *= hw->size();
  }
}
void BranchRecord::addHWReliabilityBranch(BranchSystemAction *_bp1) {
  auto container_pt = make_unique<VHWReliabilityUnit>();
  container_pt->push_back(unique_ptr<BranchSystemAction>(_bp1));
  HW_reliability_branch.push_back(std::move(container_pt));
  num_of_HWReliability_branch = 1;
  for (auto &hw : HW_reliability_branch) {
    num_of_HWReliability_branch *= hw->size();
  }
}
void BranchRecord::addSSReliabilityBranch(BranchSupportSystemAction *_bssa1, BranchSupportSystemAction *_bssa2) {
  auto container_pt = make_unique<VSSReliabilityUnit>();
  container_pt->push_back(unique_ptr<BranchSupportSystemAction>(_bssa1));
  container_pt->push_back(unique_ptr<BranchSupportSystemAction>(_bssa2));
  SS_reliability_branch.push_back(std::move(container_pt));
  num_of_SSReliability_branch = 1;
  for (auto &ss : SS_reliability_branch) {
    num_of_SSReliability_branch *= ss->size();
  }
}
void BranchRecord::addSSReliabilityBranch(BranchSupportSystemAction *_bssa) {
  auto container_pt = make_unique<VSSReliabilityUnit>();
  container_pt->push_back(unique_ptr<BranchSupportSystemAction>(_bssa));
  SS_reliability_branch.push_back(std::move(container_pt));
  num_of_SSReliability_branch = 1;
  for (auto &ss : SS_reliability_branch) {
    num_of_SSReliability_branch *= ss->size();
  }
}
void BranchRecord::addSystemAlarms(BranchSystemAlarmState *_sap) {
  system_branch.push_back(unique_ptr<BranchSystemAlarmState>(_sap));
}
 
void BranchRecord::calculateTotalNumberOfBranch() {
  bool branch_generated = false;
  total_number_of_branches = 0;
  if (num_of_ODM_branch != 0) {
    total_number_of_branches = num_of_ODM_branch;
    branch_generated = true;
  }
  if (num_of_OAT_branch != 0) {
    if (branch_generated) {
      total_number_of_branches *= num_of_OAT_branch;
    } else {
      total_number_of_branches = num_of_OAT_branch;
      branch_generated = true;
    }
  }
  if (num_of_OCT_branch != 0) {
    if (branch_generated) {
      total_number_of_branches *= num_of_OCT_branch;
    } else {
      total_number_of_branches = num_of_OCT_branch;
      branch_generated = true;
    }
  }
  if (num_of_HWReliability_branch != 0) {
    if (branch_generated) {
      total_number_of_branches *= num_of_HWReliability_branch;
    } else {
      total_number_of_branches = num_of_HWReliability_branch;
      branch_generated = true;
    }
  }
  if (num_of_SSReliability_branch != 0) {
    if (branch_generated) {
      total_number_of_branches *= num_of_SSReliability_branch;
    } else {
      total_number_of_branches = num_of_SSReliability_branch;
      branch_generated = true;
    }
  }
  if ((total_number_of_branches == 0) && (system_branch.size() > 0)) {
    total_number_of_branches = 1;
  }
}
//  BranchUnit ODM_branch, OAT_branch, OCT_branch;
 
// Minimum branch probability (env ADS_BRANCH_FLOOR, default 0.0 = off). Applied
// per fork BEFORE the cluster cross-product is formed: an alternative whose
// conditional probability is below the floor is not generated, and its mass is
// added to the fork's continuing alternative (index 0, the choice the running
// sequence takes), so each fork still sums to 1 and no probability leaks. A fork
// reduced to its continuing alternative contributes a factor of 1 to the
// product; a cluster of a single branch injects its content and opens no
// restart point.
namespace {
// Threshold for forks registered with a SINGLE alternative of probability
// p < 1. Their implicit complement (1 - p) is never a branch, so the sequence
// carries p and the mass (1 - p) is not represented in the tree (initiating
// events are single-branch by design). A complement below this threshold is
// folded back, p := 1.
// The value is env ADS_BRANCH_FLOOR_SINGLE, read once per process; when the
// variable is unset or negative the threshold is the floor passed in. Returns
// the threshold to compare (1 - p) against. It only takes effect when
// ADS_BRANCH_FLOOR is above zero, because the fold does not run otherwise.
double singleFloor(double floor) {
  static const double v = [] {
    const char *s = std::getenv("ADS_BRANCH_FLOOR_SINGLE");
    return s ? std::atof(s) : -1.0;
  }();
  return v >= 0.0 ? v : floor;
}
// Folds one fork in place. `alternatives` is the fork's vector of (smart)
// pointers to items that have getProbability()/setProbability().
//  - empty fork: nothing happens.
//  - one alternative with probability p < 1: if (1 - p) < singleFloor(floor),
//    p is set to 1.0; otherwise it is left alone.
//  - two or more alternatives: scanning from the last index down to index 1,
//    every alternative with probability < floor is erased and its probability
//    is summed; the sum is then added to alternative 0. Alternative 0 is never
//    erased, whatever its probability. Survivors keep their relative order.
template <class Vec>
void foldBelowFloor(Vec &alternatives, double floor) {
  if (alternatives.empty()) return;
  if (alternatives.size() == 1) {
    double p = alternatives[0]->getProbability();
    if (p < 1.0 && (1.0 - p) < singleFloor(floor)) alternatives[0]->setProbability(1.0);
    return;
  }
  double folded = 0.0;
  for (size_t k = alternatives.size(); k-- > 1;) {
    double p = alternatives[k]->getProbability();
    if (p < floor) {
      folded += p;
      alternatives.erase(alternatives.begin() + static_cast<long>(k));
    }
  }
  if (folded > 0.0) alternatives[0]->setProbability(alternatives[0]->getProbability() + folded);
}
// Folds the crew fork of one operator. `type` is the operator's pending branch
// type (type_of_ODM_branch and its OAT/OCT counterparts) and selects the vector
// of `bu` that holds the fork's alternatives. Returns the fork's alternative
// count after folding, or -1 for a type that has no vector here (nothing is
// folded in that case).
int foldCrewFork(BranchUnit &bu, int type, double floor) {
  switch (type) {
    case sim::Decision::Goal: foldBelowFloor(bu.goal, floor); return static_cast<int>(bu.goal.size());
    case sim::Decision::Strategy: foldBelowFloor(bu.strategy, floor); return static_cast<int>(bu.strategy.size());
    case sim::Decision::SubGoal: foldBelowFloor(bu.subgoal, floor); return static_cast<int>(bu.subgoal.size());
    case sim::Decision::Diagnosis: foldBelowFloor(bu.diagnosis, floor); return static_cast<int>(bu.diagnosis.size());
    case sim::Action::Objective: foldBelowFloor(bu.action_objective, floor); return static_cast<int>(bu.action_objective.size());
    case sim::Action::Pack: foldBelowFloor(bu.action_pack, floor); return static_cast<int>(bu.action_pack.size());
    case sim::Action::Action: foldBelowFloor(bu.action, floor); return static_cast<int>(bu.action.size());
    case sim::Comm::AlarmState: foldBelowFloor(bu.alarm_state, floor); return static_cast<int>(bu.alarm_state.size());
    case sim::Comm::ComponentState: foldBelowFloor(bu.component_state, floor); return static_cast<int>(bu.component_state.size());
    case sim::Comm::SupportSystemState: foldBelowFloor(bu.support_system_state, floor); return static_cast<int>(bu.support_system_state.size());
    case sim::Comm::ParameterTrend: foldBelowFloor(bu.parameter_trend, floor); return static_cast<int>(bu.parameter_trend.size());
    case sim::Comm::ParameterValue: foldBelowFloor(bu.parameter_value, floor); return static_cast<int>(bu.parameter_value.size());
    case sim::Comm::ParameterDifference: foldBelowFloor(bu.parameter_difference, floor); return static_cast<int>(bu.parameter_difference.size());
    case sim::Branch::Procedure: foldBelowFloor(bu.procedure_step, floor); return static_cast<int>(bu.procedure_step.size());
    case sim::Strategy::InstinctiveResponse: foldBelowFloor(bu.instinctive_response_procedure, floor); return static_cast<int>(bu.instinctive_response_procedure.size());
    case sim::Branch::InfoGatherMode: foldBelowFloor(bu.info_gather_mode, floor); return static_cast<int>(bu.info_gather_mode.size());
    case sim::Branch::MentalBelief: foldBelowFloor(bu.mental_belief, floor); return static_cast<int>(bu.mental_belief.size());
    case sim::ControlAction::ParameterScan: foldBelowFloor(bu.scanned_parameter, floor); return static_cast<int>(bu.scanned_parameter.size());
    default: return -1;
  }
}
}  // namespace
 
// Folds every pending fork (ODM, OAT, OCT crew forks, each hardware and each
// support system reliability fork) and refreshes the per-source branch counts:
// a crew count becomes the size of its folded fork, the hardware and support
// system counts become the product of their folded fork sizes. System alarm
// content (system_branch) is not touched.
void BranchRecord::applyBranchProbabilityFloor(double floor) {
  int n;
  if (num_of_ODM_branch >= 1 && (n = foldCrewFork(ODM_branch, type_of_ODM_branch, floor)) >= 0) num_of_ODM_branch = n;
  if (num_of_OAT_branch >= 1 && (n = foldCrewFork(OAT_branch, type_of_OAT_branch, floor)) >= 0) num_of_OAT_branch = n;
  if (num_of_OCT_branch >= 1 && (n = foldCrewFork(OCT_branch, type_of_OCT_branch, floor)) >= 0) num_of_OCT_branch = n;
  if (num_of_HWReliability_branch >= 1) {
    for (auto &hw : HW_reliability_branch) foldBelowFloor(*hw, floor);
    num_of_HWReliability_branch = 1;
    for (auto &hw : HW_reliability_branch) num_of_HWReliability_branch *= static_cast<int>(hw->size());
  }
  if (num_of_SSReliability_branch >= 1) {
    for (auto &ss : SS_reliability_branch) foldBelowFloor(*ss, floor);
    num_of_SSReliability_branch = 1;
    for (auto &ss : SS_reliability_branch) num_of_SSReliability_branch *= static_cast<int>(ss->size());
  }
}
 
int BranchRecord::checkAndAddBranchCluster() {
  int i, j, k, n, section_size, section_size1, num_element_repeat, num_unit_repeat, num_element_repeat1,
      num_unit_repeat1;
  static const double branch_floor = [] {
    const char *v = std::getenv("ADS_BRANCH_FLOOR");
    return v ? std::atof(v) : 0.0;
  }();
  if (branch_floor > 0.0) this->applyBranchProbabilityFloor(branch_floor);
  BranchCluster *mother_bc_pt;
  BranchProbability *mother_branch_pt;
  double bc_probability;
  vector<unique_ptr<BranchSystemActionVector>> branch_system_action_matrix;
  decltype(branch_system_action_matrix)::iterator bsam_itr;
  vector<unique_ptr<BranchSupportSystemActionVector>> branch_support_system_action_matrix;
  decltype(branch_support_system_action_matrix)::iterator bssam_itr;
  BranchSystemAction *bsa_pt;
  BranchSupportSystemAction *bssa_pt;
  //
  this->calculateTotalNumberOfBranch();
    if (total_number_of_branches <= 0) return 0;
  auto bc_upt = make_unique<BranchCluster>();
  auto *bc_pt = bc_upt.get();
  bc_pt->setTimeAtWhichThisEventHappen(r5pars_.timesno);
  for (i = 0; i < total_number_of_branches; i++) {
    bc_pt->all_branch.push_back(make_unique<BranchProbability>());
  }
  num_element_repeat = total_number_of_branches;
  section_size = total_number_of_branches;
  if (num_of_ODM_branch > 0) {
    num_unit_repeat = total_number_of_branches / section_size;
    num_element_repeat = section_size / num_of_ODM_branch;
    section_size = num_element_repeat;
    for (i = 1; i <= num_unit_repeat; i++) {
      this->addCrewContentToExpandedBranch(ODM_branch, *bc_pt, type_of_ODM_branch, num_element_repeat, i);
    }
  }
  if (num_of_OAT_branch > 0) {
    num_unit_repeat = total_number_of_branches / section_size;
    num_element_repeat = section_size / num_of_OAT_branch;
    section_size = num_element_repeat;
    for (i = 1; i <= num_unit_repeat; i++) {
      this->addCrewContentToExpandedBranch(OAT_branch, *bc_pt, type_of_OAT_branch, num_element_repeat, i);
    }
  }
  if (num_of_OCT_branch > 0) {
    num_unit_repeat = total_number_of_branches / section_size;
    num_element_repeat = section_size / num_of_OCT_branch;
    section_size = num_element_repeat;
    for (i = 1; i <= num_unit_repeat; i++) {
      this->addCrewContentToExpandedBranch(OCT_branch, *bc_pt, type_of_OCT_branch, num_element_repeat, i);
    }
  }
  //
  if (num_of_HWReliability_branch > 0) {
    if (HW_reliability_branch.size() == 1) {
      num_unit_repeat = total_number_of_branches / section_size;
      num_element_repeat = section_size / num_of_HWReliability_branch;
      section_size = num_element_repeat;
      for (i = 1; i <= num_unit_repeat; i++) {
        this->addHWContentToExpandedBranch(HW_reliability_branch, *bc_pt, num_element_repeat, i);
      }
    } else {
      //vector<BranchSystemActionVector *> branch_system_action_matrix;
      for (i = 0; i < num_of_HWReliability_branch; i++) {
        branch_system_action_matrix.push_back(make_unique<BranchSystemActionVector>());
      }
      section_size1 = num_of_HWReliability_branch;
      for (auto &hw_container : HW_reliability_branch) {
        num_unit_repeat1 = num_of_HWReliability_branch / section_size1;
        num_element_repeat1 = section_size1 / hw_container->size();
        section_size1 = num_element_repeat1;
        for (i = 1; i <= num_unit_repeat1; i++) {
          k = 0;
          for (auto &bsa_src : *hw_container) {
            k++;
            for (j = 0; j < num_element_repeat1; j++) {
              bsa_pt = new BranchSystemAction();
              bsa_pt->copyBranchSystemAction(*bsa_src);
              n = (i - 1) * (hw_container->size() * num_element_repeat1) + (k - 1) * num_element_repeat1 + j;
              branch_system_action_matrix.at(n)->branch_system_action_vector.push_back(unique_ptr<BranchSystemAction>(bsa_pt));
            }
          }
        }
      }
      num_unit_repeat = total_number_of_branches / section_size;
      num_element_repeat = section_size / num_of_HWReliability_branch;
      section_size = num_element_repeat;
      for (i = 1; i <= num_unit_repeat; i++) {
        k = 0;
        for (bsam_itr = branch_system_action_matrix.begin(); bsam_itr != branch_system_action_matrix.end();
             bsam_itr++) {
          k++;
          for (j = 0; j < num_element_repeat; j++) {
            n = (i - 1) * branch_system_action_matrix.size() + (k - 1) * num_element_repeat + j;
            auto *bp_pt = bc_pt->all_branch.at(n).get();
            for (auto &bsa_src : (*bsam_itr)->branch_system_action_vector) {
              bsa_pt = new BranchSystemAction();
              bsa_pt->copyBranchSystemAction(*bsa_src);
              bp_pt->HW_reliability.push_back(shared_ptr<BranchSystemAction>(bsa_pt));
            }
          }
        }
 
      }
      branch_system_action_matrix.clear();
    }
  }
  //
  if (num_of_SSReliability_branch > 0) {
    if (SS_reliability_branch.size() == 1) {
      num_unit_repeat = total_number_of_branches / section_size;
      num_element_repeat = section_size / num_of_SSReliability_branch;
      section_size = num_element_repeat;
      for (i = 1; i <= num_unit_repeat; i++) {
        this->addSSContentToExpandedBranch(SS_reliability_branch, *bc_pt, num_element_repeat, i);
      }
    } else {
      for (i = 0; i < num_of_SSReliability_branch; i++) {
        branch_support_system_action_matrix.push_back(make_unique<BranchSupportSystemActionVector>());
      }
      section_size1 = num_of_SSReliability_branch;
      for (auto &ss_container : SS_reliability_branch) {
        num_unit_repeat1 = num_of_SSReliability_branch / section_size1;
        num_element_repeat1 = section_size1 / ss_container->size();
        section_size1 = num_element_repeat1;
        for (i = 1; i <= num_unit_repeat1; i++) {
          k = 0;
          for (auto &bssa_src : *ss_container) {
            k++;
            for (j = 0; j < num_element_repeat1; j++) {
              bssa_pt = new BranchSupportSystemAction();
              bssa_pt->copyBranchSupportSystemAction(*bssa_src);
              n = (i - 1) * (ss_container->size() * num_element_repeat1) + (k - 1) * num_element_repeat1 + j;
              branch_support_system_action_matrix.at(n)->branch_support_system_action_vector.push_back(unique_ptr<BranchSupportSystemAction>(bssa_pt));
            }
          }
        }
      }
      num_unit_repeat = total_number_of_branches / section_size;
      num_element_repeat = section_size / num_of_SSReliability_branch;
      section_size = num_element_repeat;
      for (i = 1; i <= num_unit_repeat; i++) {
        k = 0;
        for (bssam_itr = branch_support_system_action_matrix.begin();
             bssam_itr != branch_support_system_action_matrix.end();
             bssam_itr++) {
          k++;
          for (j = 0; j < num_element_repeat; j++) {
            n = (i - 1) * branch_support_system_action_matrix.size() + (k - 1) * num_element_repeat + j;
            auto *bp_pt = bc_pt->all_branch.at(n).get();
            for (auto &bssa_src : (*bssam_itr)->branch_support_system_action_vector) {
              bssa_pt = new BranchSupportSystemAction();
              bssa_pt->copyBranchSupportSystemAction(*bssa_src);
              bp_pt->SS_reliability.push_back(shared_ptr<BranchSupportSystemAction>(bssa_pt));
            }
          }
        }
 
      }
      branch_support_system_action_matrix.clear();
    }
  }
  //
  if (system_branch.size() > 0) {
    for (auto &sb_src : system_branch) {
      for (i = 0; i < total_number_of_branches; i++) {
        auto spt = new BranchSystemAlarmState();
        spt->copyBranchSystemAlarmState(*sb_src);
        bc_pt->all_branch.at(i)->new_alarm.push_back(shared_ptr<BranchSystemAlarmState>(spt));
      }
    }
  }
//
  bc_pt->setNCountForRestartRELAP5(r5pars_.cncount);
/*
CONSOLE_Mode    0
NetClient_Mode  1
NetSrv_Mode     2
*/
  if (r5pars_.tsimmode == static_cast<int>(ConsoleMode::Console)) {
    //Dealing with Current related parameters
    ID_of_recent_generated_branch_cluster++;
    ID_of_recent_generated_branch++;
    bc_pt->setIDOfThisBranchCluster(ID_of_recent_generated_branch_cluster);
    bc_pt->setCurrentBranchNum(0);
    bc_pt->all_branch.at(0)->setIDOfThisBranch(ID_of_recent_generated_branch);
    // DIAG: log cluster creation with RELAP5 time as physics fingerprint
    // Enable via environment variable: ADSIDAC_BRANCH_DIAG=1
    if (getenv("ADSIDAC_BRANCH_DIAG"))
        fprintf(stderr, "[BRANCH-DIAG] t=%.4f branches=%zu CID=%d br0_id=%d mother_cid=%d mother_br=%d\n",
            r5pars_.timesno, bc_pt->all_branch.size(),
            ID_of_recent_generated_branch_cluster,
            ID_of_recent_generated_branch, ID_of_mother_cluster, ID_of_mother_branch);
    // SEQ-FP: track branching events for per-sequence fingerprinting
    g_sim.current_seq_events.emplace_back(r5pars_.timesno, static_cast<int>(bc_pt->all_branch.size()));
    bc_pt->setIDOfMotherCluster(ID_of_mother_cluster);
    if (this->getIDOfRecentGeneratedBranchCluster() != 0) {
      mother_bc_pt = this->findBrnachCluster(ID_of_mother_cluster);
      mother_branch_pt = mother_bc_pt->findBranch(ID_of_mother_branch);
      mother_branch_pt->setIDOfTheChildBranchCluster(bc_pt->getIDOfThisBranchCluster());
      mother_branch_pt->setTypeOfChild(sim::Branch::Branch);
      mother_branch_pt->child_IDs.push_back(ID_of_recent_generated_branch);
      bc_probability = mother_branch_pt->getUnconditionalBranchProbability();
      bc_pt->setProbability(bc_probability);
    } else {
      bc_pt->setProbability(1.0);
    }
    n = bc_pt->getIDOfThisBranchCluster();
    for (auto &ab : bc_pt->all_branch) {
      ab->setIDOfTheAssociatedBranchCluster(n);
      ab->calculateProbability();
      ab->calUnconditionalBranchProbability(bc_pt->getProbability());
    }
    this->setRecentUnconditionalBranchProbability(bc_pt->all_branch.at(0)->getUnconditionalBranchProbability());
    //Dealing with Mother related parameters
    //send branch info to command center
    bc_pt->setIDOfTheMotherBranch(ID_of_mother_branch);
    ID_of_mother_cluster = ID_of_recent_generated_branch_cluster;
    ID_of_mother_branch = ID_of_recent_generated_branch;
    auto num_branches = bc_pt->all_branch.size();
    this->branch_cluster.push_back(std::move(bc_upt));
    this->clearBranches();
    return num_branches;
  } else {
//         #ifndef _CONSOLE
//          ID_of_recent_generated_branch_cluster = SScheduler.getClusterNodeSequenceFromSrv();
// //difference between the two versions from Kevin
// //update to the Aug. 2011 version
//          //
//          bc_pt->setIDOfMotherCluster(ID_of_mother_cluster);          
//          //
//          //
//          bc_pt->setIDOfThisBranchCluster(ID_of_recent_generated_branch_cluster);
//          bc_pt->setCurrentBranchNum(0);
//          //calculate the branch probility (NOT conditional probability)
// //difference between the two versions from Kevin
// //update to the Aug. 2011 version
//          if(this->getIDOfRecentGeneratedBranchCluster() != 0)
//          {
//                 bc_pt->setIDOfMotherCluster(ID_of_mother_cluster);
 
//              mother_bc_pt = this->findBrnachCluster(ID_of_mother_cluster);
//              mother_branch_pt = mother_bc_pt->findBranch(ID_of_mother_branch); 
//              mother_branch_pt->setIDOfTheChildBranchCluster(bc_pt->getIDOfThisBranchCluster());
//              mother_branch_pt->setTypeOfChild(sim::Branch::Branch);
// //               mother_branch_pt->child_IDs.push_back(ID_of_recent_generated_branch);
//              bc_probability = mother_branch_pt->getUnconditionalBranchProbability();
//              bc_pt->setProbability(bc_probability);
//          }
//          else{ // The first branch cluster 
//              bc_pt->setProbability(1.0);
//          }
//          n = bc_pt->getIDOfThisBranchCluster();
// //difference between the two versions from Kevin
// //update to the Aug. 2011 version
//          bc_pt->setIDOfTheMotherBranch(ID_of_mother_branch);
//          for(all_branch_itr = bc_pt->all_branch.begin(); all_branch_itr != bc_pt->all_branch.end(); all_branch_itr++){
//                 // Get a unique ID number from server for each branch
//              ID_of_recent_generated_branch = SScheduler.getPENodeSequenceFromSrv();
 
//              if(this->getIDOfRecentGeneratedBranchCluster() != 0){
//                  mother_branch_pt->child_IDs.push_back(ID_of_recent_generated_branch);
//                 }
//              if(all_branch_itr == bc_pt->all_branch.begin()){
//                  ID_of_mother_branch = ID_of_recent_generated_branch;
//              }
//              (*all_branch_itr)->setIDOfTheAssociatedBranchCluster(n);
//              (*all_branch_itr)->calculateProbability();
//              (*all_branch_itr)->calUnconditionalBranchProbability(bc_pt->getProbability());
//              (*all_branch_itr)->setIDOfThisBranch(ID_of_recent_generated_branch);
//          }
//          this->setRecentUnconditionalBranchProbability(bc_pt->all_branch.at(0)->getUnconditionalBranchProbability());
//          //Dealing with Mother related parameters
//          //send branch info to command center
// //difference between the two versions from Kevin
// //update to the Aug. 2011 version
//          ID_of_mother_cluster = ID_of_recent_generated_branch_cluster;
//          this->branch_cluster.push_back(bc_pt);
//          this->clearBranches();
//         #endif
    return bc_pt->all_branch.size();
  }
}
void BranchRecord::sendCurrentBranchCommandToCommandCenter() {
  bool found_branch_cluster = false;
  bool found_branch = false;
  auto branch_cluster_ritr = g_sim.Branch_center.branch_cluster.rbegin();
  while (branch_cluster_ritr != g_sim.Branch_center.branch_cluster.rend() && !found_branch_cluster) {
    if ((*branch_cluster_ritr)->getIDOfThisBranchCluster() == ID_of_recent_generated_branch_cluster) {
      found_branch_cluster = true;
      auto all_branch_itr = (*branch_cluster_ritr)->all_branch.begin();
      while (all_branch_itr != (*branch_cluster_ritr)->all_branch.end() && !found_branch) {
        if (r5pars_.tsimmode == static_cast<int>(ConsoleMode::Console)) {
          //console mode
          if ((*all_branch_itr)->getIDOfThisBranch() == ID_of_recent_generated_branch) {
            found_branch = true;
            (*all_branch_itr)->sendBranchInfoToCommandCenter(ID_of_recent_generated_branch);
            (*all_branch_itr)->setStateOfActivation(sim::State::Succeed);
          }
        } else {
          // multiprocessor version
          //if((*all_branch_itr)->getIDOfThisBranch() == (this->ID_of_recent_generated_branch - ((*branch_cluster_ritr)->all_branch.size() - 1))){
          if ((*all_branch_itr)->getStateOfActivation() != sim::State::Succeed) {
            found_branch = true;
            (*all_branch_itr)->sendBranchInfoToCommandCenter((*all_branch_itr)->getIDOfThisBranch());
            (*all_branch_itr)->setStateOfActivation(sim::State::Succeed);
          }
        }
        all_branch_itr++;
      }
    }
    branch_cluster_ritr++;
  }
  if (!found_branch_cluster || !found_branch) {
    ofstream fout("err messages.txt", ios::app);
    cout << "BranchRecord::sendCurrentBranchCommandToCommandCenter Branch Cluster ID: "
         << ID_of_recent_generated_branch_cluster
         << "; or Branch ID: " << ID_of_recent_generated_branch << " can not be found" << endl;
    fout << r5pars_.timesno << "  BranchRecord::sendCurrentBranchCommandToCommandCenter Branch Cluster ID: "
         << ID_of_recent_generated_branch_cluster
         << "; or Branch ID: " << ID_of_recent_generated_branch << " can not be found\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("BranchRecord::sendCurrentBranchCommandToCommandCenter err");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
}
/*------------------------
Function sendSpecifiedBranchCommandToCommandCenter(int) is called only at the beginning when a client 
is called by the server start to run a sequence.  After the node information is loaded into the client, 
this function applies the specified branch information to overwrite the node information.  The branch information
sent from the Server is stored at the last BranchCluster of the BranchRecord::branch_cluster.
---------------------------*/
void BranchRecord::sendSpecifiedBranchCommandToCommandCenter(int n_th_branch) {
  bool found_branch = false;
  auto branch_cluster_ritr = g_sim.Branch_center.branch_cluster.rbegin();
  BranchProbability *all_branch_pt;
  if (branch_cluster_ritr == g_sim.Branch_center.branch_cluster.rend()) {
    //At the beginning of a simulation, the server pass the very first restart information to a client.
    //There is no branch generated for this restart.  Client do nothing here
    found_branch = true;
  } else {
    if (n_th_branch < (*branch_cluster_ritr)->all_branch.size()) {
      all_branch_pt = (*branch_cluster_ritr)->all_branch.at(n_th_branch).get();
      //
      ofstream fout("err messages.txt", ios::app);
      fout << "Restart Branch Cluster: " << (*branch_cluster_ritr)->getIDOfThisBranchCluster() << "  Cluster Branch: "
           << n_th_branch << "  BranchID: " << all_branch_pt->getIDOfThisBranch() << "   Branch UnCondProbability:  "
           << (all_branch_pt)->getUnconditionalBranchProbability() << '\n';
      fout.close();
      //
      all_branch_pt->sendBranchInfoToCommandCenter(all_branch_pt->getIDOfThisBranch());
      all_branch_pt->setStateOfActivation(sim::State::Succeed);
      //
      this->setIDOfMotherBranch(all_branch_pt->getIDOfThisBranch());
      //
      //Update recent unconditional branch probability
      this->setRecentUnconditionalBranchProbability((all_branch_pt)->getUnconditionalBranchProbability());
      //
      found_branch = true;
    }
  }
  if (!found_branch) {
    ofstream fout("err messages.txt", ios::app);
    cout << "BranchRecord:sendSpecifiedBranchCommandToCommandCenter n_th_branch: " << n_th_branch
         << " exceeds the size of all_branch: " << (*branch_cluster_ritr)->all_branch.size() << endl;
    fout << r5pars_.timesno << "  BranchRecord:sendSpecifiedBranchCommandToCommandCenter n_th_branch: " << n_th_branch
         << " exceeds the size of all_branch: " << (*branch_cluster_ritr)->all_branch.size() << '\n';
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("BranchRecord:sendSpecifiedBranchCommandToCommandCenter err");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
}
void BranchRecord::addCrewContentToExpandedBranch(BranchUnit &_bu,
                                                  BranchCluster &bc_ref,
                                                  int type_of_branch,
                                                  int num_of_single_element_repeat,
                                                  int nth_unit_appear) {
  int i, j, k;
 
  switch (type_of_branch) {
    case sim::Decision::Goal: j = 0;
      for (auto &src : _bu.goal) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchGoal>();
          p->copyBranchGoal(*src);
          k = (nth_unit_appear - 1) * _bu.goal.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->goal.push_back(std::move(p));
        }
        j++;
      }
      break;
    case sim::Decision::Strategy: j = 0;
      for (auto &src : _bu.strategy) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchStrategy>();
          p->copyBranchStrategy(*src);
          k = (nth_unit_appear - 1) * _bu.strategy.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->strategy.push_back(std::move(p));
        }
        j++;
      }
      break;
    case sim::Decision::SubGoal: j = 0;
      for (auto &src : _bu.subgoal) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchSubGoal>();
          p->copyBranchSubGoal(*src);
          k = (nth_unit_appear - 1) * _bu.subgoal.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->subgoal.push_back(std::move(p));
        }
        j++;
      }
      break;
    case sim::Decision::Diagnosis: j = 0;
      for (auto &src : _bu.diagnosis) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchDiagnosis>();
          p->copyBranchDiagnosis(*src);
          k = (nth_unit_appear - 1) * _bu.diagnosis.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->diagnosis.push_back(std::move(p));
        }
        j++;
      }
      break;
    case sim::Action::Objective: j = 0;
      for (auto &src : _bu.action_objective) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchActionObjective>();
          p->copyBranchActionObjective(*src);
          k = (nth_unit_appear - 1) * _bu.action_objective.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->action_objective.push_back(std::move(p));
        }
        j++;
      }
      break;
    case sim::Action::Pack: j = 0;
      for (auto &src : _bu.action_pack) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchActionPack>();
          p->copyBranchActionPack(*src);
          k = (nth_unit_appear - 1) * _bu.action_pack.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->action_pack.push_back(std::move(p));
        }
        j++;
      }
      break;
    case sim::Action::Action: j = 0;
      for (auto &src : _bu.action) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchAction>();
          p->copyBranchAction(*src);
          k = (nth_unit_appear - 1) * _bu.action.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->action.push_back(std::move(p));
        }
        j++;
      }
      break;
    case sim::Comm::AlarmState: j = 0;
      for (auto &src : _bu.alarm_state) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchExpectedAlarmState>();
          p->copyBranchExpectedAlarmState(*src);
          k = (nth_unit_appear - 1) * _bu.alarm_state.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->alarm_state.push_back(std::move(p));
        }
        j++;
      }
      break;
    case sim::Comm::ComponentState: j = 0;
      for (auto &src : _bu.component_state) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchExpectedComponentState>();
          p->copyBranchExpectedComponentState(*src);
          k = (nth_unit_appear - 1) * _bu.component_state.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->component_state.push_back(std::move(p));
        }
        j++;
      }
      break;
    case sim::Comm::SupportSystemState: j = 0;
      for (auto &src : _bu.support_system_state) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchExpectedSupportSystemState>();
          p->copyBranchExpectedSupportSystemState(*src);
          k = (nth_unit_appear - 1) * _bu.support_system_state.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->support_system_state.push_back(std::move(p));
        }
        j++;
      }
      break;
    case sim::Comm::ParameterTrend: j = 0;
      for (auto &src : _bu.parameter_trend) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchExpectedParameterTrend>();
          p->copyBranchExpectedParameterTrend(*src);
          k = (nth_unit_appear - 1) * _bu.parameter_trend.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->parameter_trend.push_back(std::move(p));
        }
        j++;
      }
      break;
    case sim::Comm::ParameterValue: j = 0;
      for (auto &src : _bu.parameter_value) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchExpectedParameterValue>();
          p->copyBranchExpectedParameterValue(*src);
          k = (nth_unit_appear - 1) * _bu.parameter_value.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->parameter_value.push_back(std::move(p));
        }
        j++;
      }
      break;
 
    case sim::Comm::ParameterDifference: j = 0;
      for (auto &src : _bu.parameter_difference) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchExpectedParameterDifference>();
          p->copyBranchExpectedParameterDifference(*src);
          k = (nth_unit_appear - 1) * _bu.parameter_difference.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->parameter_difference.push_back(std::move(p));
        }
        j++;
      }
      break;
 
    case sim::Branch::Procedure: j = 0;
      for (auto &src : _bu.procedure_step) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchProcedureStep>();
          p->copyBranchProcedureStep(*src);
          k = (nth_unit_appear - 1) * _bu.procedure_step.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->procedure_step.push_back(std::move(p));
        }
        j++;
      }
      break;
    case sim::Strategy::InstinctiveResponse: j = 0;
      for (auto &src : _bu.instinctive_response_procedure) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchProcedureStep>();
          p->copyBranchProcedureStep(*src);
          k = (nth_unit_appear - 1) * _bu.instinctive_response_procedure.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->instinctive_response_procedure.push_back(std::move(p));
        }
        j++;
      }
      break;
    case sim::Branch::InfoGatherMode: j = 0;
      for (auto &src : _bu.info_gather_mode) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchInfoGatherMode>();
          p->copyBranchInfoGatherMode(*src);
          k = (nth_unit_appear - 1) * _bu.info_gather_mode.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->info_gather_mode.push_back(std::move(p));
        }
        j++;
      }
      break;
    case sim::Branch::MentalBelief: j = 0;
      for (auto &src : _bu.mental_belief) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchExpectedMentalBelief>();
          p->copyBranchExpectedMentalBelief(*src);
          k = (nth_unit_appear - 1) * _bu.mental_belief.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->mental_belief.push_back(std::move(p));
        }
        j++;
      }
      break;
 
    case sim::ControlAction::ParameterScan: j = 0;
      for (auto &src : _bu.scanned_parameter) {
        for (i = 0; i < num_of_single_element_repeat; i++) {
          auto p = make_shared<BranchScannedParameter>();
          p->copyBranchScannedParameter(*src);
          k = (nth_unit_appear - 1) * _bu.scanned_parameter.size() + j * num_of_single_element_repeat + i;
          bc_ref.all_branch.at(k)->scanned_parameter.push_back(std::move(p));
        }
        j++;
      }
      break;
 
    default:
      //error message
      break;
  }
}
 
void BranchRecord::addHWContentToExpandedBranch(MHWReliabilityUnit &_bu,
                                                BranchCluster &bc_ref,
                                                int num_of_single_element_repeat,
                                                int nth_unit_appear) {
  int i, j, k;
  auto &first_unit = *_bu.begin();
  j = 0;
  for (auto &src : *first_unit) {
    for (i = 0; i < num_of_single_element_repeat; i++) {
      auto sa_pt = new BranchSystemAction();
      sa_pt->copyBranchSystemAction(*src);
      k = (nth_unit_appear - 1) * num_of_HWReliability_branch + j * num_of_single_element_repeat + i;
      bc_ref.all_branch.at(k)->HW_reliability.push_back(shared_ptr<BranchSystemAction>(sa_pt));
    }
    j++;
  }
}
void BranchRecord::addSSContentToExpandedBranch(MSSReliabilityUnit &_bu,
                                                BranchCluster &bc_ref,
                                                int num_of_single_element_repeat,
                                                int nth_unit_appear) {
  int i, j, k;
  auto &first_unit = *_bu.begin();
  j = 0;
  for (auto &src : *first_unit) {
    for (i = 0; i < num_of_single_element_repeat; i++) {
      auto ssa_pt = new BranchSupportSystemAction();
      ssa_pt->copyBranchSupportSystemAction(*src);
      k = (nth_unit_appear - 1) * num_of_SSReliability_branch + j * num_of_single_element_repeat + i;
      bc_ref.all_branch.at(k)->SS_reliability.push_back(shared_ptr<BranchSupportSystemAction>(ssa_pt));
    }
    j++;
  }
}
void BranchRecord::setIDOfRecentGeneratedBranch(int n) { ID_of_recent_generated_branch = n; }
void BranchRecord::setIDOfRecentGeneratedES(int n) { ID_of_recent_generated_ES = n; }
void BranchRecord::setIDOfRecentGeneratedBranchCluster(int n) { ID_of_recent_generated_branch_cluster = n; }
int BranchRecord::getIDOfRecentGeneratedBranch() { return ID_of_recent_generated_branch; }
int BranchRecord::getIDOfRecentGeneratedES() { return ID_of_recent_generated_ES; }
int BranchRecord::getIDOfRecentGeneratedBranchCluster() { return ID_of_recent_generated_branch_cluster; }
 
void BranchRecord::setRecentUnconditionalBranchProbability(double x) { recent_unconditional_branch_probability = x; }
double BranchRecord::getRecentUnconditionalBranchProbability() { return recent_unconditional_branch_probability; }
void BranchRecord::addAnEndState(BranchEndState *_es) {
  BranchProbability *mother_branch_pt;
  BranchCluster *mother_bc_pt;
  string str;
  r5pars_.csnostop = 3;
  int id_es;
  if (r5pars_.tsimmode == static_cast<int>(ConsoleMode::Console)) {
    //TODO: Check if this needs to change for different sequence names. Probably sequence ID is enough.
    _es->setIDOfThisEndState(++ID_of_recent_generated_ES);
    _es->setIDOfTheMotherBranch(ID_of_mother_branch);
    _es->setTimeAtWhichThisEventHappen(r5pars_.timesno);
    _es->setProbability(recent_unconditional_branch_probability);
    mother_bc_pt = this->findBrnachCluster(this->ID_of_mother_cluster);
    if (mother_bc_pt == 0) {
      r5pars_.terminateall = true;
    } else {
      mother_branch_pt = mother_bc_pt->findBranch(ID_of_mother_branch);
      mother_branch_pt->setIDOfTheChildBranchCluster(_es->getIDOfThisEndState());
      mother_branch_pt->setTypeOfChild(sim::Branch::EndState);
      mother_branch_pt->child_IDs.push_back(_es->getIDOfThisEndState());
    }
  } else {
//         #ifndef _CONSOLE
//          id_es = SScheduler.getESNodeSequenceFromSrv();
//          this->setIDOfRecentGeneratedES(id_es);
//          _es->setIDOfThisEndState(id_es);
//          //the value of ID_of_mother_branch might need to be rechecked later
//          _es->setIDOfTheMotherBranch(ID_of_mother_branch);
//          _es->setTimeAtWhichThisEventHappen(r5pars_.timesno);
//          _es->setProbability(recent_unconditional_branch_probability);
// //difference between the two versions from Kevin
// //update to the Aug. 2011 version
//          //
//          ofstream fout("err messages.txt", ios::app);
//          fout <<"End State ID: " <<  id_es << " Mother Branch: " << ID_of_mother_branch << "\n";
//          fout.close();
//          //
//         #endif
  }
  // In MPI mode the ID set here is rank-local and provisional; Client::save_sequence_outputs
  // rewrites the file under the authoritative global sequence ID. Writing here too leaves a
  // stale ZESNode_<provisional>.txt that can clobber a real sequence's file during the merge.
  if (!g_sim.config.is_mpi_environment) {
    _es->saveInfoToFile();
  }
  this->end_state.push_back(unique_ptr<BranchEndState>(_es));
}
int BranchRecord::getSizeOfSubFolder() { return size_of_subfolder; }
void BranchRecord::setSizeOfSubFolder(int n) { size_of_subfolder = n; }
void BranchRecord::clearBranchRecordAll() {
//
  branch_cluster.clear();
//
  end_state.clear();
  //
  ODM_branch.clearBranchUnit();
  OAT_branch.clearBranchUnit();
  OCT_branch.clearBranchUnit();
  HW_reliability_branch.clear();
  SS_reliability_branch.clear();
  system_branch.clear();
  this->source_of_procedure_time_branches.clearBranchProcedureAtionTime();
  this->mental_procedure_activation_branches.clearBranchMentalProcedureActivationTime();
  this->control_value_branches.clearBranchProcedureControlValue();
  type_of_ODM_branch = sim::None;
  type_of_OAT_branch = sim::None;
  type_of_OCT_branch = sim::None;
  total_number_of_branches = 0;
  num_of_ODM_branch = 0;
  num_of_OAT_branch = 0;
  num_of_OCT_branch = 0;
  num_of_HWReliability_branch = 0;
  num_of_SSReliability_branch = 0;
  //
  ID_of_recent_generated_branch = -1;//number to be used as PE_N; started from zero including the branch following g_sim.IE
  ID_of_recent_generated_ES = -1;
  ID_of_recent_generated_branch_cluster = -1;
  ID_of_mother_cluster = -1;
  ID_of_mother_branch = -1;
  recent_unconditional_branch_probability = 0.0;
  size_of_subfolder = 0;
  temp_es_message = "NONE";
  temp_type_of_consequence = Consequence::Succeed;
}
 
BranchCluster *BranchRecord::findBrnachCluster(int _id) {
  bool found = false;
  int dbg_i1;
  BranchCluster *bc_pt = 0;
  dbg_i1 = this->branch_cluster.size();
  auto bc_ritr = this->branch_cluster.rbegin();
  while (bc_ritr != branch_cluster.rend() && !found) {
    if ((*bc_ritr)->getIDOfThisBranchCluster() == _id) {
      found = true;
      bc_pt = bc_ritr->get();
    }
    bc_ritr++;
  }
  return bc_pt;
}
/*
void BranchRecord::saveAESNodeToFile(BranchEndState *_es_pt){
    _es_pt->saveInfoToFile();
    full_file_name = g_sim.SScheduler.getESDirectory();
    full_file_name += "ES_summary.txt";
    fout = new ofstream();
    fout->open(full_file_name.c_str(), ios::app);
    *fout << "ES#\tProbability\tEnd_time\tConsequence#\tDescription\n";
    *fout << _es_pt->getIDOfThisEndState() << '\t' 
        << _es_pt->getProbability() << '\t'
        << _es_pt->getTimeAtWhichThisEventHappen() << '\t'
        << static_cast<int>(_es_pt->getTypeOfConsequence()) << '\t'
        << _es_pt->getConsequenceDescription() << '\n';
    fout->close();
}*/
void BranchRecord::endSimulation() {
  ofstream fout_obj;
  ofstream *fout = &fout_obj;
  bool first_branch = true;
  string full_file_name, branch_name;
  //ES summary: append if resuming from checkpoint, overwrite otherwise
  full_file_name = g_sim.SScheduler.getESDirectory();
  full_file_name += "ES_summary.txt";
  if (!g_sim.config.resume_file.empty() && !g_sim.config.resume_has_end_states && std::filesystem::exists(full_file_name)) {
    // MPI→serial resume: append without header (phase 1 wrote per-sequence entries)
    fout->open(full_file_name.c_str(), ios::app);
  } else {
    // Fresh run or serial→serial resume (restored BranchRecord has complete end_state)
    fout->open(full_file_name.c_str(), ios::out);
    *fout << "ES#\tProbability\tEnd_time\tConsequence#\tDescription\n";
  }
  for (auto &es : end_state) {
    *fout << es->getIDOfThisEndState() << '\t'
          << es->getProbability() << '\t'
          << es->getTimeAtWhichThisEventHappen() << '\t'
          << static_cast<int>(es->getTypeOfConsequence()) << '\t'
          << es->getConsequenceDescription() << '\n';
  }
  fout->close();
}
void BranchRecord::appendEndStateSummary() {
  namespace fs = std::filesystem;
  string path = g_sim.SScheduler.getESDirectory() + "ES_summary.txt";
  bool needs_header = !fs::exists(path);
  ofstream fout(path.c_str(), ios::app);
  if (needs_header)
    fout << "ES#\tProbability\tEnd_time\tConsequence#\tDescription\n";
  if (!end_state.empty()) {
    auto* es = end_state.back().get();
    fout << es->getIDOfThisEndState() << '\t'
         << es->getProbability() << '\t'
         << es->getTimeAtWhichThisEventHappen() << '\t'
         << static_cast<int>(es->getTypeOfConsequence()) << '\t'
         << es->getConsequenceDescription() << '\n';
  }
  fout.close();
}
void BranchRecord::setIDOfMotherCluster(int n) { ID_of_mother_cluster = n; }
int BranchRecord::getIDOfMotherCluster() { return ID_of_mother_cluster; }
void BranchRecord::setIDOfMotherBranch(int n) { ID_of_mother_branch = n; }
int BranchRecord::getIDOfMotherBranch() { return ID_of_mother_branch; }
void BranchRecord::saveBranchRecordToFile(ofstream &fout) {
  int i, j, num, num1;
  fout << "BranchRecord\n"
       << type_of_ODM_branch << ' '
       << type_of_OAT_branch << ' '
       << type_of_OCT_branch << ' '
       << num_of_ODM_branch << ' '
       << num_of_OAT_branch << ' '
       << num_of_OCT_branch << ' '
       << num_of_HWReliability_branch << ' '
       << num_of_SSReliability_branch << ' '
       << total_number_of_branches << ' '
       << ID_of_recent_generated_branch << ' '
       << ID_of_recent_generated_ES << ' '
       << ID_of_recent_generated_branch_cluster << ' '
       << ID_of_mother_cluster << ' '
       << ID_of_mother_branch << ' '
       << recent_unconditional_branch_probability << ' '
       << size_of_subfolder << '\n';
 
  num = branch_cluster.size();
  fout << num << '\n';
  for (i = 0; i < num; i++) {
    branch_cluster.at(i)->saveBranchClusterToFile(fout);
  }
  num = end_state.size();
  fout << num << '\n';
  for (i = 0; i < num; i++) {
    end_state.at(i)->saveBranchEndStateToFile(fout);
  }
  ODM_branch.saveBranchUnitToFile(fout);
  OAT_branch.saveBranchUnitToFile(fout);
  OCT_branch.saveBranchUnitToFile(fout);
  num = HW_reliability_branch.size();
  fout << num << '\n';
  for (i = 0; i < num; i++) {
    num1 = HW_reliability_branch.at(i)->size();
    fout << num1 << '\n';
    for (j = 0; j < num1; j++) {
      HW_reliability_branch.at(i)->at(j)->saveBranchSystemActionToFile(fout);
    }
  }
  num = SS_reliability_branch.size();
  fout << num << '\n';
  for (i = 0; i < num; i++) {
    num1 = SS_reliability_branch.at(i)->size();
    fout << num1 << '\n';
    for (j = 0; j < num1; j++) {
      SS_reliability_branch.at(i)->at(j)->saveBranchSupportSystemActionToFile(fout);
    }
  }
  num = system_branch.size();
  fout << num << '\n';
  for (i = 0; i < num; i++) {
    system_branch.at(i)->saveBranchSystemAlarmStateToFile(fout);
  }
  this->source_of_procedure_time_branches.saveBranchProcedureAtionTimeToFile(fout);
  this->mental_procedure_activation_branches.saveBranchMentalProcedureActivationTimeToFile(fout);
  this->control_value_branches.saveBranchProcedureControlValueToFile(fout);
}
void BranchRecord::retrieveBranchRecordFromFile(ifstream &fin) {
  int i, j, num, num1;
  string str;
 
  fin >> str;
  if (str != "BranchRecord") {
    ofstream fout("err messages.txt", ios::app);
    cout << "BranchRecord::retrieveBranchRecordFromFile File retrieval error in previous function" << endl;
    fout << r5pars_.timesno
         << "  BranchRecord::retrieveBranchRecordFromFile File retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("BranchRecord::retrieveBranchRecordFromFile Prior err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
 
  fin >> type_of_ODM_branch
      >> type_of_OAT_branch
      >> type_of_OCT_branch
      >> num_of_ODM_branch
      >> num_of_OAT_branch
      >> num_of_OCT_branch
      >> num_of_HWReliability_branch
      >> num_of_SSReliability_branch
      >> total_number_of_branches
      >> ID_of_recent_generated_branch
      >> ID_of_recent_generated_ES
      >> ID_of_recent_generated_branch_cluster
      >> ID_of_mother_cluster
      >> ID_of_mother_branch
      >> recent_unconditional_branch_probability
      >> size_of_subfolder
      >> num;
  for (i = 0; i < num; i++) {
    auto p = make_unique<BranchCluster>();
    p->retrieveBranchClusterFromFile(fin);
    branch_cluster.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_unique<BranchEndState>();
    p->retrieveBranchEndStateFromFile(fin);
    end_state.push_back(std::move(p));
  }
  ODM_branch.retrieveBranchUnitFromFile(fin);
  OAT_branch.retrieveBranchUnitFromFile(fin);
  OCT_branch.retrieveBranchUnitFromFile(fin);
  fin >> num;
  for (i = 0; i < num; i++) {
    fin >> num1;
    auto hw_pt = make_unique<VHWReliabilityUnit>();
    for (j = 0; i < num1; j++) {
      auto sa = make_unique<BranchSystemAction>();
      sa->retrieveBranchSystemActionFromFile(fin);
      hw_pt->push_back(std::move(sa));
    }
    HW_reliability_branch.push_back(std::move(hw_pt));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    fin >> num1;
    auto ss_pt = make_unique<VSSReliabilityUnit>();
    for (j = 0; i < num1; j++) {
      auto ssa = make_unique<BranchSupportSystemAction>();
      ssa->retrieveBranchSupportSystemActionFromFile(fin);
      ss_pt->push_back(std::move(ssa));
    }
    SS_reliability_branch.push_back(std::move(ss_pt));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto sb = make_unique<BranchSystemAlarmState>();
    sb->retrieveBranchSystemAlarmStateFromFile(fin);
    system_branch.push_back(std::move(sb));
  }
  this->source_of_procedure_time_branches.retrieveBranchProcedureAtionTimeFromFile(fin);
  this->mental_procedure_activation_branches.retrieveBranchMentalProcedureActivationTimeFromFile(fin);
  this->control_value_branches.retreiveBranchProcedureControlValueFromFile(fin);
}
void BranchRecord::saveRecentBranchClusterToFile(ofstream &fout) {
  auto bc_ritr = branch_cluster.rbegin();
  if (bc_ritr != branch_cluster.rend()) {
    fout << "BranchRecord 1 "
         << type_of_ODM_branch << ' '
         << type_of_OAT_branch << ' '
         << type_of_OCT_branch << ' '
         << num_of_ODM_branch << ' '
         << num_of_OAT_branch << ' '
         << num_of_OCT_branch << ' '
         << num_of_HWReliability_branch << ' '
         << total_number_of_branches << ' '
         << ID_of_recent_generated_branch << ' '
         << ID_of_recent_generated_ES << ' '
         << ID_of_recent_generated_branch_cluster << ' '
         << ID_of_mother_cluster << ' '
         << ID_of_mother_branch << ' '
         << recent_unconditional_branch_probability << ' '
         << size_of_subfolder << '\n';
//No need for saving temp_es_message and temp_type_of_consequence
//temp_es_message is a sting which could include space
    (*bc_ritr)->saveBranchClusterToFile(fout);
  } else {
    fout << "BranchRecord 0\n";
  }
  this->source_of_procedure_time_branches.saveBranchProcedureAtionTimeToFile(fout);
  this->mental_procedure_activation_branches.saveBranchMentalProcedureActivationTimeToFile(fout);
  this->control_value_branches.saveBranchProcedureControlValueToFile(fout);
}
void BranchRecord::saveNumOfBranchInRecentBranchClusterToFile(ofstream &fout) {
  int n_branch;
  auto bc_ritr = branch_cluster.rbegin();
  if (bc_ritr != branch_cluster.rend()) {
    n_branch = (*bc_ritr)->all_branch.size();
    fout << n_branch << '\n';
  } else {
    fout << "0\n";
  }
}
void BranchRecord::retrieveRecentBranchClusterFromFile(ifstream &fin) {
  int i_exist_bc;
  string str;
 
  fin >> str >> i_exist_bc;
  if (i_exist_bc == 1) {
    fin >> type_of_ODM_branch
        >> type_of_OAT_branch
        >> type_of_OCT_branch
        >> num_of_ODM_branch
        >> num_of_OAT_branch
        >> num_of_OCT_branch
        >> num_of_HWReliability_branch
        >> total_number_of_branches
        >> ID_of_recent_generated_branch
        >> ID_of_recent_generated_ES
        >> ID_of_recent_generated_branch_cluster
        >> ID_of_mother_cluster
        >> ID_of_mother_branch
        >> recent_unconditional_branch_probability
        >> size_of_subfolder;
//No need for saving temp_es_message and temp_type_of_consequence
//temp_es_message is a sting which could include space
 
    auto bc_pt = make_unique<BranchCluster>();
    bc_pt->retrieveBranchClusterFromFile(fin);
    this->branch_cluster.push_back(std::move(bc_pt));
  } else if (i_exist_bc == 0) {
    //do notihing here
  } else {
    ofstream fout("err messages.txt", ios::app);
    cout << "BranchRecord::retrieveRecentBranchClusterFromFile: Data mismatch in file retrieval." << endl;
    fout << r5pars_.timesno
         << "  BranchRecord::retrieveRecentBranchClusterFromFile: Data mismatch in file retrieval.\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage("BranchRecord::retrieveRecentBranchClusterFromFile err.");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
  }
  this->source_of_procedure_time_branches.retrieveBranchProcedureAtionTimeFromFile(fin);
  this->mental_procedure_activation_branches.retrieveBranchMentalProcedureActivationTimeFromFile(fin);
  this->control_value_branches.retreiveBranchProcedureControlValueFromFile(fin);
 
}
int BranchRecord::getTypeOfODMBranch() { return type_of_ODM_branch; }
int BranchRecord::getTypeOfOATBranch() { return type_of_OAT_branch; }
int BranchRecord::getTypeOfOCTBranch() { return type_of_OCT_branch; }
int BranchRecord::getNumOfODMBranch() { return num_of_ODM_branch; }
int BranchRecord::getNumOfOATBranch() { return num_of_OAT_branch; }
int BranchRecord::getNumOfOCTBranch() { return num_of_OCT_branch; }
int BranchRecord::getNumOfHWReliabilityBranch() { return num_of_HWReliability_branch; }
int BranchRecord::getTotalNumberOfBranches() { return total_number_of_branches; }
 
void BranchRecord::copyBranchRecord(BranchRecord &_br) {
  //
  type_of_ODM_branch = _br.getTypeOfODMBranch();
  type_of_OAT_branch = _br.getTypeOfOATBranch();
  type_of_OCT_branch = _br.getTypeOfOCTBranch();
  num_of_ODM_branch = _br.getNumOfODMBranch();
  num_of_OAT_branch = _br.getNumOfOATBranch();
  num_of_OCT_branch = _br.getNumOfOCTBranch();
  num_of_HWReliability_branch = _br.getNumOfHWReliabilityBranch();
  total_number_of_branches = _br.getTotalNumberOfBranches();
  ID_of_recent_generated_branch = _br.getIDOfRecentGeneratedBranch();
  ID_of_recent_generated_ES = _br.getIDOfRecentGeneratedES();
  ID_of_recent_generated_branch_cluster = _br.getIDOfRecentGeneratedBranchCluster();
  ID_of_mother_cluster = _br.getIDOfMotherCluster();
  ID_of_mother_branch = _br.getIDOfMotherBranch();
  recent_unconditional_branch_probability = _br.getRecentUnconditionalBranchProbability();
  size_of_subfolder = _br.getSizeOfSubFolder();
  for (auto &src : _br.branch_cluster) {
    auto p = make_unique<BranchCluster>();
    p->copyBranchCluster(*src);
    this->branch_cluster.push_back(std::move(p));
  }
  for (auto &src : _br.end_state) {
    auto p = make_unique<BranchEndState>();
    p->copyBranchEndState(*src);
    this->end_state.push_back(std::move(p));
  }
  for (auto &hw_src : _br.HW_reliability_branch) {
    auto hw_pt = make_unique<VHWReliabilityUnit>();
    for (auto &bsa_src : *hw_src) {
      auto bsa_pt = make_unique<BranchSystemAction>();
      bsa_pt->copyBranchSystemAction(*bsa_src);
      hw_pt->push_back(std::move(bsa_pt));
    }
    this->HW_reliability_branch.push_back(std::move(hw_pt));
  }
  for (auto &ss_src : _br.SS_reliability_branch) {
    auto ss_pt = make_unique<VSSReliabilityUnit>();
    for (auto &bssa_src : *ss_src) {
      auto bssa_pt = make_unique<BranchSupportSystemAction>();
      bssa_pt->copyBranchSupportSystemAction(*bssa_src);
      ss_pt->push_back(std::move(bssa_pt));
    }
    this->SS_reliability_branch.push_back(std::move(ss_pt));
  }
  for (auto &sb_src : _br.system_branch) {
    auto sb_pt = make_unique<BranchSystemAlarmState>();
    sb_pt->copyBranchSystemAlarmState(*sb_src);
    this->system_branch.push_back(std::move(sb_pt));
  }
  this->ODM_branch.copyBranchUnit(_br.ODM_branch);
  this->OAT_branch.copyBranchUnit(_br.OAT_branch);
  this->OCT_branch.copyBranchUnit(_br.OCT_branch);
  this->source_of_procedure_time_branches.copyBranchProcedureAtionTime(_br.source_of_procedure_time_branches);
  this->mental_procedure_activation_branches.copyBranchMentalProcedureActivationTime(_br.mental_procedure_activation_branches);
  this->control_value_branches.copyBranchProcedureControlValue(_br.control_value_branches);
  this->num_of_SSReliability_branch = _br.num_of_SSReliability_branch;
}
void BranchRecord::setTempESMessage(string str) { temp_es_message = str; }
void BranchRecord::setTempTypeOfConsequence(Consequence n) { temp_type_of_consequence = n; }
string BranchRecord::getTempESMessage() { return temp_es_message; }
Consequence BranchRecord::getTempTypeOfConsequence() { return temp_type_of_consequence; }
void BranchRecord::initiationForSimulation() {
  this->source_of_procedure_time_branches.readInfoFromFile();
  this->mental_procedure_activation_branches.readInfoFromFile();
  this->control_value_branches.readInfoFromFile();
}