ExpectationORUnit.cpp

Go to the documentation of this file.

// ExpectationORUnit.cpp: implementation of the ExpectationORUnit class.
//
 
#include "ExpectationORUnit.h"
#include "ProcedureExpectedAlarmStateUnit.h"
#include "ProcedureExpectedComponentStateUnit.h"
#include "ProcedureExpectedParameterValueUnit.h"
#include "ProcedureExpectedParameterTrendUnit.h"
#include "ProcedureExpectedParameterDifferenceUnit.h"
#include "ProcedureExpectedSupportSystemStateUnit.h"
#include "../Crew/Operator.h"
#include <boost/serialization/export.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include "../Global/SimulationContext.h"
BOOST_CLASS_EXPORT_IMPLEMENT(ExpectationORUnit)
using namespace std;
 
 
// Construction/Destruction
 
ExpectationORUnit::ExpectationORUnit() {
}
 
ExpectationORUnit::~ExpectationORUnit() {
}
 
void ExpectationORUnit::add(ExpectationElement *_pt) {
  expectation_OR.push_back(unique_ptr<ExpectationElement>(_pt));
};
void ExpectationORUnit::copyExpectationORUnit(ExpectationORUnit &_exp) {
  StateOfActivation::copyStateOfActivation((StateOfActivation &) _exp);
  int type_of_exp;
  for (auto& src : _exp.expectation_OR) {
    type_of_exp = src->getTypeOfExpectation();
    if (type_of_exp == sim::Comm::AlarmState) {
      auto ptr = make_unique<ProcedureExpectedAlarmStateUnit>();
      ptr->copyProcedureExpectedAlarmStateUnit((ProcedureExpectedAlarmStateUnit &) *src);
      expectation_OR.push_back(std::move(ptr));
    } else if (type_of_exp == sim::Comm::ComponentState) {
      auto ptr = make_unique<ProcedureExpectedComponentStateUnit>();
      ptr->copyProcedureExpectedComponentStateUnit((ProcedureExpectedComponentStateUnit &) *src);
      expectation_OR.push_back(std::move(ptr));
    } else if (type_of_exp == sim::Comm::SupportSystemState) {
      auto ptr = make_unique<ProcedureExpectedSupportSystemStateUnit>();
      ptr->copyProcedureExpectedSupportSystemStateUnit((ProcedureExpectedSupportSystemStateUnit &) *src);
      expectation_OR.push_back(std::move(ptr));
    } else if (type_of_exp == sim::Comm::ParameterValue) {
      auto ptr = make_unique<ProcedureExpectedParameterValueUnit>();
      ptr->copyProcedureExpectedParameterValueUnit((ProcedureExpectedParameterValueUnit &) *src);
      expectation_OR.push_back(std::move(ptr));
    } else if (type_of_exp == sim::Comm::ParameterDifference) {
      auto ptr = make_unique<ProcedureExpectedParameterDifferenceUnit>();
      ptr->copyProcedureExpectedParameterDifferenceUnit((ProcedureExpectedParameterDifferenceUnit &) *src);
      expectation_OR.push_back(std::move(ptr));
    } else if (type_of_exp == sim::Comm::ParameterTrend) {
      auto ptr = make_unique<ProcedureExpectedParameterTrendUnit>();
      ptr->copyProcedureExpectedParameterTrendUnit((ProcedureExpectedParameterTrendUnit &) *src);
      expectation_OR.push_back(std::move(ptr));
    } else if (type_of_exp == sim::Branch::MentalBelief) {
      auto ptr = make_unique<ExpectedMentalBelief>();
      ptr->copyExpectedMentalBelief((ExpectedMentalBelief &) *src);
      expectation_OR.push_back(std::move(ptr));
    } else {
      ofstream fout("err messages.txt", ios::app);
      cout << "ExpectationORUnit::copyExpectationORUnit Type_of_exp: " << type_of_exp << " can not be recognized"
           << endl;
      fout << r5pars_.timesno << "  ExpectationORUnit::copyExpectationORUnit Type_of_exp: " << type_of_exp
           << " can not be recognized\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("ExpectationORUnit::copyExpectationORUnit err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
    }
  }
};
bool ExpectationORUnit::assessExpectation(Operator &_operator, ShortTermMemory &_stm, int _entry) {
  bool found_exp = false;
  bool branch_generated = false;
  bool use_old_info = false;
  bool recent_info = false;
  double time;
  int info_gather_mode;
  int exp_state, type_of_exp, r_state, n_count, observation;
  BranchExpectedAlarmState *b_alarm_state;
  BranchExpectedComponentState *b_component_state;
  BranchExpectedSupportSystemState *b_support_system_state;
  BranchExpectedParameterValue *b_parameter_value;
  BranchExpectedParameterDifference *b_parameter_difference;
  //BranchExpectedParameterTrend *b_parameter_trend;
  BranchExpectedMentalBelief *b_mental_belief;
  ProcedureExpectedAlarmStateUnit *alarm_pt;
  ProcedureExpectedComponentStateUnit *comp_pt;
  ProcedureExpectedSupportSystemStateUnit *ss_pt;
  ProcedureExpectedParameterValueUnit *par_value_pt;
  ProcedureExpectedParameterDifferenceUnit *par_diff_pt;
  //ProcedureExpectedParameterTrendUnit *par_trend_pt;
  ExpectedMentalBelief *mental_belief_pt, *mental_belief_pt1;
  MentalAlarm *ma_pt;
  MentalComponentState *mcs_pt;
  MentalSupportSystemState *msss_pt;
  MentalParameterValue *mpv_pt, *mpv_pt1, *mpv_pt2;
  MentalParameterTrend *mpt_pt;
  int receiver = sim::Operator::OAT;
  if (_operator.getTypeOfOperator() == sim::Operator::OAT) receiver = sim::Source::Plant;
  //
  info_gather_mode = _stm.getInfoGatherMode();
  //
  decltype(expectation_OR)::iterator exp_itr;
  exp_itr = expectation_OR.begin();
  n_count = 1;
  while (exp_itr != expectation_OR.end() && !found_exp) {
    exp_state = (*exp_itr)->getStateOfExpectation();
    if (exp_state == sim::None) {
      (*exp_itr)->setStateOfExpectation(sim::State::Active);
      type_of_exp = (*exp_itr)->getTypeOfExpectation();
      if (type_of_exp == sim::Comm::AlarmState) {
        alarm_pt = (ProcedureExpectedAlarmStateUnit *) exp_itr->get();
        ma_pt = _stm.perceived_info.checkExistanceOfPerceivedAlarms(alarm_pt->getInfoName());
        if (ma_pt != 0 && info_gather_mode == sim::State::OldInfo
            && alarm_pt->getUseNewInfo() != sim::Bool::Yes) {  // use found memorized information
          if ((ma_pt->getTimeAtWhichThisInfoIsPerceived() + _stm.alarm_update_time.calculateRequiredTime())
              > r5pars_.timesno) {
            if (ma_pt->getObservedAlarmState() == alarm_pt->getExpectedState()) {
              observation = sim::State::Succeed;
            } else {
              observation = sim::State::Failed;
            }
            use_old_info = true;
            (*exp_itr)->setStateOfExpectation(observation);
            b_alarm_state = new BranchExpectedAlarmState();
            b_alarm_state->copyMentalAlarm(*ma_pt);
            b_alarm_state->copyKBExpectedAlarmStateUnit(*alarm_pt);
            b_alarm_state->copyTimer(*alarm_pt);
            b_alarm_state->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
            // set time delay for memorized information to 1.0 second
            b_alarm_state->setTimerAndProbability(1.0, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
            //
            b_alarm_state->setStateOfActivation(sim::State::OldInfo);
            b_alarm_state->setTypeOfPauseActivity(_entry);
            g_sim.Branch_center.addAlarmState(_operator.getTypeOfOperator(), b_alarm_state);
            branch_generated = true;
          }
        }
        if (!use_old_info) {
          b_alarm_state = new BranchExpectedAlarmState();
          b_alarm_state->copyKBExpectedAlarmStateUnit(*alarm_pt);
          b_alarm_state->copyTimer(*alarm_pt);
          b_alarm_state->setAlarmName(alarm_pt->getInfoName());
          b_alarm_state->setInfoName(alarm_pt->getInfoName());
          b_alarm_state->setSenderAndReceiver(_operator.getTypeOfOperator(), receiver);
          // set stochastic time to check expectation
          time = alarm_pt->calculateRequiredTime();
          b_alarm_state->setTimerAndProbability(time, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          //
          //b_alarm_state->setTimerAndProbability(alarm_pt->getRemainingTime(), 1.0);
          b_alarm_state->setExpectedState(alarm_pt->getExpectedState());
          b_alarm_state->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addAlarmState(_operator.getTypeOfOperator(), b_alarm_state);
          branch_generated = true;
        }
      } else if (type_of_exp == sim::Comm::ComponentState) {
        comp_pt = (ProcedureExpectedComponentStateUnit *) exp_itr->get();
        mcs_pt = _stm.perceived_info.checkExistanceOfPerceivedComponentState(comp_pt->getInfoName());
        use_old_info = false;
        if (mcs_pt != 0 && info_gather_mode == sim::State::OldInfo
            && comp_pt->getUseNewInfo() != sim::Bool::Yes) {//found memorized information
          if ((mcs_pt->getTimeAtWhichThisInfoIsPerceived() + _stm.component_update_time.calculateRequiredTime())
              > r5pars_.timesno) {
            if (mcs_pt->getObservedComponentState() == comp_pt->getExpectedState()) {
              observation = sim::State::Succeed;
            } else {
              observation = sim::State::Failed;
            }
            use_old_info = true;
            (*exp_itr)->setStateOfExpectation(observation);
            b_component_state = new BranchExpectedComponentState();
            b_component_state->copyMentalComponentState(*mcs_pt);
            b_component_state->copyKBExpectedComponentStateUnit(*comp_pt);
            b_component_state->copyTimer(*comp_pt);
            b_component_state->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
            //set time for memorized information to 1.0 second
            b_component_state->setTimerAndProbability(1.0, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
            b_component_state->setStateOfActivation(sim::State::OldInfo);
            b_component_state->setTypeOfPauseActivity(_entry);
            g_sim.Branch_center.addComponentState(_operator.getTypeOfOperator(), b_component_state);
            branch_generated = true;
          }
        }
        if (!use_old_info) {
          b_component_state = new BranchExpectedComponentState();
          b_component_state->copyKBExpectedComponentStateUnit(*comp_pt);
          b_component_state->copyTimer(*comp_pt);
          b_component_state->setDisplayName(comp_pt->getInfoName());
          b_component_state->setSenderAndReceiver(_operator.getTypeOfOperator(), receiver);
          // set stochastic action time
          time = comp_pt->calculateRequiredTime();
          b_component_state->setTimerAndProbability(time, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          b_component_state->setExpectedState(comp_pt->getExpectedState());
          b_component_state->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addComponentState(_operator.getTypeOfOperator(), b_component_state);
          branch_generated = true;
        }
      } else if (type_of_exp == sim::Comm::SupportSystemState) {
        ss_pt = (ProcedureExpectedSupportSystemStateUnit *) exp_itr->get();
        msss_pt = _stm.perceived_info.checkExistanceOfPerceivedSupportSystemState(ss_pt->getInfoName());
        use_old_info = false;
        if (msss_pt != 0 && info_gather_mode == sim::State::OldInfo
            && ss_pt->getUseNewInfo() != sim::Bool::Yes) {//found memorized information
          if ((msss_pt->getTimeAtWhichThisInfoIsPerceived() + _stm.support_system_update_time.calculateRequiredTime())
              > r5pars_.timesno) {
            if (msss_pt->getObservedSupportSystemState() == ss_pt->getExpectedState()) {
              observation = sim::State::Succeed;
            } else {
              observation = sim::State::Failed;
            }
            use_old_info = true;
            (*exp_itr)->setStateOfExpectation(observation);
            b_support_system_state = new BranchExpectedSupportSystemState();
            b_support_system_state->copyMentalSupportSystemState(*msss_pt);
            b_support_system_state->copyKBExpectedSupportSystemStateUnit(*ss_pt);
            b_support_system_state->copyTimer(*ss_pt);
            b_support_system_state->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
            //set time for memorized information to 1.0 second
            b_support_system_state->setTimerAndProbability(1.0, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
            b_support_system_state->setStateOfActivation(sim::State::OldInfo);
            b_support_system_state->setTypeOfPauseActivity(_entry);
            std::cout << "Created support system state: " << b_support_system_state->getDisplayName() << std::endl;
            g_sim.Branch_center.addSupportSystemState(_operator.getTypeOfOperator(), b_support_system_state);
            branch_generated = true;
          }
        }
        if (!use_old_info) {
          b_support_system_state = new BranchExpectedSupportSystemState();
          b_support_system_state->copyKBExpectedSupportSystemStateUnit(*ss_pt);
          b_support_system_state->copyTimer(*ss_pt);
          b_support_system_state->setDisplayName(ss_pt->getInfoName());
          b_support_system_state->setSenderAndReceiver(_operator.getTypeOfOperator(), receiver);
          // set stochastic action time
          time = ss_pt->calculateRequiredTime();
          b_support_system_state->setTimerAndProbability(time, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          b_support_system_state->setExpectedState(ss_pt->getExpectedState());
          b_support_system_state->setTypeOfPauseActivity(_entry);
          std::cout << "Created support system state: " << b_support_system_state->getDisplayName() << std::endl;
          g_sim.Branch_center.addSupportSystemState(_operator.getTypeOfOperator(), b_support_system_state);
          branch_generated = true;
        }
      } else if (type_of_exp == sim::Comm::ParameterValue || type_of_exp == sim::Comm::ParameterTrend) {
        par_value_pt = (ProcedureExpectedParameterValueUnit *) exp_itr->get();
        mpv_pt = _stm.perceived_info.checkExistanceOfPerceivedParameterValue(par_value_pt->getInfoName());
        use_old_info = false;
        if (mpv_pt != 0 && info_gather_mode == sim::State::OldInfo
            && par_value_pt->getUseNewInfo() != sim::Bool::Yes) {//found memorized information
          observation = _stm.perceived_info.checkWhetherExpectedParameterValueMatchObservation(par_value_pt);
          if ((mpv_pt->getTimeAtWhichThisInfoIsPerceived() + _stm.parameter_update_time.calculateRequiredTime()
              > r5pars_.timesno) && (observation == sim::State::Succeed || observation == sim::State::Failed)) {
            use_old_info = true;
            (*exp_itr)->setStateOfExpectation(observation);
            b_parameter_value = new BranchExpectedParameterValue();
            b_parameter_value->copyMentalParameterValue(*mpv_pt);
            b_parameter_value->copyTimer(*par_value_pt);
            b_parameter_value->copyKBExpectedParameterValueUnit(*par_value_pt);
            b_parameter_value->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
            b_parameter_value->setStateOfActivation(sim::State::OldInfo);
            // use 1 second delay for memorized information
            b_parameter_value->setTimerAndProbability(1.0, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
            b_parameter_value->setTypeOfPauseActivity(_entry);
            g_sim.Branch_center.addParameterValue(_operator.getTypeOfOperator(), b_parameter_value);
            branch_generated = true;
          }
        }
        if (!use_old_info) {
          b_parameter_value = new BranchExpectedParameterValue();
          b_parameter_value->copyKBExpectedParameterValueUnit(*par_value_pt);
          b_parameter_value->copyTimer(*par_value_pt);
          b_parameter_value->setDisplayName(par_value_pt->getInfoName());
          b_parameter_value->setSenderAndReceiver(_operator.getTypeOfOperator(), receiver);
          // calculate stochastic time for checking expectation
          time = par_value_pt->calculateRequiredTime();
          b_parameter_value->setTimerAndProbability(time, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          b_parameter_value->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addParameterValue(_operator.getTypeOfOperator(), b_parameter_value);
          branch_generated = true;
        }
      } else if (type_of_exp == sim::Comm::ParameterDifference) {
        par_diff_pt = (ProcedureExpectedParameterDifferenceUnit *) exp_itr->get();
        mpv_pt1 =
            _stm.perceived_info.checkExistanceOfPerceivedParameterValue(par_diff_pt->first_indicator.getInfoName());
        mpv_pt2 =
            _stm.perceived_info.checkExistanceOfPerceivedParameterValue(par_diff_pt->second_indicator.getInfoName());
        use_old_info = false;
        if (mpv_pt1 != 0 && mpv_pt2 != 0 && info_gather_mode == sim::State::OldInfo
            && par_diff_pt->getUseNewInfo() != sim::Bool::Yes) {//found memorized information
          observation = _stm.perceived_info.checkWhetherExpectedParameterDifferenceMatchObservation(par_diff_pt);
          if ((mpv_pt1->getTimeAtWhichThisInfoIsPerceived() + _stm.parameter_update_time.calculateRequiredTime()
              > r5pars_.timesno)
              && (mpv_pt2->getTimeAtWhichThisInfoIsPerceived() + _stm.parameter_update_time.calculateRequiredTime()
                  > r5pars_.timesno)) {
            recent_info = true;
          }
          if (recent_info && (observation == sim::State::Succeed || observation == sim::State::Failed)) {
            use_old_info = true;
            (*exp_itr)->setStateOfExpectation(observation);
            b_parameter_difference = new BranchExpectedParameterDifference();
            b_parameter_difference->first_mental_parameter.copyMentalParameterValue(*mpv_pt1);
            b_parameter_difference->second_mental_parameter.copyMentalParameterValue(*mpv_pt2);
            b_parameter_difference->copyKBExpectedParameterDifferenceUnit(*par_diff_pt);
            b_parameter_difference->copyTimer(*par_diff_pt);
            b_parameter_difference->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
            b_parameter_difference->setStateOfActivation(sim::State::OldInfo);
            // use 1 second delay for memorized information
            b_parameter_difference->setTimerAndProbability(1.0, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
            b_parameter_difference->setTypeOfPauseActivity(_entry);
            g_sim.Branch_center.addParameterDifference(_operator.getTypeOfOperator(), b_parameter_difference);
            branch_generated = true;
          }
        }
        if (!use_old_info) {
          b_parameter_difference = new BranchExpectedParameterDifference();
          b_parameter_difference->copyKBExpectedParameterDifferenceUnit(*par_diff_pt);
          b_parameter_difference->copyTimer(*par_diff_pt);
          b_parameter_difference->first_mental_parameter.setDisplayName(par_diff_pt->first_indicator.getInfoName());
          b_parameter_difference->second_mental_parameter.setDisplayName(par_diff_pt->second_indicator.getInfoName());
          b_parameter_difference->setSenderAndReceiver(_operator.getTypeOfOperator(), receiver);
          // calculate stochastic time for checking expectation
          time = par_diff_pt->calculateRequiredTime();
          b_parameter_difference->setTimerAndProbability(time, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          b_parameter_difference->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addParameterDifference(_operator.getTypeOfOperator(), b_parameter_difference);
          branch_generated = true;
        }
      }
 
        /*
        else if(type_of_exp == sim::Comm::ParameterTrend){
            par_trend_pt = (ProcedureExpectedParameterTrendUnit *) (*exp_itr);
            mpt_pt = _stm.perceived_info.checkExistanceOfPerceivedParameterTrend(par_trend_pt->getInfoName());
            use_old_info = false;
            if(mpt_pt != 0 && info_gather_mode == sim::State::OldInfo){//found memorized information
                observation = _stm.perceived_info.checkWhetherExpectedParameterTrendMatchObservation(par_trend_pt);
                if(observation == sim::State::Succeed){
                    use_old_info = true;
                    (*exp_itr)->setStateOfExpectation(sim::State::Succeed);
                    b_parameter_trend = new BranchExpectedParameterTrend();
                    b_parameter_trend->copyMentalParameterTrend(*mpt_pt);
                    b_parameter_trend->copyKBExpectedParameterTrendUnit(*par_trend_pt);
                    b_parameter_trend->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
                    b_parameter_trend->setStateOfActivation(sim::State::OldInfo);
                    b_parameter_trend->setTimerAndProbability(par_trend_pt->getRemainingTime(), 1.0);
                    g_sim.Branch_center.addParameterTrend(_operator.getTypeOfOperator(), b_parameter_trend);
                    branch_generated = true;
                }
            }
            if(!use_old_info){
                b_parameter_trend = new BranchExpectedParameterTrend();
                b_parameter_trend->copyKBExpectedParameterTrendUnit(*par_trend_pt);
                b_parameter_trend->setDisplayName(par_trend_pt->getInfoName());
                b_parameter_trend->setSenderAndReceiver(_operator.getTypeOfOperator(), receiver);
                b_parameter_trend->setTimerAndProbability(par_trend_pt->getRemainingTime(), 1.0);
                g_sim.Branch_center.addParameterTrend(_operator.getTypeOfOperator(), b_parameter_trend);
                branch_generated = true;
            }
        }
        */
      else if (type_of_exp == sim::Branch::MentalBelief) {
        mental_belief_pt = (ExpectedMentalBelief *) exp_itr->get();
        mental_belief_pt1 = _stm.perceived_info.checkExistanceOfMentalBelief(mental_belief_pt->getInfoName());
        if (mental_belief_pt1 != 0) {
          if (mental_belief_pt1->getStateOfActivation() == mental_belief_pt->getExpectedState()) {
            (*exp_itr)->setStateOfExpectation(sim::State::Succeed);
            b_mental_belief = new BranchExpectedMentalBelief();
            b_mental_belief->copyExpectedMentalBelief(*mental_belief_pt);
            b_mental_belief->setStateOfExpectation(sim::State::Succeed);
            b_mental_belief->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
            b_mental_belief->setBothTotalTimeRequiredAndRemainingTime(0.0);
            b_mental_belief->setProbability(1.0 - _operator.hfe_bbn.getMentalProcedureFailureProbability());
            b_mental_belief->setStateOfActivation(sim::State::OldInfo);
            b_mental_belief->setTypeOfPauseActivity(_entry);
            g_sim.Branch_center.addMentalBelief(_operator.getTypeOfOperator(), b_mental_belief);
            branch_generated = true;
          } else {
            (*exp_itr)->setStateOfExpectation(sim::State::Failed);
            b_mental_belief = new BranchExpectedMentalBelief();
            b_mental_belief->copyExpectedMentalBelief(*mental_belief_pt);
            b_mental_belief->setStateOfExpectation(sim::State::Failed);
            b_mental_belief->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
            b_mental_belief->setBothTotalTimeRequiredAndRemainingTime(0.0);
            b_mental_belief->setProbability(1.0 - _operator.hfe_bbn.getMentalProcedureFailureProbability());
            b_mental_belief->setStateOfActivation(sim::State::OldInfo);
            b_mental_belief->setTypeOfPauseActivity(_entry);
            g_sim.Branch_center.addMentalBelief(_operator.getTypeOfOperator(), b_mental_belief);
            branch_generated = true;
          }
        } else { // generate error message if mental belief has not been found
          ofstream fout("err messages.txt", ios::app);
          cout << "ExpectationORUnit::assessExpectation: mental belief expectation name: "
               << mental_belief_pt->getInfoName() << " can not be found." << endl;
          fout << r5pars_.timesno << "  ExpectationORUnit::assessExpectation: mental belief expectation name: "
               << mental_belief_pt->getInfoName() << " can not be found.\n";
          fout.close();
          r5pars_.sim_err = true;
          g_sim.Branch_center.setTempESMessage("ExpectationORUnit::assessExpectation err.");
          g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
        }
      } else {
        ofstream fout("err messages.txt", ios::app);
        cout << "ExpectationORUnit::assessExpectation: expectation type: " << type_of_exp << " can not be recognized."
             << endl;
        fout << r5pars_.timesno << "  ExpectationORUnit::assessExpectation: expectation type: " << type_of_exp
             << " can not be recognized.\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ExpectationORUnit::assessExpectation err.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      }
      found_exp = true;
    } else if (exp_state == sim::State::Active) {
      type_of_exp = (*exp_itr)->getTypeOfExpectation();
      if (type_of_exp == sim::Comm::AlarmState) {
        alarm_pt = (ProcedureExpectedAlarmStateUnit *) exp_itr->get();
        ma_pt = _stm.perceived_info.checkExistanceOfPerceivedAlarms(alarm_pt->getInfoName());
        r_state =
            _stm.perceived_info.checkWhetherExpectedAlarmMatchObservation((KBExpectedAlarmStateUnit *) exp_itr->get());
        (*exp_itr)->setStateOfExpectation(r_state);
        if (r_state != sim::State::Succeed && r_state != sim::State::Failed
            && ma_pt != 0) {//r_state == sim::None (the information has not been perceived; ask for info again
          alarm_pt = (ProcedureExpectedAlarmStateUnit *) exp_itr->get();
          b_alarm_state = new BranchExpectedAlarmState();
          b_alarm_state->copyKBExpectedAlarmStateUnit(*alarm_pt);
          b_alarm_state->copyTimer(*alarm_pt);
          b_alarm_state->copyMentalAlarm(*ma_pt);
          b_alarm_state->setSenderAndReceiver(_operator.getTypeOfOperator(), receiver);
          // set stochastic time to check expectation
          time = alarm_pt->calculateRequiredTime();
          b_alarm_state->setTimerAndProbability(time, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          //b_alarm_state->setTimerAndProbability(alarm_pt->getRemainingTime(), 1.0);
          b_alarm_state->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addAlarmState(_operator.getTypeOfOperator(), b_alarm_state);
          branch_generated = true;
        } else if (ma_pt != 0) {
          alarm_pt = (ProcedureExpectedAlarmStateUnit *) exp_itr->get();
          b_alarm_state = new BranchExpectedAlarmState();
          b_alarm_state->copyKBExpectedAlarmStateUnit(*alarm_pt);
          b_alarm_state->copyTimer(*alarm_pt);
          b_alarm_state->copyMentalAlarm(*ma_pt);
          b_alarm_state->setAlarmName(alarm_pt->getInfoName());
          b_alarm_state->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
          b_alarm_state->setTimerAndProbability(-1.0, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          b_alarm_state->setStateOfExpectation(r_state);
          b_alarm_state->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addAlarmState(_operator.getTypeOfOperator(), b_alarm_state);
          branch_generated = true;
        } else {
          alarm_pt = (ProcedureExpectedAlarmStateUnit *) exp_itr->get();
          b_alarm_state = new BranchExpectedAlarmState();
          b_alarm_state->copyKBExpectedAlarmStateUnit(*alarm_pt);
          b_alarm_state->copyTimer(*alarm_pt);
          b_alarm_state->setAlarmName(alarm_pt->getInfoName());
          b_alarm_state->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
          b_alarm_state->setTimerAndProbability(-1.0, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          b_alarm_state->setStateOfExpectation(r_state);
          b_alarm_state->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addAlarmState(_operator.getTypeOfOperator(), b_alarm_state);
          branch_generated = true;
        }
      } else if (type_of_exp == sim::Comm::ComponentState) {
        comp_pt = (ProcedureExpectedComponentStateUnit *) exp_itr->get();
        mcs_pt = _stm.perceived_info.checkExistanceOfPerceivedComponentState(comp_pt->getInfoName());
        r_state =
            _stm.perceived_info.checkWhetherExpectedComponentStateMatchObservation((KBExpectedComponentStateUnit *) exp_itr->get());
        (*exp_itr)->setStateOfExpectation(r_state);
        if (r_state != sim::State::Succeed && r_state != sim::State::Failed
            && mcs_pt != 0) {//r_state == sim::None (the information has not been perceived; ask for info again
          comp_pt = (ProcedureExpectedComponentStateUnit *) exp_itr->get();
          b_component_state = new BranchExpectedComponentState();
          b_component_state->copyKBExpectedComponentStateUnit(*comp_pt);
          b_component_state->copyTimer(*comp_pt);
          b_component_state->copyMentalComponentState(*mcs_pt);
          b_component_state->setSenderAndReceiver(_operator.getTypeOfOperator(), receiver);
          time = comp_pt->calculateRequiredTime();
          b_component_state->setTimerAndProbability(time, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          //b_component_state->setTimerAndProbability(comp_pt->getRemainingTime(), 1.0);
          b_component_state->setExpectedState(comp_pt->getExpectedState());
          b_component_state->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addComponentState(_operator.getTypeOfOperator(), b_component_state);
          branch_generated = true;
        } else if (mcs_pt != 0) {
          comp_pt = (ProcedureExpectedComponentStateUnit *) exp_itr->get();
          b_component_state = new BranchExpectedComponentState();
          b_component_state->copyKBExpectedComponentStateUnit(*comp_pt);
          b_component_state->copyTimer(*comp_pt);
          b_component_state->copyMentalComponentState(*mcs_pt);
          b_component_state->setDisplayName(comp_pt->getInfoName());
          b_component_state->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
          b_component_state->setTimerAndProbability(-1.0, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          b_component_state->setExpectedState(comp_pt->getExpectedState());
          b_component_state->setStateOfExpectation(r_state);
          b_component_state->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addComponentState(_operator.getTypeOfOperator(), b_component_state);
          branch_generated = true;
        } else {
          comp_pt = (ProcedureExpectedComponentStateUnit *) exp_itr->get();
          b_component_state = new BranchExpectedComponentState();
          b_component_state->copyKBExpectedComponentStateUnit(*comp_pt);
          b_component_state->copyTimer(*comp_pt);
          b_component_state->setDisplayName(comp_pt->getInfoName());
          b_component_state->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
          b_component_state->setTimerAndProbability(-1.0, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          b_component_state->setExpectedState(comp_pt->getExpectedState());
          b_component_state->setStateOfExpectation(r_state);
          b_component_state->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addComponentState(_operator.getTypeOfOperator(), b_component_state);
          branch_generated = true;
        }
      } else if (type_of_exp == sim::Comm::SupportSystemState) {
        ss_pt = (ProcedureExpectedSupportSystemStateUnit *) exp_itr->get();
        msss_pt = _stm.perceived_info.checkExistanceOfPerceivedSupportSystemState(ss_pt->getInfoName());
        r_state =
            _stm.perceived_info.checkWhetherExpectedSupportSystemStateMatchObservation((KBExpectedSupportSystemStateUnit *) exp_itr->get());
        (*exp_itr)->setStateOfExpectation(r_state);
        if (r_state != sim::State::Succeed && r_state != sim::State::Failed
            && msss_pt != 0) {//r_state == sim::None (the information has not been perceived; ask for info again
          ss_pt = (ProcedureExpectedSupportSystemStateUnit *) exp_itr->get();
          b_support_system_state = new BranchExpectedSupportSystemState();
          b_support_system_state->copyKBExpectedSupportSystemStateUnit(*ss_pt);
          b_support_system_state->copyTimer(*ss_pt);
          b_support_system_state->copyMentalSupportSystemState(*msss_pt);
          b_support_system_state->setSenderAndReceiver(_operator.getTypeOfOperator(), receiver);
          time = ss_pt->calculateRequiredTime();
          b_support_system_state->setTimerAndProbability(time, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          //b_component_state->setTimerAndProbability(comp_pt->getRemainingTime(), 1.0);
          b_support_system_state->setExpectedState(ss_pt->getExpectedState());
          b_support_system_state->setTypeOfPauseActivity(_entry);
          std::cout << "Created support system state: " << b_support_system_state->getDisplayName() << std::endl;
          g_sim.Branch_center.addSupportSystemState(_operator.getTypeOfOperator(), b_support_system_state);
          branch_generated = true;
        } else if (msss_pt != 0) {
          ss_pt = (ProcedureExpectedSupportSystemStateUnit *) exp_itr->get();
          b_support_system_state = new BranchExpectedSupportSystemState();
          b_support_system_state->copyKBExpectedSupportSystemStateUnit(*ss_pt);
          b_support_system_state->copyTimer(*ss_pt);
          b_support_system_state->copyMentalSupportSystemState(*msss_pt);
          b_support_system_state->setDisplayName(ss_pt->getInfoName());
          b_support_system_state->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
          b_support_system_state->setTimerAndProbability(-1.0, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          b_support_system_state->setExpectedState(ss_pt->getExpectedState());
          b_support_system_state->setStateOfExpectation(r_state);
          b_support_system_state->setTypeOfPauseActivity(_entry);
          std::cout << "Created support system state: " << b_support_system_state->getDisplayName() << std::endl;
          g_sim.Branch_center.addSupportSystemState(_operator.getTypeOfOperator(), b_support_system_state);
          branch_generated = true;
        } else {
          ss_pt = (ProcedureExpectedSupportSystemStateUnit *) exp_itr->get();
          b_support_system_state = new BranchExpectedSupportSystemState();
          b_support_system_state->copyKBExpectedSupportSystemStateUnit(*ss_pt);
          b_support_system_state->copyTimer(*ss_pt);
          b_support_system_state->setDisplayName(ss_pt->getInfoName());
          b_support_system_state->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
          b_support_system_state->setTimerAndProbability(-1.0, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          b_support_system_state->setExpectedState(ss_pt->getExpectedState());
          b_support_system_state->setStateOfExpectation(r_state);
          b_support_system_state->setTypeOfPauseActivity(_entry);
          std::cout << "Created support system state: " << b_support_system_state->getDisplayName() << std::endl;
          g_sim.Branch_center.addSupportSystemState(_operator.getTypeOfOperator(), b_support_system_state);
          branch_generated = true;
        }
      } else if (type_of_exp == sim::Comm::ParameterValue || type_of_exp == sim::Comm::ParameterTrend) {
        par_value_pt = (ProcedureExpectedParameterValueUnit *) exp_itr->get();
        mpv_pt = _stm.perceived_info.checkExistanceOfPerceivedParameterValue(par_value_pt->getInfoName());
        r_state =
            _stm.perceived_info.checkWhetherExpectedParameterValueMatchObservation((KBExpectedParameterValueUnit *) exp_itr->get());
        (*exp_itr)->setStateOfExpectation(r_state);
        if (r_state != sim::State::Succeed && r_state != sim::State::Failed
            && mpv_pt != 0) {//r_state == sim::None (the information has not been perceived; ask for info again
          par_value_pt = (ProcedureExpectedParameterValueUnit *) exp_itr->get();
          b_parameter_value = new BranchExpectedParameterValue();
          b_parameter_value->copyKBExpectedParameterValueUnit(*par_value_pt);
          b_parameter_value->copyTimer(*par_value_pt);
          b_parameter_value->setSenderAndReceiver(_operator.getTypeOfOperator(), receiver);
          time = par_value_pt->calculateRequiredTime();
          b_parameter_value->setTimerAndProbability(time, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          //b_parameter_value->setTimerAndProbability(par_value_pt->getRemainingTime(), 1.0);
          b_parameter_value->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addParameterValue(_operator.getTypeOfOperator(), b_parameter_value);
          branch_generated = true;
        } else if (mpv_pt != 0) {
          par_value_pt = (ProcedureExpectedParameterValueUnit *) exp_itr->get();
          b_parameter_value = new BranchExpectedParameterValue();
          b_parameter_value->copyKBExpectedParameterValueUnit(*par_value_pt);
          b_parameter_value->copyTimer(*par_value_pt);
          b_parameter_value->copyMentalParameterValue(*mpv_pt);
          b_parameter_value->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
          b_parameter_value->setTimerAndProbability(-1.0, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          b_parameter_value->setStateOfExpectation(r_state);
          b_parameter_value->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addParameterValue(_operator.getTypeOfOperator(), b_parameter_value);
          branch_generated = true;
        } else {
          par_value_pt = (ProcedureExpectedParameterValueUnit *) exp_itr->get();
          b_parameter_value = new BranchExpectedParameterValue();
          b_parameter_value->copyKBExpectedParameterValueUnit(*par_value_pt);
          b_parameter_value->copyTimer(*par_value_pt);
          b_parameter_value->setDisplayName(par_value_pt->getInfoName());
          b_parameter_value->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
          b_parameter_value->setTimerAndProbability(-1.0, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          b_parameter_value->setStateOfExpectation(r_state);
          b_parameter_value->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addParameterValue(_operator.getTypeOfOperator(), b_parameter_value);
          branch_generated = true;
        }
      } else if (type_of_exp == sim::Comm::ParameterDifference) {
        par_diff_pt = (ProcedureExpectedParameterDifferenceUnit *) exp_itr->get();
        mpv_pt1 =
            _stm.perceived_info.checkExistanceOfPerceivedParameterValue(par_diff_pt->first_indicator.getInfoName());
        mpv_pt2 =
            _stm.perceived_info.checkExistanceOfPerceivedParameterValue(par_diff_pt->second_indicator.getInfoName());
        r_state =
            _stm.perceived_info.checkWhetherExpectedParameterDifferenceMatchObservation((KBExpectedParameterDifferenceUnit *) exp_itr->get());
        (*exp_itr)->setStateOfExpectation(r_state);
        if (r_state != sim::State::Succeed
            && r_state != sim::State::Failed) {//r_state == sim::None (the information has not been perceived; ask for info again
          par_diff_pt = (ProcedureExpectedParameterDifferenceUnit *) exp_itr->get();
          b_parameter_difference = new BranchExpectedParameterDifference();
          b_parameter_difference->copyKBExpectedParameterDifferenceUnit(*par_diff_pt);
          b_parameter_difference->copyTimer(*par_diff_pt);
          b_parameter_difference->setSenderAndReceiver(_operator.getTypeOfOperator(), receiver);
          time = par_diff_pt->calculateRequiredTime();
          b_parameter_difference->setTimerAndProbability(time, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          //b_parameter_value->setTimerAndProbability(par_value_pt->getRemainingTime(), 1.0);
          b_parameter_difference->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addParameterDifference(_operator.getTypeOfOperator(), b_parameter_difference);
          branch_generated = true;
        } else if (mpv_pt1 != 0 && mpv_pt2 != 0) {
          par_diff_pt = (ProcedureExpectedParameterDifferenceUnit *) exp_itr->get();
          b_parameter_difference = new BranchExpectedParameterDifference();
          b_parameter_difference->copyKBExpectedParameterDifferenceUnit(*par_diff_pt);
          b_parameter_difference->copyTimer(*par_diff_pt);
          b_parameter_difference->first_mental_parameter.copyMentalParameterValue(*mpv_pt1);
          b_parameter_difference->second_mental_parameter.copyMentalParameterValue(*mpv_pt2);
          b_parameter_difference->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
          b_parameter_difference->setTimerAndProbability(-1.0, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          b_parameter_difference->setStateOfExpectation(r_state);
          b_parameter_difference->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addParameterDifference(_operator.getTypeOfOperator(), b_parameter_difference);
          branch_generated = true;
        } else {
          par_diff_pt = (ProcedureExpectedParameterDifferenceUnit *) exp_itr->get();
          b_parameter_difference = new BranchExpectedParameterDifference();
          b_parameter_difference->copyKBExpectedParameterDifferenceUnit(*par_diff_pt);
          b_parameter_difference->copyTimer(*par_diff_pt);
          b_parameter_difference->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
          b_parameter_difference->setTimerAndProbability(-1.0, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());
          b_parameter_difference->setStateOfExpectation(r_state);
          b_parameter_difference->setTypeOfPauseActivity(_entry);
          g_sim.Branch_center.addParameterDifference(_operator.getTypeOfOperator(), b_parameter_difference);
          branch_generated = true;
        }
      }
 
 
        /*else if(type_of_exp == sim::Comm::ParameterTrend){
            par_trend_pt = (ProcedureExpectedParameterTrendUnit *) (*exp_itr);
            mpt_pt = _stm.perceived_info.checkExistanceOfPerceivedParameterTrend(par_trend_pt->getInfoName());
            r_state = _stm.perceived_info.checkWhetherExpectedParameterTrendMatchObservation((KBExpectedParameterTrendUnit *) (*exp_itr));
            (*exp_itr)->setStateOfExpectation(r_state);
            if (r_state != sim::State::Succeed && r_state != sim::State::Failed && mpt_pt != 0){//r_state == sim::None (the information has not been perceived; ask for info again
                par_trend_pt = (ProcedureExpectedParameterTrendUnit *) (*exp_itr);
                b_parameter_trend = new BranchExpectedParameterTrend();
                b_parameter_trend->copyKBExpectedParameterTrendUnit(*par_trend_pt);
                b_parameter_trend->setSenderAndReceiver(_operator.getTypeOfOperator(), receiver);
                b_parameter_trend->setTimerAndProbability(par_trend_pt->getRemainingTime(), 1.0);
                g_sim.Branch_center.addParameterTrend(_operator.getTypeOfOperator(), b_parameter_trend);
                branch_generated = true;
            }
            else if(mpt_pt != 0){
                par_trend_pt = (ProcedureExpectedParameterTrendUnit *) (*exp_itr);
                b_parameter_trend = new BranchExpectedParameterTrend();
                b_parameter_trend->copyKBExpectedParameterTrendUnit(*par_trend_pt);
                b_parameter_trend->copyMentalParameterTrend(*mpt_pt);
                b_parameter_trend->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
                b_parameter_trend->setTimerAndProbability(-1.0, 1.0);
                b_parameter_trend->setStateOfExpectation(r_state);
                g_sim.Branch_center.addParameterTrend(_operator.getTypeOfOperator(), b_parameter_trend);
                branch_generated = true;
            }
            else{
                par_trend_pt = (ProcedureExpectedParameterTrendUnit *) (*exp_itr);
                b_parameter_trend = new BranchExpectedParameterTrend();
                b_parameter_trend->copyKBExpectedParameterTrendUnit(*par_trend_pt);
                b_parameter_trend->setDisplayName(par_trend_pt->getInfoName());
                b_parameter_trend->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());
                b_parameter_trend->setTimerAndProbability(-1.0, 1.0);
                b_parameter_trend->setStateOfExpectation(r_state);
                g_sim.Branch_center.addParameterTrend(_operator.getTypeOfOperator(), b_parameter_trend);
                branch_generated = true;
            }
        }
        */
      else {
        ofstream fout("err messages.txt", ios::app);
        cout << "ExpectationORUnit::assessExpectation: expectation type: " << type_of_exp << " can not be recognized1."
             << endl;
        fout << r5pars_.timesno << "  ExpectationORUnit::assessExpectation: expectation type: " << type_of_exp
             << " can not be recognized1.\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ExpectationORUnit::assessExpectation err.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
      }
      found_exp = true;
    } else if (exp_state == sim::State::Succeed) {
      this->setStateOfActivation(sim::State::Succeed);
      found_exp = true;
    } else {}
    exp_itr++;
    n_count++;
  }
  if (!found_exp) {
    this->setStateOfActivation(sim::State::Failed);
  }
  return branch_generated;
}
void ExpectationORUnit::saveExpectationORUnitToFile(ofstream &fout) {
  int obj_type;
  this->saveStateOfActivationToFile(fout);
  fout << expectation_OR.size() << '\n';
  for (auto& e : expectation_OR) {
    obj_type = e->getTypeOfExpectation();
    fout << obj_type << ' ';
    if (obj_type == sim::Comm::AlarmState) {
      ((ProcedureExpectedAlarmStateUnit *) e.get())->saveProcedureExpectedAlarmStateUnitToFile(fout);
    } else if (obj_type == sim::Comm::ComponentState) {
      ((ProcedureExpectedComponentStateUnit *) e.get())->saveProcedureExpectedComponentStateUnitToFile(fout);
    } else if (obj_type == sim::Comm::SupportSystemState) {
      ((ProcedureExpectedSupportSystemStateUnit *) e.get())->saveProcedureExpectedSupportSystemStateUnitToFile(fout);
    } else if (obj_type == sim::Comm::ParameterValue) {
      ((ProcedureExpectedParameterValueUnit *) e.get())->saveProcedureExpectedParameterValueUnitToFile(fout);
    } else if (obj_type == sim::Comm::ParameterDifference) {
      ((ProcedureExpectedParameterDifferenceUnit *) e.get())->saveProcedureExpectedParameterDifferenceUnitToFile(fout);
    } else if (obj_type == sim::Comm::ParameterTrend) {
      ((ProcedureExpectedParameterTrendUnit *) e.get())->saveProcedureExpectedParameterTrendUnitToFile(fout);
    } else if (obj_type == sim::Branch::MentalBelief) {
      ((ExpectedMentalBelief *) e.get())->saveExpectedMentalBeliefToFile(fout);
    } else {//parmeter trend and parameter state are not provided currently
      ofstream fout("err messages.txt", ios::app);
      cout << "ExpectationORUnit::saveExpectationORUnitToFile: expectation body obj_type:" << obj_type
           << " cannot be recognized" << endl;
      fout << r5pars_.timesno << "  ExpectationORUnit::saveExpectationORUnitToFile: expectation body obj_type:"
           << obj_type << " cannot be recognized\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("ExpectationORUnit::saveExpectationORUnitToFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    }
  }
}
void ExpectationORUnit::retrieveExpectationORUnitFromFile(ifstream &fin) {
  int obj_type, i, n_expectation;
  unique_ptr<ExpectationElement> exp_pt;
 
  this->retrieveStateOfActivationFromFile(fin);
  fin >> n_expectation;//number of OR linked expectations
 
  for (i = 0; i < n_expectation; i++) {
    fin >> obj_type;
    if (obj_type == sim::Comm::AlarmState) {
      auto p = make_unique<ProcedureExpectedAlarmStateUnit>();
      p->retrieveProcedureExpectedAlarmStateUnitFromFile(fin);
      exp_pt = std::move(p);
    } else if (obj_type == sim::Comm::ComponentState) {
      auto p = make_unique<ProcedureExpectedComponentStateUnit>();
      p->retrieveProcedureExpectedComponentStateUnitFromFile(fin);
      exp_pt = std::move(p);
    } else if (obj_type == sim::Comm::SupportSystemState) {
      auto p = make_unique<ProcedureExpectedSupportSystemStateUnit>();
      p->retrieveProcedureExpectedSupportSystemStateUnitFromFile(fin);
      exp_pt = std::move(p);
    } else if (obj_type == sim::Comm::ParameterValue) {
      auto p = make_unique<ProcedureExpectedParameterValueUnit>();
      p->retrieveProcedureExpectedParameterValueUnitFromFile(fin);
      exp_pt = std::move(p);
    } else if (obj_type == sim::Comm::ParameterDifference) {
      auto p = make_unique<ProcedureExpectedParameterDifferenceUnit>();
      p->retrieveProcedureExpectedParameterDifferenceUnitFromFile(fin);
      exp_pt = std::move(p);
    } else if (obj_type == sim::Comm::ParameterTrend) {
      auto p = make_unique<ProcedureExpectedParameterTrendUnit>();
      p->retrieveProcedureExpectedParameterTrendUnitFromFile(fin);
      exp_pt = std::move(p);
    } else if (obj_type == sim::Branch::MentalBelief) {
      auto p = make_unique<ExpectedMentalBelief>();
      p->retrieveExpectedMentalBeliefFromFile(fin);
      exp_pt = std::move(p);
    } else {
      ofstream fout("err messages.txt", ios::app);
      cout << "ExpectationORUnit::retrieveExpectationORUnitFromFile: expectation body obj_type:" << obj_type
           << " cannot be recognized" << endl;
      fout << r5pars_.timesno << "  ExpectationORUnit::retrieveExpectationORUnitFromFile: expectation body obj_type:"
           << obj_type << " cannot be recognized\n";
      fout.close();
      r5pars_.sim_err = true;
      g_sim.Branch_center.setTempESMessage("ExpectationORUnit::retrieveExpectationORUnitFromFile err.");
      g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    }
    this->expectation_OR.push_back(std::move(exp_pt));
  }
}
 
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <stdexcept>
 
void ExpectationORUnit::state_save(boost::archive::binary_oarchive& ar) const {
    const int soa = const_cast<ExpectationORUnit*>(this)->getStateOfActivation();
    ar << soa;
    const uint32_t n = static_cast<uint32_t>(expectation_OR.size());
    ar << n;
    for (const auto& e : expectation_OR)
        e->state_save(ar);
}
void ExpectationORUnit::state_load(boost::archive::binary_iarchive& ar) {
    int soa = 0;
    ar >> soa;
    setStateOfActivation(soa);
    uint32_t n = 0;
    ar >> n;
    if (n != expectation_OR.size())
        throw std::runtime_error(
            "expectation state overlay: element count mismatch against the seeded book");
    for (auto& e : expectation_OR)
        e->state_load(ar);
}