HumanFailureEventsBBN.h

Go to the documentation of this file.

#include <iostream>
#include <typeinfo>
#pragma once
 
#ifdef ENABLE_HCL
#include "../../HCL/smile/network.h"
#else
#include <array>
#include <cstdint>
#include <memory>
namespace bncore {
class Graph;
class JunctionTree;
class BatchExecutionEngine;
}
#endif
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/export.hpp>
 
class HumanFailureEventsBBN {
 public:
  HumanFailureEventsBBN();
  ~HumanFailureEventsBBN();
  void NetworkInitiation();
  void setSystemCriticality(double system_criticality);
  void setInformationLoad(double information_load);
  void setTimeConstraintLoad(double time_constraint_load);
  void setCognitiveTaskLoad(double cognitive_task_load);
  void setPassiveAlarmLoad(double passive_alarm_load);
  void setTaskComplexity(double task_complexity);
  void setExpertise(double expertise);
  void setStress(double stress);
  void setFatigue(double fatigue);
  void setProblemSolvingStyle(double problem_solving_style);
  double getGatherStateInfoFailureProbability();
  double getGatherInfoModeFailureProbability();
  double getPerceiveStateInfoFailureProbability();
  double getGatherNewInfoFailureProbability();
  double getDiagnosisFailureProbability();
  double getStrategySelectionFailureProbability();
  double getGoalSelectionFailureProbability();
  double getStrategyCommunicationFailureProbability();
  double getGoalCommunicationFailureProbability();
  double getProcedureTransferFailureProbability();
  double getMentalProcedureFailureProbability();
  double getProcedureInterpretationFailureProbability();
  double getProcedureStepFailureProbability();
  double getManeuverActionFailureProbability();
  void copyHumanFailureEventsBBN(HumanFailureEventsBBN &);
 private:
  // PSFs
  double system_criticality;
  double information_load;
  double time_constraint_load;
  double cognitive_task_load;
  double passive_alarm_load;
  double task_complexity;
  double expertise;
  double stress;
  double fatigue;
  double problem_solving_style;
  // HFEs
  double gather_state_info;
  double gather_info_mode;
  double perceive_state_info;
  double gather_new_info;
  double diagnosis;
  double strategy_selection;
  double goal_selection;
  double strategy_communication;
  double goal_communication;
  double procedure_transfer;
  double mental_procedure;
  double procedure_interpretation;
  double procedure_step;
  double maneuver_action;
#ifdef ENABLE_HCL
  // The Network
  DSL_network net;
  int systemCriticalityNode;
  int informationLoadNode;
  int timeConstraintLoadNode;
  int cognitiveTaskLoadNode;
  int passiveAlarmLoadNode;
  int taskComplexityNode;
  int expertiseNode;
  int stressNode;
  int fatigueNode;
  int problemSolvingStyleNode;
  int gatherStateInfoNode;
  int gatherInfoModeNode;
  int perceiveStateInfoNode;
  int gatherNewInfoNode;
  int diagnosisNode;
  int strategySelectionNode;
  int goalSelectionNode;
  int strategyCommunicationNode;
  int goalCommunicationNode;
  int procedureTransferNode;
  int mentalProcedureNode;
  int procedureInterpretationNode;
  int procedureStepNode;
  int maneuverActionNode;
  // SMILE Utils
  int CreateCptNode(DSL_network &net, const char *id, const char *name, const char *outcomes[], int xPos, int yPos);
  int CreateNoisyMaxNode(DSL_network &net, const char *id, const char *name, const char *outcomes[], int xPos, int yPos);
  double getFailurePosteriorProbability(DSL_network &net, int handle);
#else
  // BNCore network (forward-declared; full headers in .cpp only)
  std::unique_ptr<bncore::Graph> graph_;
  std::unique_ptr<bncore::JunctionTree> jt_;
  std::unique_ptr<bncore::BatchExecutionEngine> engine_;
  std::array<std::uint32_t, 10> psf_ids_;  // bncore::NodeId = uint32_t
  std::array<std::uint32_t, 14> hfe_ids_;
  bool needs_update_;
  void updateAllPosteriors();
#endif
  // Re-syncs the inference engine's soft evidence with the PSF members and
  // marks posteriors dirty. Called from copy and from the serialize load path.
  void reapplyEvidenceAfterLoad();
    // Boost Serialization
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version) {
//     std::cout << "Serializing class: " << typeid(*this).name() << std::endl;
        ar & system_criticality;
        ar & information_load;
        ar & time_constraint_load;
        ar & cognitive_task_load;
        ar & passive_alarm_load;
        ar & task_complexity;
        ar & expertise;
        ar & stress;
        ar & fatigue;
        ar & problem_solving_style;
        // Note: only the PSF state is archived; the network is rebuilt by the
        // constructor. After a load the engine still carries constructor
        // evidence, so re-sync it and force re-inference.
        if constexpr (Archive::is_loading::value) {
            reapplyEvidenceAfterLoad();
        }
    }
};