HumanFailureEventsBBN.cpp

Go to the documentation of this file.

#include "HumanFailureEventsBBN.h"
#include <boost/serialization/export.hpp>
 
#ifdef ENABLE_HCL
#include "../../HCL/smile/smile.h"
#else
#include "bncore/graph/graph.hpp"
#include "bncore/inference/compiler.hpp"
#include "bncore/inference/engine.hpp"
#endif
#include<iostream>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(HumanFailureEventsBBN)
using namespace std;
 
HumanFailureEventsBBN::HumanFailureEventsBBN() {
  system_criticality = 0.0;
  information_load = 0.0;
  time_constraint_load = 0.0;
  cognitive_task_load = 0.0;
  passive_alarm_load = 0.0;
  task_complexity = 0.0;
  expertise = 0.0;
  stress = 0.0;
  fatigue = 0.0;
  problem_solving_style = 0.0;
  // Deterministic cached posteriors until the first inference fills them.
  gather_state_info = 0.0;
  gather_info_mode = 0.0;
  perceive_state_info = 0.0;
  gather_new_info = 0.0;
  diagnosis = 0.0;
  strategy_selection = 0.0;
  goal_selection = 0.0;
  strategy_communication = 0.0;
  goal_communication = 0.0;
  procedure_transfer = 0.0;
  mental_procedure = 0.0;
  procedure_interpretation = 0.0;
  procedure_step = 0.0;
  maneuver_action = 0.0;
 
#ifdef ENABLE_HCL
  NetworkInitiation();
 
  gather_state_info = getFailurePosteriorProbability(net, gatherStateInfoNode);
  gather_info_mode = getFailurePosteriorProbability(net, gatherInfoModeNode);
  perceive_state_info = getFailurePosteriorProbability(net, perceiveStateInfoNode);
  gather_new_info = getFailurePosteriorProbability(net, gatherNewInfoNode);
  diagnosis = getFailurePosteriorProbability(net, diagnosisNode);
  strategy_selection = getFailurePosteriorProbability(net, strategySelectionNode);
  goal_selection = getFailurePosteriorProbability(net, goalSelectionNode);
  strategy_communication = getFailurePosteriorProbability(net, strategyCommunicationNode);
  goal_communication = getFailurePosteriorProbability(net, goalCommunicationNode);
  procedure_transfer = getFailurePosteriorProbability(net, procedureTransferNode);
  mental_procedure = getFailurePosteriorProbability(net, mentalProcedureNode);
  procedure_interpretation = getFailurePosteriorProbability(net, procedureInterpretationNode);
  procedure_step = getFailurePosteriorProbability(net, procedureStepNode);
  maneuver_action = getFailurePosteriorProbability(net, maneuverActionNode);
#else
  // Posteriors are computed lazily on first getter access (the getters check
  // needs_update_). RestartNodeInfo holds two of these objects per branch
  // point and never reads posteriors, so an eager calibration here would
  // build a throwaway junction-tree workspace on every construction.
  needs_update_ = true;
  NetworkInitiation();
#endif
}
 
HumanFailureEventsBBN::~HumanFailureEventsBBN() {
 
}
 
#ifdef ENABLE_HCL
void HumanFailureEventsBBN::NetworkInitiation() {
 
  const char *SYSTEM_CRITICALITY[] = {"Present", "Absent", NULL};
  systemCriticalityNode =
      CreateCptNode(net, "SystemCriticality", "State of System Criticality", SYSTEM_CRITICALITY, 100, 150);
  const char *INFORMATION_LOAD[] = {"Present", "Absent", NULL};
  informationLoadNode = CreateCptNode(net, "InformationLoad", "State of Information Load", INFORMATION_LOAD, 200, 150);
  const char *TIME_CONSTRAINT_LOAD[] = {"Present", "Absent", NULL};
  timeConstraintLoadNode =
      CreateCptNode(net, "TimeConstraintLoad", "State of Time Constraint Load", TIME_CONSTRAINT_LOAD, 300, 150);
  const char *COGNITIVE_TASK_LOAD[] = {"Present", "Absent", NULL};
  cognitiveTaskLoadNode =
      CreateCptNode(net, "CognitiveTaskLoad", "State of Cognitive Task Load", COGNITIVE_TASK_LOAD, 400, 150);
  const char *PASSIVE_ALARM_LOAD[] = {"Present", "Absent", NULL};
  passiveAlarmLoadNode =
      CreateCptNode(net, "PassiveAlarmLoad", "State of Passive Alarm Load", PASSIVE_ALARM_LOAD, 500, 150);
  const char *TASK_COMPLEXITY[] = {"Present", "Absent", NULL};
  taskComplexityNode = CreateCptNode(net, "TaskComplexity", "State of Task Complexity", TASK_COMPLEXITY, 600, 150);
  const char *EXPERTISE[] = {"Low", "High", NULL};
  expertiseNode = CreateCptNode(net, "Expertise", "State of Expertise", EXPERTISE, 700, 150);
  const char *STRESS[] = {"Present", "Absent", NULL};
  stressNode = CreateCptNode(net, "Stress", "State of Stress", STRESS, 800, 150);
  const char *FATIGUE[] = {"Present", "Absent", NULL};
  fatigueNode = CreateCptNode(net, "Fatigue", "State of Fatigue", FATIGUE, 900, 150);
  const char *PROBLEM_SOLVING_STYLE[] = {"Poor", "Best", NULL};
  problemSolvingStyleNode =
      CreateCptNode(net, "ProblemSolvingStyle", "State of Problem Solving Style", PROBLEM_SOLVING_STYLE, 1000, 150);
 
  const char *OUTCOMES[] = {"Failure", "Success", NULL};
  gatherStateInfoNode = CreateNoisyMaxNode(net, "GatherStateInfo", "Gather State Info", OUTCOMES, 210, 350);
  gatherInfoModeNode = CreateNoisyMaxNode(net, "GatherInfoMode", "Gather Info Mode", OUTCOMES, 230, 450);
  perceiveStateInfoNode = CreateNoisyMaxNode(net, "PerceiveStateInfo", "Perceive State Info", OUTCOMES, 350, 350);
  gatherNewInfoNode = CreateNoisyMaxNode(net, "GatherNewInfo", "Gather New Info", OUTCOMES, 350, 430);
  diagnosisNode = CreateNoisyMaxNode(net, "Diagnosis", "Diagnosis", OUTCOMES, 570, 350);
  strategySelectionNode = CreateNoisyMaxNode(net, "StrategySelection", "Strategy Selection", OUTCOMES, 710, 350);
  goalSelectionNode = CreateNoisyMaxNode(net, "GoalSelection", "Goal Selection", OUTCOMES, 840, 350);
  strategyCommunicationNode =
      CreateNoisyMaxNode(net, "StrategyCommunication", "Strategy Communication", OUTCOMES, 570, 450);
  goalCommunicationNode = CreateNoisyMaxNode(net, "GoalCommunication", "Goal Communication", OUTCOMES, 730, 450);
  procedureTransferNode = CreateNoisyMaxNode(net, "ProcedureTransfer", "Procedure Transfer", OUTCOMES, 870, 450);
  mentalProcedureNode = CreateNoisyMaxNode(net, "MentalProcedure", "Mental Procedure", OUTCOMES, 1100, 350);
  procedureInterpretationNode =
      CreateNoisyMaxNode(net, "ProcedureInterpretation", "Procedure Interpretation", OUTCOMES, 1200, 350);
  procedureStepNode = CreateNoisyMaxNode(net, "ProcedureStep", "Procedure Step", OUTCOMES, 1100, 450);
  maneuverActionNode = CreateNoisyMaxNode(net, "ManeuverAction", "Maneuver Action", OUTCOMES, 1250, 450);
 
  net.AddArc(systemCriticalityNode, gatherStateInfoNode);
  net.AddArc(systemCriticalityNode, gatherInfoModeNode);
  net.AddArc(systemCriticalityNode, perceiveStateInfoNode);
  net.AddArc(systemCriticalityNode, gatherNewInfoNode);
  net.AddArc(systemCriticalityNode, diagnosisNode);
  net.AddArc(systemCriticalityNode, strategySelectionNode);
  net.AddArc(systemCriticalityNode, goalSelectionNode);
  net.AddArc(systemCriticalityNode, strategyCommunicationNode);
  net.AddArc(systemCriticalityNode, goalCommunicationNode);
  net.AddArc(systemCriticalityNode, procedureTransferNode);
  net.AddArc(systemCriticalityNode, mentalProcedureNode);
  net.AddArc(systemCriticalityNode, procedureInterpretationNode);
  net.AddArc(systemCriticalityNode, procedureStepNode);
  net.AddArc(systemCriticalityNode, maneuverActionNode);
  net.AddArc(informationLoadNode, gatherStateInfoNode);
  net.AddArc(informationLoadNode, gatherInfoModeNode);
  net.AddArc(informationLoadNode, perceiveStateInfoNode);
  net.AddArc(informationLoadNode, gatherNewInfoNode);
  net.AddArc(informationLoadNode, diagnosisNode);
  net.AddArc(informationLoadNode, strategySelectionNode);
  net.AddArc(informationLoadNode, goalSelectionNode);
  net.AddArc(informationLoadNode, strategyCommunicationNode);
  net.AddArc(informationLoadNode, goalCommunicationNode);
  net.AddArc(informationLoadNode, procedureTransferNode);
  net.AddArc(informationLoadNode, mentalProcedureNode);
  net.AddArc(informationLoadNode, procedureInterpretationNode);
  net.AddArc(informationLoadNode, procedureStepNode);
  net.AddArc(informationLoadNode, maneuverActionNode);
  net.AddArc(timeConstraintLoadNode, gatherStateInfoNode);
  net.AddArc(timeConstraintLoadNode, gatherInfoModeNode);
  net.AddArc(timeConstraintLoadNode, perceiveStateInfoNode);
  net.AddArc(timeConstraintLoadNode, gatherNewInfoNode);
  net.AddArc(timeConstraintLoadNode, diagnosisNode);
  net.AddArc(timeConstraintLoadNode, strategySelectionNode);
  net.AddArc(timeConstraintLoadNode, goalSelectionNode);
  net.AddArc(timeConstraintLoadNode, strategyCommunicationNode);
  net.AddArc(timeConstraintLoadNode, goalCommunicationNode);
  net.AddArc(timeConstraintLoadNode, procedureTransferNode);
  net.AddArc(timeConstraintLoadNode, mentalProcedureNode);
  net.AddArc(timeConstraintLoadNode, procedureInterpretationNode);
  net.AddArc(timeConstraintLoadNode, procedureStepNode);
  net.AddArc(timeConstraintLoadNode, maneuverActionNode);
  net.AddArc(cognitiveTaskLoadNode, gatherStateInfoNode);
  net.AddArc(cognitiveTaskLoadNode, gatherInfoModeNode);
  net.AddArc(cognitiveTaskLoadNode, perceiveStateInfoNode);
  net.AddArc(cognitiveTaskLoadNode, gatherNewInfoNode);
  net.AddArc(cognitiveTaskLoadNode, diagnosisNode);
  net.AddArc(cognitiveTaskLoadNode, strategySelectionNode);
  net.AddArc(cognitiveTaskLoadNode, goalSelectionNode);
  net.AddArc(cognitiveTaskLoadNode, strategyCommunicationNode);
  net.AddArc(cognitiveTaskLoadNode, goalCommunicationNode);
  net.AddArc(cognitiveTaskLoadNode, procedureTransferNode);
  net.AddArc(cognitiveTaskLoadNode, mentalProcedureNode);
  net.AddArc(cognitiveTaskLoadNode, procedureInterpretationNode);
  net.AddArc(cognitiveTaskLoadNode, procedureStepNode);
  net.AddArc(cognitiveTaskLoadNode, maneuverActionNode);
  net.AddArc(passiveAlarmLoadNode, gatherStateInfoNode);
  net.AddArc(passiveAlarmLoadNode, gatherInfoModeNode);
  net.AddArc(passiveAlarmLoadNode, perceiveStateInfoNode);
  net.AddArc(passiveAlarmLoadNode, gatherNewInfoNode);
  net.AddArc(passiveAlarmLoadNode, diagnosisNode);
  net.AddArc(passiveAlarmLoadNode, strategySelectionNode);
  net.AddArc(passiveAlarmLoadNode, goalSelectionNode);
  net.AddArc(passiveAlarmLoadNode, strategyCommunicationNode);
  net.AddArc(passiveAlarmLoadNode, goalCommunicationNode);
  net.AddArc(passiveAlarmLoadNode, procedureTransferNode);
  net.AddArc(passiveAlarmLoadNode, mentalProcedureNode);
  net.AddArc(passiveAlarmLoadNode, procedureInterpretationNode);
  net.AddArc(passiveAlarmLoadNode, procedureStepNode);
  net.AddArc(passiveAlarmLoadNode, maneuverActionNode);
  net.AddArc(taskComplexityNode, gatherStateInfoNode);
  net.AddArc(taskComplexityNode, gatherInfoModeNode);
  net.AddArc(taskComplexityNode, perceiveStateInfoNode);
  net.AddArc(taskComplexityNode, gatherNewInfoNode);
  net.AddArc(taskComplexityNode, diagnosisNode);
  net.AddArc(taskComplexityNode, strategySelectionNode);
  net.AddArc(taskComplexityNode, goalSelectionNode);
  net.AddArc(taskComplexityNode, strategyCommunicationNode);
  net.AddArc(taskComplexityNode, goalCommunicationNode);
  net.AddArc(taskComplexityNode, procedureTransferNode);
  net.AddArc(taskComplexityNode, mentalProcedureNode);
  net.AddArc(taskComplexityNode, procedureInterpretationNode);
  net.AddArc(taskComplexityNode, procedureStepNode);
  net.AddArc(taskComplexityNode, maneuverActionNode);
  net.AddArc(expertiseNode, gatherStateInfoNode);
  net.AddArc(expertiseNode, gatherInfoModeNode);
  net.AddArc(expertiseNode, perceiveStateInfoNode);
  net.AddArc(expertiseNode, gatherNewInfoNode);
  net.AddArc(expertiseNode, diagnosisNode);
  net.AddArc(expertiseNode, strategySelectionNode);
  net.AddArc(expertiseNode, goalSelectionNode);
  net.AddArc(expertiseNode, strategyCommunicationNode);
  net.AddArc(expertiseNode, goalCommunicationNode);
  net.AddArc(expertiseNode, procedureTransferNode);
  net.AddArc(expertiseNode, mentalProcedureNode);
  net.AddArc(expertiseNode, procedureInterpretationNode);
  net.AddArc(expertiseNode, procedureStepNode);
  net.AddArc(expertiseNode, maneuverActionNode);
  net.AddArc(stressNode, gatherStateInfoNode);
  net.AddArc(stressNode, gatherInfoModeNode);
  net.AddArc(stressNode, perceiveStateInfoNode);
  net.AddArc(stressNode, gatherNewInfoNode);
  net.AddArc(stressNode, diagnosisNode);
  net.AddArc(stressNode, strategySelectionNode);
  net.AddArc(stressNode, goalSelectionNode);
  net.AddArc(stressNode, strategyCommunicationNode);
  net.AddArc(stressNode, goalCommunicationNode);
  net.AddArc(stressNode, procedureTransferNode);
  net.AddArc(stressNode, mentalProcedureNode);
  net.AddArc(stressNode, procedureInterpretationNode);
  net.AddArc(stressNode, procedureStepNode);
  net.AddArc(stressNode, maneuverActionNode);
  net.AddArc(fatigueNode, gatherStateInfoNode);
  net.AddArc(fatigueNode, gatherInfoModeNode);
  net.AddArc(fatigueNode, perceiveStateInfoNode);
  net.AddArc(fatigueNode, gatherNewInfoNode);
  net.AddArc(fatigueNode, diagnosisNode);
  net.AddArc(fatigueNode, strategySelectionNode);
  net.AddArc(fatigueNode, goalSelectionNode);
  net.AddArc(fatigueNode, strategyCommunicationNode);
  net.AddArc(fatigueNode, goalCommunicationNode);
  net.AddArc(fatigueNode, procedureTransferNode);
  net.AddArc(fatigueNode, mentalProcedureNode);
  net.AddArc(fatigueNode, procedureInterpretationNode);
  net.AddArc(fatigueNode, procedureStepNode);
  net.AddArc(fatigueNode, maneuverActionNode);
  net.AddArc(problemSolvingStyleNode, gatherStateInfoNode);
  net.AddArc(problemSolvingStyleNode, gatherInfoModeNode);
  net.AddArc(problemSolvingStyleNode, perceiveStateInfoNode);
  net.AddArc(problemSolvingStyleNode, gatherNewInfoNode);
  net.AddArc(problemSolvingStyleNode, diagnosisNode);
  net.AddArc(problemSolvingStyleNode, strategySelectionNode);
  net.AddArc(problemSolvingStyleNode, goalSelectionNode);
  net.AddArc(problemSolvingStyleNode, strategyCommunicationNode);
  net.AddArc(problemSolvingStyleNode, goalCommunicationNode);
  net.AddArc(problemSolvingStyleNode, procedureTransferNode);
  net.AddArc(problemSolvingStyleNode, mentalProcedureNode);
  net.AddArc(problemSolvingStyleNode, procedureInterpretationNode);
  net.AddArc(problemSolvingStyleNode, procedureStepNode);
  net.AddArc(problemSolvingStyleNode, maneuverActionNode);
 
  DSL_doubleArray probabilities(2);
  probabilities[0] = 0.0;
  probabilities[1] = 1.0;
  DSL_nodeDefinition *systemCriticalityDef = net.GetNode(systemCriticalityNode)->Definition();
  systemCriticalityDef->SetDefinition(probabilities);
  DSL_nodeDefinition *informationLoadDef = net.GetNode(informationLoadNode)->Definition();
  informationLoadDef->SetDefinition(probabilities);
  DSL_nodeDefinition *timeConstraintLoadDef = net.GetNode(timeConstraintLoadNode)->Definition();
  timeConstraintLoadDef->SetDefinition(probabilities);
  DSL_nodeDefinition *cognitiveTaskLoadDef = net.GetNode(cognitiveTaskLoadNode)->Definition();
  cognitiveTaskLoadDef->SetDefinition(probabilities);
  DSL_nodeDefinition *passiveAlarmLoadDef = net.GetNode(passiveAlarmLoadNode)->Definition();
  passiveAlarmLoadDef->SetDefinition(probabilities);
  DSL_nodeDefinition *taskComplexityDef = net.GetNode(taskComplexityNode)->Definition();
  taskComplexityDef->SetDefinition(probabilities);
  DSL_nodeDefinition *expertiseDef = net.GetNode(expertiseNode)->Definition();
  expertiseDef->SetDefinition(probabilities);
  DSL_nodeDefinition *stressDef = net.GetNode(stressNode)->Definition();
  stressDef->SetDefinition(probabilities);
  DSL_nodeDefinition *fatigueDef = net.GetNode(fatigueNode)->Definition();
  fatigueDef->SetDefinition(probabilities);
  DSL_nodeDefinition *problemSolvingStyleDef = net.GetNode(problemSolvingStyleNode)->Definition();
  problemSolvingStyleDef->SetDefinition(probabilities);
 
  DSL_nodeDefinition *gatherStateInfoDef = net.GetNode(gatherStateInfoNode)->Definition();
  DSL_Dmatrix gatherStateInfoMatrix;
  gatherStateInfoMatrix.AddDimension(21);
  gatherStateInfoMatrix.AddDimension(2);
  gatherStateInfoMatrix[0] = 0.0063;
  gatherStateInfoMatrix[1] = 0.9937;
  gatherStateInfoMatrix[2] = 0;
  gatherStateInfoMatrix[3] = 1;
  gatherStateInfoMatrix[4] = 0.00317;
  gatherStateInfoMatrix[5] = 0.99683;
  gatherStateInfoMatrix[6] = 0;
  gatherStateInfoMatrix[7] = 1;
  gatherStateInfoMatrix[8] = 0.0063;
  gatherStateInfoMatrix[9] = 0.9937;
  gatherStateInfoMatrix[10] = 0;
  gatherStateInfoMatrix[11] = 1;
  gatherStateInfoMatrix[12] = 0.00621;
  gatherStateInfoMatrix[13] = 0.99379;
  gatherStateInfoMatrix[14] = 0;
  gatherStateInfoMatrix[15] = 1;
  gatherStateInfoMatrix[16] = 0.00626;
  gatherStateInfoMatrix[17] = 0.99374;
  gatherStateInfoMatrix[18] = 0;
  gatherStateInfoMatrix[19] = 1;
  gatherStateInfoMatrix[20] = 0.00481;
  gatherStateInfoMatrix[21] = 0.99519;
  gatherStateInfoMatrix[22] = 0;
  gatherStateInfoMatrix[23] = 1;
  gatherStateInfoMatrix[24] = 0.0029;
  gatherStateInfoMatrix[25] = 0.9971;
  gatherStateInfoMatrix[26] = 0;
  gatherStateInfoMatrix[27] = 1;
  gatherStateInfoMatrix[28] = 0.00271;
  gatherStateInfoMatrix[29] = 0.99729;
  gatherStateInfoMatrix[30] = 0;
  gatherStateInfoMatrix[31] = 1;
  gatherStateInfoMatrix[32] = 0.00271;
  gatherStateInfoMatrix[33] = 0.99729;
  gatherStateInfoMatrix[34] = 0;
  gatherStateInfoMatrix[35] = 1;
  gatherStateInfoMatrix[36] = 0.00342;
  gatherStateInfoMatrix[37] = 0.99658;
  gatherStateInfoMatrix[38] = 0;
  gatherStateInfoMatrix[39] = 1;
  gatherStateInfoMatrix[40] = 0.001;
  gatherStateInfoMatrix[41] = 0.999;
  gatherStateInfoDef->SetDefinition(gatherStateInfoMatrix);
 
  DSL_nodeDefinition *gatherInfoModeDef = net.GetNode(gatherInfoModeNode)->Definition();
  DSL_Dmatrix gatherInfoModeMatrix;
  gatherInfoModeMatrix.AddDimension(21);
  gatherInfoModeMatrix.AddDimension(2);
  gatherInfoModeMatrix[0] = 0.167;
  gatherInfoModeMatrix[1] = 0.833;
  gatherInfoModeMatrix[2] = 0;
  gatherInfoModeMatrix[3] = 1;
  gatherInfoModeMatrix[4] = 0.084;
  gatherInfoModeMatrix[5] = 0.916;
  gatherInfoModeMatrix[6] = 0;
  gatherInfoModeMatrix[7] = 1;
  gatherInfoModeMatrix[8] = 0.167;
  gatherInfoModeMatrix[9] = 0.833;
  gatherInfoModeMatrix[10] = 0;
  gatherInfoModeMatrix[11] = 1;
  gatherInfoModeMatrix[12] = 0.164;
  gatherInfoModeMatrix[13] = 0.836;
  gatherInfoModeMatrix[14] = 0;
  gatherInfoModeMatrix[15] = 1;
  gatherInfoModeMatrix[16] = 0.166;
  gatherInfoModeMatrix[17] = 0.834;
  gatherInfoModeMatrix[18] = 0;
  gatherInfoModeMatrix[19] = 1;
  gatherInfoModeMatrix[20] = 0.127;
  gatherInfoModeMatrix[21] = 0.873;
  gatherInfoModeMatrix[22] = 0;
  gatherInfoModeMatrix[23] = 1;
  gatherInfoModeMatrix[24] = 0.767;
  gatherInfoModeMatrix[25] = 0.233;
  gatherInfoModeMatrix[26] = 0;
  gatherInfoModeMatrix[27] = 1;
  gatherInfoModeMatrix[28] = 0.0718;
  gatherInfoModeMatrix[29] = 0.9282;
  gatherInfoModeMatrix[30] = 0;
  gatherInfoModeMatrix[31] = 1;
  gatherInfoModeMatrix[32] = 0.0718;
  gatherInfoModeMatrix[33] = 0.9282;
  gatherInfoModeMatrix[34] = 0;
  gatherInfoModeMatrix[35] = 1;
  gatherInfoModeMatrix[36] = 0.0905;
  gatherInfoModeMatrix[37] = 0.9095;
  gatherInfoModeMatrix[38] = 0;
  gatherInfoModeMatrix[39] = 1;
  gatherInfoModeMatrix[40] = 0.0265;
  gatherInfoModeMatrix[41] = 0.9735;
  gatherInfoModeDef->SetDefinition(gatherInfoModeMatrix);
 
  DSL_nodeDefinition *perceiveStateInfoDef = net.GetNode(perceiveStateInfoNode)->Definition();
  DSL_Dmatrix perceiveStateInfoMatrix;
  perceiveStateInfoMatrix.AddDimension(21);
  perceiveStateInfoMatrix.AddDimension(2);
  perceiveStateInfoMatrix[0] = 0.0528;
  perceiveStateInfoMatrix[1] = 0.9472;
  perceiveStateInfoMatrix[2] = 0;
  perceiveStateInfoMatrix[3] = 1;
  perceiveStateInfoMatrix[4] = 0.0266;
  perceiveStateInfoMatrix[5] = 0.9734;
  perceiveStateInfoMatrix[6] = 0;
  perceiveStateInfoMatrix[7] = 1;
  perceiveStateInfoMatrix[8] = 0.0528;
  perceiveStateInfoMatrix[9] = 0.9472;
  perceiveStateInfoMatrix[10] = 0;
  perceiveStateInfoMatrix[11] = 1;
  perceiveStateInfoMatrix[12] = 0.052;
  perceiveStateInfoMatrix[13] = 0.948;
  perceiveStateInfoMatrix[14] = 0;
  perceiveStateInfoMatrix[15] = 1;
  perceiveStateInfoMatrix[16] = 0.0229;
  perceiveStateInfoMatrix[17] = 0.9771;
  perceiveStateInfoMatrix[18] = 0;
  perceiveStateInfoMatrix[19] = 1;
  perceiveStateInfoMatrix[20] = 0.0403;
  perceiveStateInfoMatrix[21] = 0.9597;
  perceiveStateInfoMatrix[22] = 0;
  perceiveStateInfoMatrix[23] = 1;
  perceiveStateInfoMatrix[24] = 0.0243;
  perceiveStateInfoMatrix[25] = 0.9757;
  perceiveStateInfoMatrix[26] = 0;
  perceiveStateInfoMatrix[27] = 1;
  perceiveStateInfoMatrix[28] = 0.0227;
  perceiveStateInfoMatrix[29] = 0.9773;
  perceiveStateInfoMatrix[30] = 0;
  perceiveStateInfoMatrix[31] = 1;
  perceiveStateInfoMatrix[32] = 0.0227;
  perceiveStateInfoMatrix[33] = 0.9773;
  perceiveStateInfoMatrix[34] = 0;
  perceiveStateInfoMatrix[35] = 1;
  perceiveStateInfoMatrix[36] = 0.0286;
  perceiveStateInfoMatrix[37] = 0.9714;
  perceiveStateInfoMatrix[38] = 0;
  perceiveStateInfoMatrix[39] = 1;
  perceiveStateInfoMatrix[40] = 0.00837;
  perceiveStateInfoMatrix[41] = 0.99163;
  perceiveStateInfoDef->SetDefinition(perceiveStateInfoMatrix);
 
  DSL_nodeDefinition *gatherNewInfoDef = net.GetNode(gatherNewInfoNode)->Definition();
  DSL_Dmatrix gatherNewInfoMatrix;
  gatherNewInfoMatrix.AddDimension(21);
  gatherNewInfoMatrix.AddDimension(2);
  gatherNewInfoMatrix[0] = 0.441;
  gatherNewInfoMatrix[1] = 0.559;
  gatherNewInfoMatrix[2] = 0;
  gatherNewInfoMatrix[3] = 1;
  gatherNewInfoMatrix[4] = 0.222;
  gatherNewInfoMatrix[5] = 0.778;
  gatherNewInfoMatrix[6] = 0;
  gatherNewInfoMatrix[7] = 1;
  gatherNewInfoMatrix[8] = 0.441;
  gatherNewInfoMatrix[9] = 0.559;
  gatherNewInfoMatrix[10] = 0;
  gatherNewInfoMatrix[11] = 1;
  gatherNewInfoMatrix[12] = 0.435;
  gatherNewInfoMatrix[13] = 0.565;
  gatherNewInfoMatrix[14] = 0;
  gatherNewInfoMatrix[15] = 1;
  gatherNewInfoMatrix[16] = 0.438;
  gatherNewInfoMatrix[17] = 0.562;
  gatherNewInfoMatrix[18] = 0;
  gatherNewInfoMatrix[19] = 1;
  gatherNewInfoMatrix[20] = 0.337;
  gatherNewInfoMatrix[21] = 0.663;
  gatherNewInfoMatrix[22] = 0;
  gatherNewInfoMatrix[23] = 1;
  gatherNewInfoMatrix[24] = 0.203;
  gatherNewInfoMatrix[25] = 0.797;
  gatherNewInfoMatrix[26] = 0;
  gatherNewInfoMatrix[27] = 1;
  gatherNewInfoMatrix[28] = 0.19;
  gatherNewInfoMatrix[29] = 0.81;
  gatherNewInfoMatrix[30] = 0;
  gatherNewInfoMatrix[31] = 1;
  gatherNewInfoMatrix[32] = 0.19;
  gatherNewInfoMatrix[33] = 0.81;
  gatherNewInfoMatrix[34] = 0;
  gatherNewInfoMatrix[35] = 1;
  gatherNewInfoMatrix[36] = 0.239;
  gatherNewInfoMatrix[37] = 0.761;
  gatherNewInfoMatrix[38] = 0;
  gatherNewInfoMatrix[39] = 1;
  gatherNewInfoMatrix[40] = 0.07;
  gatherNewInfoMatrix[41] = 0.93;
  gatherNewInfoDef->SetDefinition(gatherNewInfoMatrix);
 
  DSL_nodeDefinition *diagnosisDef = net.GetNode(diagnosisNode)->Definition();
  DSL_Dmatrix diagnosisMatrix;
  diagnosisMatrix.AddDimension(21);
  diagnosisMatrix.AddDimension(2);
  diagnosisMatrix[0] = 0.271;
  diagnosisMatrix[1] = 0.729;
  diagnosisMatrix[2] = 0;
  diagnosisMatrix[3] = 1;
  diagnosisMatrix[4] = 0.109;
  diagnosisMatrix[5] = 0.891;
  diagnosisMatrix[6] = 0;
  diagnosisMatrix[7] = 1;
  diagnosisMatrix[8] = 0.271;
  diagnosisMatrix[9] = 0.729;
  diagnosisMatrix[10] = 0;
  diagnosisMatrix[11] = 1;
  diagnosisMatrix[12] = 0.268;
  diagnosisMatrix[13] = 0.732;
  diagnosisMatrix[14] = 0;
  diagnosisMatrix[15] = 1;
  diagnosisMatrix[16] = 0.206;
  diagnosisMatrix[17] = 0.794;
  diagnosisMatrix[18] = 0;
  diagnosisMatrix[19] = 1;
  diagnosisMatrix[20] = 0.236;
  diagnosisMatrix[21] = 0.764;
  diagnosisMatrix[22] = 0;
  diagnosisMatrix[23] = 1;
  diagnosisMatrix[24] = 0.109;
  diagnosisMatrix[25] = 0.891;
  diagnosisMatrix[26] = 0;
  diagnosisMatrix[27] = 1;
  diagnosisMatrix[28] = 0.0892;
  diagnosisMatrix[29] = 0.9108;
  diagnosisMatrix[30] = 0;
  diagnosisMatrix[31] = 1;
  diagnosisMatrix[32] = 0.0892;
  diagnosisMatrix[33] = 0.9108;
  diagnosisMatrix[34] = 0;
  diagnosisMatrix[35] = 1;
  diagnosisMatrix[36] = 0.147;
  diagnosisMatrix[37] = 0.853;
  diagnosisMatrix[38] = 0;
  diagnosisMatrix[39] = 1;
  diagnosisMatrix[40] = 0.0431;
  diagnosisMatrix[41] = 0.9569;
  diagnosisDef->SetDefinition(diagnosisMatrix);
 
  DSL_nodeDefinition *strategySelectionDef = net.GetNode(strategySelectionNode)->Definition();
  DSL_Dmatrix strategySelectionMatrix;
  strategySelectionMatrix.AddDimension(21);
  strategySelectionMatrix.AddDimension(2);
  strategySelectionMatrix[0] = 0.063;
  strategySelectionMatrix[1] = 0.937;
  strategySelectionMatrix[2] = 0;
  strategySelectionMatrix[3] = 1;
  strategySelectionMatrix[4] = 0.0252;
  strategySelectionMatrix[5] = 0.9748;
  strategySelectionMatrix[6] = 0;
  strategySelectionMatrix[7] = 1;
  strategySelectionMatrix[8] = 0.063;
  strategySelectionMatrix[9] = 0.937;
  strategySelectionMatrix[10] = 0;
  strategySelectionMatrix[11] = 1;
  strategySelectionMatrix[12] = 0.0621;
  strategySelectionMatrix[13] = 0.9379;
  strategySelectionMatrix[14] = 0;
  strategySelectionMatrix[15] = 1;
  strategySelectionMatrix[16] = 0.00789;
  strategySelectionMatrix[17] = 0.99211;
  strategySelectionMatrix[18] = 0;
  strategySelectionMatrix[19] = 1;
  strategySelectionMatrix[20] = 0.0549;
  strategySelectionMatrix[21] = 0.9451;
  strategySelectionMatrix[22] = 0;
  strategySelectionMatrix[23] = 1;
  strategySelectionMatrix[24] = 0.0368;
  strategySelectionMatrix[25] = 0.9632;
  strategySelectionMatrix[26] = 0;
  strategySelectionMatrix[27] = 1;
  strategySelectionMatrix[28] = 0.0272;
  strategySelectionMatrix[29] = 0.9728;
  strategySelectionMatrix[30] = 0;
  strategySelectionMatrix[31] = 1;
  strategySelectionMatrix[32] = 0.0272;
  strategySelectionMatrix[33] = 0.9728;
  strategySelectionMatrix[34] = 0;
  strategySelectionMatrix[35] = 1;
  strategySelectionMatrix[36] = 0.0342;
  strategySelectionMatrix[37] = 0.9658;
  strategySelectionMatrix[38] = 0;
  strategySelectionMatrix[39] = 1;
  strategySelectionMatrix[40] = 0.01;
  strategySelectionMatrix[41] = 0.99;
  strategySelectionDef->SetDefinition(strategySelectionMatrix);
 
  DSL_nodeDefinition *goalSelectionDef = net.GetNode(goalSelectionNode)->Definition();
  DSL_Dmatrix goalSelectionMatrix;
  goalSelectionMatrix.AddDimension(21);
  goalSelectionMatrix.AddDimension(2);
  goalSelectionMatrix[0] = 0.063;
  goalSelectionMatrix[1] = 0.937;
  goalSelectionMatrix[2] = 0;
  goalSelectionMatrix[3] = 1;
  goalSelectionMatrix[4] = 0.0252;
  goalSelectionMatrix[5] = 0.9748;
  goalSelectionMatrix[6] = 0;
  goalSelectionMatrix[7] = 1;
  goalSelectionMatrix[8] = 0.063;
  goalSelectionMatrix[9] = 0.937;
  goalSelectionMatrix[10] = 0;
  goalSelectionMatrix[11] = 1;
  goalSelectionMatrix[12] = 0.0621;
  goalSelectionMatrix[13] = 0.9379;
  goalSelectionMatrix[14] = 0;
  goalSelectionMatrix[15] = 1;
  goalSelectionMatrix[16] = 0.00789;
  goalSelectionMatrix[17] = 0.99211;
  goalSelectionMatrix[18] = 0;
  goalSelectionMatrix[19] = 1;
  goalSelectionMatrix[20] = 0.0549;
  goalSelectionMatrix[21] = 0.9451;
  goalSelectionMatrix[22] = 0;
  goalSelectionMatrix[23] = 1;
  goalSelectionMatrix[24] = 0.0368;
  goalSelectionMatrix[25] = 0.9632;
  goalSelectionMatrix[26] = 0;
  goalSelectionMatrix[27] = 1;
  goalSelectionMatrix[28] = 0.0272;
  goalSelectionMatrix[29] = 0.9728;
  goalSelectionMatrix[30] = 0;
  goalSelectionMatrix[31] = 1;
  goalSelectionMatrix[32] = 0.0272;
  goalSelectionMatrix[33] = 0.9728;
  goalSelectionMatrix[34] = 0;
  goalSelectionMatrix[35] = 1;
  goalSelectionMatrix[36] = 0.0342;
  goalSelectionMatrix[37] = 0.9658;
  goalSelectionMatrix[38] = 0;
  goalSelectionMatrix[39] = 1;
  goalSelectionMatrix[40] = 0.01;
  goalSelectionMatrix[41] = 0.99;
  goalSelectionDef->SetDefinition(goalSelectionMatrix);
 
  DSL_nodeDefinition *strategyCommunicationDef = net.GetNode(strategyCommunicationNode)->Definition();
  DSL_Dmatrix strategyCommunicationMatrix;
  strategyCommunicationMatrix.AddDimension(21);
  strategyCommunicationMatrix.AddDimension(2);
  strategyCommunicationMatrix[0] = 0.0378;
  strategyCommunicationMatrix[1] = 0.9622;
  strategyCommunicationMatrix[2] = 0;
  strategyCommunicationMatrix[3] = 1;
  strategyCommunicationMatrix[4] = 0.019;
  strategyCommunicationMatrix[5] = 0.981;
  strategyCommunicationMatrix[6] = 0;
  strategyCommunicationMatrix[7] = 1;
  strategyCommunicationMatrix[8] = 0.0378;
  strategyCommunicationMatrix[9] = 0.9622;
  strategyCommunicationMatrix[10] = 0;
  strategyCommunicationMatrix[11] = 1;
  strategyCommunicationMatrix[12] = 0.0373;
  strategyCommunicationMatrix[13] = 0.9627;
  strategyCommunicationMatrix[14] = 0;
  strategyCommunicationMatrix[15] = 1;
  strategyCommunicationMatrix[16] = 0.0375;
  strategyCommunicationMatrix[17] = 0.9625;
  strategyCommunicationMatrix[18] = 0;
  strategyCommunicationMatrix[19] = 1;
  strategyCommunicationMatrix[20] = 0.0289;
  strategyCommunicationMatrix[21] = 0.9711;
  strategyCommunicationMatrix[22] = 0;
  strategyCommunicationMatrix[23] = 1;
  strategyCommunicationMatrix[24] = 0.0174;
  strategyCommunicationMatrix[25] = 0.9826;
  strategyCommunicationMatrix[26] = 0;
  strategyCommunicationMatrix[27] = 1;
  strategyCommunicationMatrix[28] = 0.0163;
  strategyCommunicationMatrix[29] = 0.9837;
  strategyCommunicationMatrix[30] = 0;
  strategyCommunicationMatrix[31] = 1;
  strategyCommunicationMatrix[32] = 0.0163;
  strategyCommunicationMatrix[33] = 0.9837;
  strategyCommunicationMatrix[34] = 0;
  strategyCommunicationMatrix[35] = 1;
  strategyCommunicationMatrix[36] = 0.0205;
  strategyCommunicationMatrix[37] = 0.9795;
  strategyCommunicationMatrix[38] = 0;
  strategyCommunicationMatrix[39] = 1;
  strategyCommunicationMatrix[40] = 0.006;
  strategyCommunicationMatrix[41] = 0.994;
  strategyCommunicationDef->SetDefinition(strategyCommunicationMatrix);
 
  DSL_nodeDefinition *goalCommunicationDef = net.GetNode(goalCommunicationNode)->Definition();
  DSL_Dmatrix goalCommunicationMatrix;
  goalCommunicationMatrix.AddDimension(21);
  goalCommunicationMatrix.AddDimension(2);
  goalCommunicationMatrix[0] = 0.0378;
  goalCommunicationMatrix[1] = 0.9622;
  goalCommunicationMatrix[2] = 0;
  goalCommunicationMatrix[3] = 1;
  goalCommunicationMatrix[4] = 0.019;
  goalCommunicationMatrix[5] = 0.981;
  goalCommunicationMatrix[6] = 0;
  goalCommunicationMatrix[7] = 1;
  goalCommunicationMatrix[8] = 0.0378;
  goalCommunicationMatrix[9] = 0.9622;
  goalCommunicationMatrix[10] = 0;
  goalCommunicationMatrix[11] = 1;
  goalCommunicationMatrix[12] = 0.0373;
  goalCommunicationMatrix[13] = 0.9627;
  goalCommunicationMatrix[14] = 0;
  goalCommunicationMatrix[15] = 1;
  goalCommunicationMatrix[16] = 0.0375;
  goalCommunicationMatrix[17] = 0.9625;
  goalCommunicationMatrix[18] = 0;
  goalCommunicationMatrix[19] = 1;
  goalCommunicationMatrix[20] = 0.0289;
  goalCommunicationMatrix[21] = 0.9711;
  goalCommunicationMatrix[22] = 0;
  goalCommunicationMatrix[23] = 1;
  goalCommunicationMatrix[24] = 0.0174;
  goalCommunicationMatrix[25] = 0.9826;
  goalCommunicationMatrix[26] = 0;
  goalCommunicationMatrix[27] = 1;
  goalCommunicationMatrix[28] = 0.0163;
  goalCommunicationMatrix[29] = 0.9837;
  goalCommunicationMatrix[30] = 0;
  goalCommunicationMatrix[31] = 1;
  goalCommunicationMatrix[32] = 0.0163;
  goalCommunicationMatrix[33] = 0.9837;
  goalCommunicationMatrix[34] = 0;
  goalCommunicationMatrix[35] = 1;
  goalCommunicationMatrix[36] = 0.0205;
  goalCommunicationMatrix[37] = 0.9795;
  goalCommunicationMatrix[38] = 0;
  goalCommunicationMatrix[39] = 1;
  goalCommunicationMatrix[40] = 0.006;
  goalCommunicationMatrix[41] = 0.994;
  goalCommunicationDef->SetDefinition(goalCommunicationMatrix);
 
  DSL_nodeDefinition *procedureTransferDef = net.GetNode(procedureTransferNode)->Definition();
  DSL_Dmatrix procedureTransferMatrix;
  procedureTransferMatrix.AddDimension(21);
  procedureTransferMatrix.AddDimension(2);
  procedureTransferMatrix[0] = 0.063;
  procedureTransferMatrix[1] = 0.937;
  procedureTransferMatrix[2] = 0;
  procedureTransferMatrix[3] = 1;
  procedureTransferMatrix[4] = 0.0252;
  procedureTransferMatrix[5] = 0.9748;
  procedureTransferMatrix[6] = 0;
  procedureTransferMatrix[7] = 1;
  procedureTransferMatrix[8] = 0.063;
  procedureTransferMatrix[9] = 0.937;
  procedureTransferMatrix[10] = 0;
  procedureTransferMatrix[11] = 1;
  procedureTransferMatrix[12] = 0.0621;
  procedureTransferMatrix[13] = 0.9379;
  procedureTransferMatrix[14] = 0;
  procedureTransferMatrix[15] = 1;
  procedureTransferMatrix[16] = 0.0478;
  procedureTransferMatrix[17] = 0.9522;
  procedureTransferMatrix[18] = 0;
  procedureTransferMatrix[19] = 1;
  procedureTransferMatrix[20] = 0.0549;
  procedureTransferMatrix[21] = 0.9451;
  procedureTransferMatrix[22] = 0;
  procedureTransferMatrix[23] = 1;
  procedureTransferMatrix[24] = 0.0393;
  procedureTransferMatrix[25] = 0.9607;
  procedureTransferMatrix[26] = 0;
  procedureTransferMatrix[27] = 1;
  procedureTransferMatrix[28] = 0.0271;
  procedureTransferMatrix[29] = 0.9729;
  procedureTransferMatrix[30] = 0;
  procedureTransferMatrix[31] = 1;
  procedureTransferMatrix[32] = 0.0271;
  procedureTransferMatrix[33] = 0.9729;
  procedureTransferMatrix[34] = 0;
  procedureTransferMatrix[35] = 1;
  procedureTransferMatrix[36] = 0.0342;
  procedureTransferMatrix[37] = 0.9658;
  procedureTransferMatrix[38] = 0;
  procedureTransferMatrix[39] = 1;
  procedureTransferMatrix[40] = 0.01;
  procedureTransferMatrix[41] = 0.99;
  procedureTransferDef->SetDefinition(procedureTransferMatrix);
 
  DSL_nodeDefinition *mentalProcedureDef = net.GetNode(mentalProcedureNode)->Definition();
  DSL_Dmatrix mentalProcedureMatrix;
  mentalProcedureMatrix.AddDimension(21);
  mentalProcedureMatrix.AddDimension(2);
  mentalProcedureMatrix[0] = 0.0154;
  mentalProcedureMatrix[1] = 0.9846;
  mentalProcedureMatrix[2] = 0;
  mentalProcedureMatrix[3] = 1;
  mentalProcedureMatrix[4] = 0.00617;
  mentalProcedureMatrix[5] = 0.99383;
  mentalProcedureMatrix[6] = 0;
  mentalProcedureMatrix[7] = 1;
  mentalProcedureMatrix[8] = 0.0154;
  mentalProcedureMatrix[9] = 0.9846;
  mentalProcedureMatrix[10] = 0;
  mentalProcedureMatrix[11] = 1;
  mentalProcedureMatrix[12] = 0.0152;
  mentalProcedureMatrix[13] = 0.9848;
  mentalProcedureMatrix[14] = 0;
  mentalProcedureMatrix[15] = 1;
  mentalProcedureMatrix[16] = 0.0117;
  mentalProcedureMatrix[17] = 0.9883;
  mentalProcedureMatrix[18] = 0;
  mentalProcedureMatrix[19] = 1;
  mentalProcedureMatrix[20] = 0.0197;
  mentalProcedureMatrix[21] = 0.9803;
  mentalProcedureMatrix[22] = 0;
  mentalProcedureMatrix[23] = 1;
  mentalProcedureMatrix[24] = 0.00962;
  mentalProcedureMatrix[25] = 0.99038;
  mentalProcedureMatrix[26] = 0;
  mentalProcedureMatrix[27] = 1;
  mentalProcedureMatrix[28] = 0.00662;
  mentalProcedureMatrix[29] = 0.99338;
  mentalProcedureMatrix[30] = 0;
  mentalProcedureMatrix[31] = 1;
  mentalProcedureMatrix[32] = 0.00662;
  mentalProcedureMatrix[33] = 0.99338;
  mentalProcedureMatrix[34] = 0;
  mentalProcedureMatrix[35] = 1;
  mentalProcedureMatrix[36] = 0.00838;
  mentalProcedureMatrix[37] = 0.99162;
  mentalProcedureMatrix[38] = 0;
  mentalProcedureMatrix[39] = 1;
  mentalProcedureMatrix[40] = 0.00245;
  mentalProcedureMatrix[41] = 0.99755;
  mentalProcedureDef->SetDefinition(mentalProcedureMatrix);
 
  DSL_nodeDefinition *procedureInterpretationDef = net.GetNode(procedureInterpretationNode)->Definition();
  DSL_Dmatrix procedureInterpretationMatrix;
  procedureInterpretationMatrix.AddDimension(21);
  procedureInterpretationMatrix.AddDimension(2);
  procedureInterpretationMatrix[0] = 0.0154;
  procedureInterpretationMatrix[1] = 0.9846;
  procedureInterpretationMatrix[2] = 0;
  procedureInterpretationMatrix[3] = 1;
  procedureInterpretationMatrix[4] = 0.00617;
  procedureInterpretationMatrix[5] = 0.99383;
  procedureInterpretationMatrix[6] = 0;
  procedureInterpretationMatrix[7] = 1;
  procedureInterpretationMatrix[8] = 0.0154;
  procedureInterpretationMatrix[9] = 0.9846;
  procedureInterpretationMatrix[10] = 0;
  procedureInterpretationMatrix[11] = 1;
  procedureInterpretationMatrix[12] = 0.0152;
  procedureInterpretationMatrix[13] = 0.9848;
  procedureInterpretationMatrix[14] = 0;
  procedureInterpretationMatrix[15] = 1;
  procedureInterpretationMatrix[16] = 0.0117;
  procedureInterpretationMatrix[17] = 0.9883;
  procedureInterpretationMatrix[18] = 0;
  procedureInterpretationMatrix[19] = 1;
  procedureInterpretationMatrix[20] = 0.0197;
  procedureInterpretationMatrix[21] = 0.9803;
  procedureInterpretationMatrix[22] = 0;
  procedureInterpretationMatrix[23] = 1;
  procedureInterpretationMatrix[24] = 0.00962;
  procedureInterpretationMatrix[25] = 0.99038;
  procedureInterpretationMatrix[26] = 0;
  procedureInterpretationMatrix[27] = 1;
  procedureInterpretationMatrix[28] = 0.00662;
  procedureInterpretationMatrix[29] = 0.99338;
  procedureInterpretationMatrix[30] = 0;
  procedureInterpretationMatrix[31] = 1;
  procedureInterpretationMatrix[32] = 0.00662;
  procedureInterpretationMatrix[33] = 0.99338;
  procedureInterpretationMatrix[34] = 0;
  procedureInterpretationMatrix[35] = 1;
  procedureInterpretationMatrix[36] = 0.00838;
  procedureInterpretationMatrix[37] = 0.99162;
  procedureInterpretationMatrix[38] = 0;
  procedureInterpretationMatrix[39] = 1;
  procedureInterpretationMatrix[40] = 0.00245;
  procedureInterpretationMatrix[41] = 0.99755;
  procedureInterpretationDef->SetDefinition(procedureInterpretationMatrix);
 
  DSL_nodeDefinition *procedureStepDef = net.GetNode(procedureStepNode)->Definition();
  DSL_Dmatrix procedureStepMatrix;
  procedureStepMatrix.AddDimension(21);
  procedureStepMatrix.AddDimension(2);
  procedureStepMatrix[0] = 0.063;
  procedureStepMatrix[1] = 0.937;
  procedureStepMatrix[2] = 0;
  procedureStepMatrix[3] = 1;
  procedureStepMatrix[4] = 0.0252;
  procedureStepMatrix[5] = 0.9748;
  procedureStepMatrix[6] = 0;
  procedureStepMatrix[7] = 1;
  procedureStepMatrix[8] = 0.063;
  procedureStepMatrix[9] = 0.937;
  procedureStepMatrix[10] = 0;
  procedureStepMatrix[11] = 1;
  procedureStepMatrix[12] = 0.0621;
  procedureStepMatrix[13] = 0.9379;
  procedureStepMatrix[14] = 0;
  procedureStepMatrix[15] = 1;
  procedureStepMatrix[16] = 0.0478;
  procedureStepMatrix[17] = 0.9522;
  procedureStepMatrix[18] = 0;
  procedureStepMatrix[19] = 1;
  procedureStepMatrix[20] = 0.0549;
  procedureStepMatrix[21] = 0.9451;
  procedureStepMatrix[22] = 0;
  procedureStepMatrix[23] = 1;
  procedureStepMatrix[24] = 0.0393;
  procedureStepMatrix[25] = 0.9607;
  procedureStepMatrix[26] = 0;
  procedureStepMatrix[27] = 1;
  procedureStepMatrix[28] = 0.0271;
  procedureStepMatrix[29] = 0.9729;
  procedureStepMatrix[30] = 0;
  procedureStepMatrix[31] = 1;
  procedureStepMatrix[32] = 0.0271;
  procedureStepMatrix[33] = 0.9729;
  procedureStepMatrix[34] = 0;
  procedureStepMatrix[35] = 1;
  procedureStepMatrix[36] = 0.0342;
  procedureStepMatrix[37] = 0.9658;
  procedureStepMatrix[38] = 0;
  procedureStepMatrix[39] = 1;
  procedureStepMatrix[40] = 0.01;
  procedureStepMatrix[41] = 0.99;
  procedureStepDef->SetDefinition(procedureStepMatrix);
 
  DSL_nodeDefinition *maneuverActionDef = net.GetNode(maneuverActionNode)->Definition();
  DSL_Dmatrix maneuverActionMatrix;
  maneuverActionMatrix.AddDimension(21);
  maneuverActionMatrix.AddDimension(2);
  maneuverActionMatrix[0] = 0.0234;
  maneuverActionMatrix[1] = 0.9766;
  maneuverActionMatrix[2] = 0;
  maneuverActionMatrix[3] = 1;
  maneuverActionMatrix[4] = 0.0132;
  maneuverActionMatrix[5] = 0.9868;
  maneuverActionMatrix[6] = 0;
  maneuverActionMatrix[7] = 1;
  maneuverActionMatrix[8] = 0.0234;
  maneuverActionMatrix[9] = 0.9766;
  maneuverActionMatrix[10] = 0;
  maneuverActionMatrix[11] = 1;
  maneuverActionMatrix[12] = 0.0207;
  maneuverActionMatrix[13] = 0.9793;
  maneuverActionMatrix[14] = 0;
  maneuverActionMatrix[15] = 1;
  maneuverActionMatrix[16] = 0.0147;
  maneuverActionMatrix[17] = 0.9853;
  maneuverActionMatrix[18] = 0;
  maneuverActionMatrix[19] = 1;
  maneuverActionMatrix[20] = 0.0194;
  maneuverActionMatrix[21] = 0.9806;
  maneuverActionMatrix[22] = 0;
  maneuverActionMatrix[23] = 1;
  maneuverActionMatrix[24] = 0.0194;
  maneuverActionMatrix[25] = 0.9806;
  maneuverActionMatrix[26] = 0;
  maneuverActionMatrix[27] = 1;
  maneuverActionMatrix[28] = 0.0928;
  maneuverActionMatrix[29] = 0.9072;
  maneuverActionMatrix[30] = 0;
  maneuverActionMatrix[31] = 1;
  maneuverActionMatrix[32] = 0.0135;
  maneuverActionMatrix[33] = 0.9865;
  maneuverActionMatrix[34] = 0;
  maneuverActionMatrix[35] = 1;
  maneuverActionMatrix[36] = 0.0234;
  maneuverActionMatrix[37] = 0.9766;
  maneuverActionMatrix[38] = 0;
  maneuverActionMatrix[39] = 1;
  maneuverActionMatrix[40] = 0.00331;
  maneuverActionMatrix[41] = 0.99669;
  maneuverActionDef->SetDefinition(maneuverActionMatrix);
 
  net.UpdateBeliefs();
}
 
void HumanFailureEventsBBN::setSystemCriticality(double system_criticality) {
  this->system_criticality = system_criticality;
  DSL_doubleArray probabilities(2);
  probabilities[0] = system_criticality;
  probabilities[1] = 1.0 - system_criticality;
  DSL_nodeDefinition *systemCriticalityDef = net.GetNode(systemCriticalityNode)->Definition();
  systemCriticalityDef->SetDefinition(probabilities);
  net.UpdateBeliefs();
}
void HumanFailureEventsBBN::setInformationLoad(double information_load) {
  this->information_load = information_load;
  DSL_doubleArray probabilities(2);
  probabilities[0] = information_load;
  probabilities[1] = 1.0 - information_load;
  DSL_nodeDefinition *informationLoadDef = net.GetNode(informationLoadNode)->Definition();
  informationLoadDef->SetDefinition(probabilities);
  net.UpdateBeliefs();
}
void HumanFailureEventsBBN::setTimeConstraintLoad(double time_constraint_load) {
  this->time_constraint_load = time_constraint_load;
  DSL_doubleArray probabilities(2);
  probabilities[0] = time_constraint_load;
  probabilities[1] = 1.0 - time_constraint_load;
  DSL_nodeDefinition *timeConstraintLoadDef = net.GetNode(timeConstraintLoadNode)->Definition();
  timeConstraintLoadDef->SetDefinition(probabilities);
  net.UpdateBeliefs();
}
void HumanFailureEventsBBN::setCognitiveTaskLoad(double cognitive_task_load) {
  this->cognitive_task_load = cognitive_task_load;
  DSL_doubleArray probabilities(2);
  probabilities[0] = cognitive_task_load;
  probabilities[1] = 1.0 - cognitive_task_load;
  DSL_nodeDefinition *cognitiveTaskLoadDef = net.GetNode(cognitiveTaskLoadNode)->Definition();
  cognitiveTaskLoadDef->SetDefinition(probabilities);
  net.UpdateBeliefs();
}
void HumanFailureEventsBBN::setPassiveAlarmLoad(double passive_alarm_load) {
  this->passive_alarm_load = passive_alarm_load;
  DSL_doubleArray probabilities(2);
  probabilities[0] = passive_alarm_load;
  probabilities[1] = 1.0 - passive_alarm_load;
  DSL_nodeDefinition *passiveAlarmLoadDef = net.GetNode(passiveAlarmLoadNode)->Definition();
  passiveAlarmLoadDef->SetDefinition(probabilities);
  net.UpdateBeliefs();
}
void HumanFailureEventsBBN::setTaskComplexity(double task_complexity) {
  this->task_complexity = task_complexity;
  DSL_doubleArray probabilities(2);
  probabilities[0] = task_complexity;
  probabilities[1] = 1.0 - task_complexity;
  DSL_nodeDefinition *taskComplexityDef = net.GetNode(taskComplexityNode)->Definition();
  taskComplexityDef->SetDefinition(probabilities);
  net.UpdateBeliefs();
}
void HumanFailureEventsBBN::setExpertise(double expertise) {
  this->expertise = expertise;
  DSL_doubleArray probabilities(2);
  probabilities[0] = expertise;
  probabilities[1] = 1.0 - expertise;
  DSL_nodeDefinition *expertiseDef = net.GetNode(expertiseNode)->Definition();
  expertiseDef->SetDefinition(probabilities);
  net.UpdateBeliefs();
}
void HumanFailureEventsBBN::setStress(double stress) {
  this->stress = stress;
  DSL_doubleArray probabilities(2);
  probabilities[0] = stress;
  probabilities[1] = 1.0 - stress;
  DSL_nodeDefinition *stressDef = net.GetNode(stressNode)->Definition();
  stressDef->SetDefinition(probabilities);
  net.UpdateBeliefs();
}
void HumanFailureEventsBBN::setFatigue(double fatigue) {
  this->fatigue = fatigue;
  DSL_doubleArray probabilities(2);
  probabilities[0] = fatigue;
  probabilities[1] = 1.0 - fatigue;
  DSL_nodeDefinition *fatigueDef = net.GetNode(fatigueNode)->Definition();
  fatigueDef->SetDefinition(probabilities);
  net.UpdateBeliefs();
}
void HumanFailureEventsBBN::setProblemSolvingStyle(double problem_solving_style) {
  this->problem_solving_style = problem_solving_style;
  DSL_doubleArray probabilities(2);
  probabilities[0] = problem_solving_style;
  probabilities[1] = 1.0 - problem_solving_style;
  DSL_nodeDefinition *problemSolvingStyleDef = net.GetNode(problemSolvingStyleNode)->Definition();
  problemSolvingStyleDef->SetDefinition(probabilities);
  net.UpdateBeliefs();
}
 
double HumanFailureEventsBBN::getGatherStateInfoFailureProbability() {
  gather_state_info = getFailurePosteriorProbability(net, gatherStateInfoNode);
  return gather_state_info;
}
double HumanFailureEventsBBN::getGatherInfoModeFailureProbability() {
  gather_info_mode = getFailurePosteriorProbability(net, gatherInfoModeNode);
  return gather_info_mode;
}
double HumanFailureEventsBBN::getPerceiveStateInfoFailureProbability() {
  perceive_state_info = getFailurePosteriorProbability(net, perceiveStateInfoNode);
  return perceive_state_info;
}
double HumanFailureEventsBBN::getGatherNewInfoFailureProbability() {
  gather_new_info = getFailurePosteriorProbability(net, gatherNewInfoNode);
  return gather_new_info;
}
double HumanFailureEventsBBN::getDiagnosisFailureProbability() {
  diagnosis = getFailurePosteriorProbability(net, diagnosisNode);
  return diagnosis;
}
double HumanFailureEventsBBN::getStrategySelectionFailureProbability() {
  strategy_selection = getFailurePosteriorProbability(net, strategySelectionNode);
  return strategy_selection;
}
double HumanFailureEventsBBN::getGoalSelectionFailureProbability() {
  goal_selection = getFailurePosteriorProbability(net, goalSelectionNode);
  return goal_selection;
}
double HumanFailureEventsBBN::getStrategyCommunicationFailureProbability() {
  strategy_communication = getFailurePosteriorProbability(net, strategyCommunicationNode);
  return strategy_communication;
}
double HumanFailureEventsBBN::getGoalCommunicationFailureProbability() {
  goal_communication = getFailurePosteriorProbability(net, goalCommunicationNode);
  return goal_communication;
}
double HumanFailureEventsBBN::getProcedureTransferFailureProbability() {
  procedure_transfer = getFailurePosteriorProbability(net, procedureTransferNode);
  return procedure_transfer;
}
double HumanFailureEventsBBN::getMentalProcedureFailureProbability() {
  mental_procedure = getFailurePosteriorProbability(net, mentalProcedureNode);
  return mental_procedure;
}
double HumanFailureEventsBBN::getProcedureInterpretationFailureProbability() {
  procedure_interpretation = getFailurePosteriorProbability(net, procedureInterpretationNode);
  return procedure_interpretation;
}
double HumanFailureEventsBBN::getProcedureStepFailureProbability() {
  procedure_step = getFailurePosteriorProbability(net, procedureStepNode);
  return procedure_step;
}
double HumanFailureEventsBBN::getManeuverActionFailureProbability() {
  maneuver_action = getFailurePosteriorProbability(net, maneuverActionNode);
  return maneuver_action;
}
 
 
void HumanFailureEventsBBN::copyHumanFailureEventsBBN(HumanFailureEventsBBN & _hfebbn) {
  this->systemCriticalityNode = _hfebbn.systemCriticalityNode;
  this->informationLoadNode = _hfebbn.informationLoadNode;
  this->timeConstraintLoadNode = _hfebbn.timeConstraintLoadNode;
  this->cognitiveTaskLoadNode = _hfebbn.cognitiveTaskLoadNode;
  this->passiveAlarmLoadNode = _hfebbn.passiveAlarmLoadNode;
  this->taskComplexityNode = _hfebbn.taskComplexityNode;
  this->expertiseNode = _hfebbn.expertiseNode;
  this->stressNode = _hfebbn.stressNode;
  this->fatigueNode = _hfebbn.fatigueNode;
  this->problemSolvingStyleNode = _hfebbn.problemSolvingStyleNode;
  this->gatherStateInfoNode = _hfebbn.gatherStateInfoNode;
  this->gatherInfoModeNode = _hfebbn.gatherInfoModeNode;
  this->perceiveStateInfoNode = _hfebbn.perceiveStateInfoNode;
  this->gatherNewInfoNode = _hfebbn.gatherNewInfoNode;
  this->diagnosisNode = _hfebbn.diagnosisNode;
  this->strategySelectionNode = _hfebbn.strategySelectionNode;
  this->goalSelectionNode = _hfebbn.goalSelectionNode;
  this->strategyCommunicationNode = _hfebbn.strategyCommunicationNode;
  this->goalCommunicationNode = _hfebbn.goalCommunicationNode;
  this->procedureTransferNode = _hfebbn.procedureTransferNode;
  this->mentalProcedureNode = _hfebbn.mentalProcedureNode;
  this->procedureInterpretationNode = _hfebbn.procedureInterpretationNode;
  this->procedureStepNode = _hfebbn.procedureStepNode;
  this->maneuverActionNode = _hfebbn.maneuverActionNode;
  this->net = _hfebbn.net;
  this->system_criticality = _hfebbn.system_criticality;
  this->information_load = _hfebbn.information_load;
  this->time_constraint_load = _hfebbn.time_constraint_load;
  this->cognitive_task_load = _hfebbn.cognitive_task_load;
  this->passive_alarm_load = _hfebbn.passive_alarm_load;
  this->task_complexity = _hfebbn.task_complexity;
  this->expertise = _hfebbn.expertise;
  this->stress = _hfebbn.stress;
  this->fatigue = _hfebbn.fatigue;
  this->problem_solving_style = _hfebbn.problem_solving_style;
  this->net.UpdateBeliefs();
}
 
int HumanFailureEventsBBN::CreateCptNode(DSL_network &net,
                                         const char *id,
                                         const char *name,
                                         const char *outcomes[],
                                         int xPos,
                                         int yPos) {
  int handle = net.AddNode(DSL_CPT, id);
  DSL_node *node = net.GetNode(handle);
 
  DSL_idArray ida;
  for (const char **p = outcomes; *p != NULL; p++) {
    ida.Add(*p);
  }
  DSL_nodeDefinition *def = node->Definition();
  def->SetNumberOfOutcomes(ida);
 
  node->Info().Header().SetName(name);
 
  DSL_rectangle &position = node->Info().Screen().position;
  position.center_X = xPos;
  position.center_Y = yPos;
  position.width = 85;
  position.height = 55;
 
  return handle;
}
 
int HumanFailureEventsBBN::CreateNoisyMaxNode(DSL_network &net,
                                              const char *id,
                                              const char *name,
                                              const char *outcomes[],
                                              int xPos,
                                              int yPos) {
  int handle = net.AddNode(DSL_NOISY_MAX, id);
  DSL_node *node = net.GetNode(handle);
 
  DSL_idArray ida;
  for (const char **p = outcomes; *p != NULL; p++) {
    ida.Add(*p);
  }
  DSL_nodeDefinition *def = node->Definition();
  def->SetNumberOfOutcomes(ida);
 
  node->Info().Header().SetName(name);
 
  DSL_rectangle &position = node->Info().Screen().position;
  position.center_X = xPos;
  position.center_Y = yPos;
  position.width = 85;
  position.height = 55;
 
  return handle;
}
 
double HumanFailureEventsBBN::getFailurePosteriorProbability(DSL_network &net, int handle) {
  DSL_node *node = net.GetNode(handle);
  DSL_nodeValue *val = node->Value();
  const DSL_Dmatrix &posteriors = *val->GetMatrix();
  //return posteriors[0];
  return 1.0e-3;
}
 
void HumanFailureEventsBBN::reapplyEvidenceAfterLoad() {
  // SMILE (ENABLE_HCL) path: deserialized state is consumed only through
  // copyHumanFailureEventsBBN, which re-applies evidence via the setter path.
  // Intentionally a no-op in the HCL build.
}
 
#else // !ENABLE_HCL — BNCore implementation
 
namespace {
 
struct NoisyMaxParams {
  double link_fail[10]; // P(Failure | parent_i = Present), per parent
  double leak;          // P(Failure | leak)
};
 
// Expand noisy-MAX D-matrix parameters to a full CPT.
// For 10 binary parents: 2^10 parent combos × 2 child states = 2048 entries.
// Formula: P(Fail) = 1 - (1-leak) × prod_i(1 - d_i(x_i))
std::vector<double> expandNoisyMaxToCpt(const NoisyMaxParams &params) {
  constexpr int N = 10;
  constexpr int NUM_COMBOS = 1 << N;
  std::vector<double> cpt(NUM_COMBOS * 2);
  for (int combo = 0; combo < NUM_COMBOS; ++combo) {
    double prod = 1.0 - params.leak;
    for (int i = 0; i < N; ++i) {
      int state = (combo >> (N - 1 - i)) & 1;
      if (state == 0) // Present/Low/Poor → contributes to failure
        prod *= (1.0 - params.link_fail[i]);
    }
    double p_fail = 1.0 - prod;
    cpt[combo * 2] = p_fail;
    cpt[combo * 2 + 1] = 1.0 - p_fail;
  }
  return cpt;
}
 
// Link failure probabilities extracted from SMILE Noisy-MAX D-matrices.
// Parent order: SysCrit, InfoLoad, TimeConst, CogTask, PassAlarm,
//               TaskComplex, Expertise, Stress, Fatigue, PSS
// clang-format off
const NoisyMaxParams kGatherStateInfo       = {{0.0063,  0.00317, 0.0063,  0.00621, 0.00626, 0.00481, 0.0029,  0.00271, 0.00271, 0.00342}, 0.001};
const NoisyMaxParams kGatherInfoMode        = {{0.167,   0.084,   0.167,   0.164,   0.166,   0.127,   0.767,   0.0718,  0.0718,  0.0905},  0.0265};
const NoisyMaxParams kPerceiveStateInfo     = {{0.0528,  0.0266,  0.0528,  0.052,   0.0229,  0.0403,  0.0243,  0.0227,  0.0227,  0.0286},  0.00837};
const NoisyMaxParams kGatherNewInfo         = {{0.441,   0.222,   0.441,   0.435,   0.438,   0.337,   0.203,   0.19,    0.19,    0.239},   0.07};
const NoisyMaxParams kDiagnosis             = {{0.271,   0.109,   0.271,   0.268,   0.206,   0.236,   0.109,   0.0892,  0.0892,  0.147},   0.0431};
const NoisyMaxParams kStrategySelection     = {{0.063,   0.0252,  0.063,   0.0621,  0.00789, 0.0549,  0.0368,  0.0272,  0.0272,  0.0342},  0.01};
const NoisyMaxParams kGoalSelection         = {{0.063,   0.0252,  0.063,   0.0621,  0.00789, 0.0549,  0.0368,  0.0272,  0.0272,  0.0342},  0.01};
const NoisyMaxParams kStrategyCommunication = {{0.0378,  0.019,   0.0378,  0.0373,  0.0375,  0.0289,  0.0174,  0.0163,  0.0163,  0.0205},  0.006};
const NoisyMaxParams kGoalCommunication     = {{0.0378,  0.019,   0.0378,  0.0373,  0.0375,  0.0289,  0.0174,  0.0163,  0.0163,  0.0205},  0.006};
const NoisyMaxParams kProcedureTransfer     = {{0.063,   0.0252,  0.063,   0.0621,  0.0478,  0.0549,  0.0393,  0.0271,  0.0271,  0.0342},  0.01};
const NoisyMaxParams kMentalProcedure       = {{0.0154,  0.00617, 0.0154,  0.0152,  0.0117,  0.0197,  0.00962, 0.00662, 0.00662, 0.00838}, 0.00245};
const NoisyMaxParams kProcedureInterpretation={{0.0154,  0.00617, 0.0154,  0.0152,  0.0117,  0.0197,  0.00962, 0.00662, 0.00662, 0.00838}, 0.00245};
const NoisyMaxParams kProcedureStep         = {{0.063,   0.0252,  0.063,   0.0621,  0.0478,  0.0549,  0.0393,  0.0271,  0.0271,  0.0342},  0.01};
const NoisyMaxParams kManeuverAction        = {{0.0234,  0.0132,  0.0234,  0.0207,  0.0147,  0.0194,  0.0194,  0.0928,  0.0135,  0.0234},  0.00331};
// clang-format on
 
} // anonymous namespace
 
void HumanFailureEventsBBN::NetworkInitiation() {
  graph_ = std::make_unique<bncore::Graph>();
 
  // 10 PSF root nodes (binary, uniform prior for soft evidence)
  psf_ids_[0] = graph_->add_variable("SystemCriticality", {"Present", "Absent"});
  psf_ids_[1] = graph_->add_variable("InformationLoad", {"Present", "Absent"});
  psf_ids_[2] = graph_->add_variable("TimeConstraintLoad", {"Present", "Absent"});
  psf_ids_[3] = graph_->add_variable("CognitiveTaskLoad", {"Present", "Absent"});
  psf_ids_[4] = graph_->add_variable("PassiveAlarmLoad", {"Present", "Absent"});
  psf_ids_[5] = graph_->add_variable("TaskComplexity", {"Present", "Absent"});
  psf_ids_[6] = graph_->add_variable("Expertise", {"Low", "High"});
  psf_ids_[7] = graph_->add_variable("Stress", {"Present", "Absent"});
  psf_ids_[8] = graph_->add_variable("Fatigue", {"Present", "Absent"});
  psf_ids_[9] = graph_->add_variable("ProblemSolvingStyle", {"Poor", "Best"});
 
  // 14 HFE child nodes (binary: Failure/Success)
  hfe_ids_[0]  = graph_->add_variable("GatherStateInfo", {"Failure", "Success"});
  hfe_ids_[1]  = graph_->add_variable("GatherInfoMode", {"Failure", "Success"});
  hfe_ids_[2]  = graph_->add_variable("PerceiveStateInfo", {"Failure", "Success"});
  hfe_ids_[3]  = graph_->add_variable("GatherNewInfo", {"Failure", "Success"});
  hfe_ids_[4]  = graph_->add_variable("Diagnosis", {"Failure", "Success"});
  hfe_ids_[5]  = graph_->add_variable("StrategySelection", {"Failure", "Success"});
  hfe_ids_[6]  = graph_->add_variable("GoalSelection", {"Failure", "Success"});
  hfe_ids_[7]  = graph_->add_variable("StrategyCommunication", {"Failure", "Success"});
  hfe_ids_[8]  = graph_->add_variable("GoalCommunication", {"Failure", "Success"});
  hfe_ids_[9]  = graph_->add_variable("ProcedureTransfer", {"Failure", "Success"});
  hfe_ids_[10] = graph_->add_variable("MentalProcedure", {"Failure", "Success"});
  hfe_ids_[11] = graph_->add_variable("ProcedureInterpretation", {"Failure", "Success"});
  hfe_ids_[12] = graph_->add_variable("ProcedureStep", {"Failure", "Success"});
  hfe_ids_[13] = graph_->add_variable("ManeuverAction", {"Failure", "Success"});
 
  // 140 edges: every PSF -> every HFE
  for (std::size_t i = 0; i < 10; ++i)
    for (std::size_t j = 0; j < 14; ++j)
      graph_->add_edge(psf_ids_[i], hfe_ids_[j]);
 
  // Uniform priors for PSF nodes (soft evidence produces correct marginals)
  for (std::size_t i = 0; i < 10; ++i)
    graph_->set_cpt(psf_ids_[i], {0.5, 0.5});
 
  // Expand noisy-MAX D-matrices to full CPTs (2^10 x 2 = 2048 entries each)
  const NoisyMaxParams *hfe_params[14] = {
      &kGatherStateInfo, &kGatherInfoMode, &kPerceiveStateInfo,
      &kGatherNewInfo, &kDiagnosis, &kStrategySelection,
      &kGoalSelection, &kStrategyCommunication, &kGoalCommunication,
      &kProcedureTransfer, &kMentalProcedure, &kProcedureInterpretation,
      &kProcedureStep, &kManeuverAction};
  for (std::size_t j = 0; j < 14; ++j)
    graph_->set_cpt(hfe_ids_[j], expandNoisyMaxToCpt(*hfe_params[j]));
 
  // Compile junction tree and create inference engine
  jt_ = bncore::JunctionTreeCompiler::compile(*graph_);
  engine_ = std::make_unique<bncore::BatchExecutionEngine>(*jt_, 1, 1);
 
  // Apply initial soft evidence (all PSFs = 0.0 -> [0.0, 1.0])
  for (std::size_t i = 0; i < 10; ++i) {
    double likelihoods[2] = {0.0, 1.0};
    engine_->set_soft_evidence(psf_ids_[i], likelihoods, 2);
  }
}
 
void HumanFailureEventsBBN::updateAllPosteriors() {
  constexpr std::size_t NUM_VARS = 24; // 10 PSF + 14 HFE
  constexpr std::size_t NUM_HFE = 14;
 
  // No hard evidence — all -1
  std::vector<int> evidence(NUM_VARS, -1);
 
  // Query all 14 HFE nodes in one calibration pass.
  // evaluate_multi treats output_offsets as a prefix-sum array and reads
  // output_offsets[num_queries] for the total state count, so it needs
  // NUM_HFE + 1 entries.
  std::size_t query_vars[NUM_HFE];
  std::size_t output_offsets[NUM_HFE + 1];
  for (std::size_t i = 0; i < NUM_HFE; ++i) {
    query_vars[i] = hfe_ids_[i];
    output_offsets[i] = i * 2;
  }
  output_offsets[NUM_HFE] = NUM_HFE * 2;
 
  // Do NOT invalidate the engine's workspace cache here: the single-chunk fast
  // path reuses the cached BatchWorkspace via reset(), which restores clean
  // base potentials and re-applies the current soft evidence, giving
  // bitwise-identical posteriors. Forcing a rebuild would pay a full
  // BatchWorkspace construction on every update.
  double output[NUM_HFE * 2] = {0.0};
  engine_->evaluate_multi(evidence.data(), 1, NUM_VARS, query_vars, NUM_HFE,
                          output_offsets, output);
 
  // Cache P(Failure) for each HFE (index 0 of each pair)
  gather_state_info        = output[0];
  gather_info_mode         = output[2];
  perceive_state_info      = output[4];
  gather_new_info          = output[6];
  diagnosis                = output[8];
  strategy_selection       = output[10];
  goal_selection           = output[12];
  strategy_communication   = output[14];
  goal_communication       = output[16];
  procedure_transfer       = output[18];
  mental_procedure         = output[20];
  procedure_interpretation = output[22];
  procedure_step           = output[24];
  maneuver_action          = output[26];
 
  needs_update_ = false;
}
 
// Setters are value-guarded: identical evidence produces bitwise-identical
// posteriors, so re-applying an unchanged value (which happens every 0.5 s
// evaluation point via updateEvidenceForAllPSFs) must not dirty the engine.
// Without the guard, every tick would pay a full junction-tree calibration.
void HumanFailureEventsBBN::setSystemCriticality(double v) {
  if (v == system_criticality) return;
  system_criticality = v;
  double lk[2] = {v, 1.0 - v};
  engine_->set_soft_evidence(psf_ids_[0], lk, 2);
  needs_update_ = true;
}
void HumanFailureEventsBBN::setInformationLoad(double v) {
  if (v == information_load) return;
  information_load = v;
  double lk[2] = {v, 1.0 - v};
  engine_->set_soft_evidence(psf_ids_[1], lk, 2);
  needs_update_ = true;
}
void HumanFailureEventsBBN::setTimeConstraintLoad(double v) {
  if (v == time_constraint_load) return;
  time_constraint_load = v;
  double lk[2] = {v, 1.0 - v};
  engine_->set_soft_evidence(psf_ids_[2], lk, 2);
  needs_update_ = true;
}
void HumanFailureEventsBBN::setCognitiveTaskLoad(double v) {
  if (v == cognitive_task_load) return;
  cognitive_task_load = v;
  double lk[2] = {v, 1.0 - v};
  engine_->set_soft_evidence(psf_ids_[3], lk, 2);
  needs_update_ = true;
}
void HumanFailureEventsBBN::setPassiveAlarmLoad(double v) {
  if (v == passive_alarm_load) return;
  passive_alarm_load = v;
  double lk[2] = {v, 1.0 - v};
  engine_->set_soft_evidence(psf_ids_[4], lk, 2);
  needs_update_ = true;
}
void HumanFailureEventsBBN::setTaskComplexity(double v) {
  if (v == task_complexity) return;
  task_complexity = v;
  double lk[2] = {v, 1.0 - v};
  engine_->set_soft_evidence(psf_ids_[5], lk, 2);
  needs_update_ = true;
}
void HumanFailureEventsBBN::setExpertise(double v) {
  if (v == expertise) return;
  expertise = v;
  double lk[2] = {v, 1.0 - v};
  engine_->set_soft_evidence(psf_ids_[6], lk, 2);
  needs_update_ = true;
}
void HumanFailureEventsBBN::setStress(double v) {
  if (v == stress) return;
  stress = v;
  double lk[2] = {v, 1.0 - v};
  engine_->set_soft_evidence(psf_ids_[7], lk, 2);
  needs_update_ = true;
}
void HumanFailureEventsBBN::setFatigue(double v) {
  if (v == fatigue) return;
  fatigue = v;
  double lk[2] = {v, 1.0 - v};
  engine_->set_soft_evidence(psf_ids_[8], lk, 2);
  needs_update_ = true;
}
void HumanFailureEventsBBN::setProblemSolvingStyle(double v) {
  if (v == problem_solving_style) return;
  problem_solving_style = v;
  double lk[2] = {v, 1.0 - v};
  engine_->set_soft_evidence(psf_ids_[9], lk, 2);
  needs_update_ = true;
}
 
double HumanFailureEventsBBN::getGatherStateInfoFailureProbability() {
  if (needs_update_) updateAllPosteriors();
  return gather_state_info;
}
double HumanFailureEventsBBN::getGatherInfoModeFailureProbability() {
  if (needs_update_) updateAllPosteriors();
  return gather_info_mode;
}
double HumanFailureEventsBBN::getPerceiveStateInfoFailureProbability() {
  if (needs_update_) updateAllPosteriors();
  return perceive_state_info;
}
double HumanFailureEventsBBN::getGatherNewInfoFailureProbability() {
  if (needs_update_) updateAllPosteriors();
  return gather_new_info;
}
double HumanFailureEventsBBN::getDiagnosisFailureProbability() {
  if (needs_update_) updateAllPosteriors();
  return diagnosis;
}
double HumanFailureEventsBBN::getStrategySelectionFailureProbability() {
  if (needs_update_) updateAllPosteriors();
  return strategy_selection;
}
double HumanFailureEventsBBN::getGoalSelectionFailureProbability() {
  if (needs_update_) updateAllPosteriors();
  return goal_selection;
}
double HumanFailureEventsBBN::getStrategyCommunicationFailureProbability() {
  if (needs_update_) updateAllPosteriors();
  return strategy_communication;
}
double HumanFailureEventsBBN::getGoalCommunicationFailureProbability() {
  if (needs_update_) updateAllPosteriors();
  return goal_communication;
}
double HumanFailureEventsBBN::getProcedureTransferFailureProbability() {
  if (needs_update_) updateAllPosteriors();
  return procedure_transfer;
}
double HumanFailureEventsBBN::getMentalProcedureFailureProbability() {
  if (needs_update_) updateAllPosteriors();
  return mental_procedure;
}
double HumanFailureEventsBBN::getProcedureInterpretationFailureProbability() {
  if (needs_update_) updateAllPosteriors();
  return procedure_interpretation;
}
double HumanFailureEventsBBN::getProcedureStepFailureProbability() {
  if (needs_update_) updateAllPosteriors();
  return procedure_step;
}
double HumanFailureEventsBBN::getManeuverActionFailureProbability() {
  if (needs_update_) updateAllPosteriors();
  return maneuver_action;
}
 
void HumanFailureEventsBBN::copyHumanFailureEventsBBN(HumanFailureEventsBBN &_hfebbn) {
  system_criticality = _hfebbn.system_criticality;
  information_load = _hfebbn.information_load;
  time_constraint_load = _hfebbn.time_constraint_load;
  cognitive_task_load = _hfebbn.cognitive_task_load;
  passive_alarm_load = _hfebbn.passive_alarm_load;
  task_complexity = _hfebbn.task_complexity;
  expertise = _hfebbn.expertise;
  stress = _hfebbn.stress;
  fatigue = _hfebbn.fatigue;
  problem_solving_style = _hfebbn.problem_solving_style;
  reapplyEvidenceAfterLoad();
}
 
void HumanFailureEventsBBN::reapplyEvidenceAfterLoad() {
  // Re-sync the engine's soft evidence with the PSF members and force
  // re-inference. Called after a copy and after a Boost load: a freshly
  // deserialized object carries the saved PSF members but an engine still
  // holding the constructor's zero evidence, so without this a getter would
  // serve posteriors computed from the wrong evidence.
  double psf_values[10] = {
      system_criticality, information_load, time_constraint_load,
      cognitive_task_load, passive_alarm_load, task_complexity,
      expertise, stress, fatigue, problem_solving_style};
  for (std::size_t i = 0; i < 10; ++i) {
    double lk[2] = {psf_values[i], 1.0 - psf_values[i]};
    engine_->set_soft_evidence(psf_ids_[i], lk, 2);
  }
  needs_update_ = true;
}
 
#endif // ENABLE_HCL