quantifier.hpp

Go to the documentation of this file.

#pragma once
//
// Exact fault tree quantification by compilation to a Bayesian network.
//
// Every fault tree node becomes a binary variable with states
// {"Failed", "Working"} (state index 0 is Failed, matching the crew BBN's
// convention that index 0 is the failure state). Basic events get the prior
// {p, 1-p}; gates get a deterministic conditional table over their inputs.
// BNCore then compiles a junction tree and returns the exact marginal.
//
// Going through the BN rather than multiplying gate probabilities directly is
// what makes repeated events correct: a basic event feeding several gates is
// one variable with several children, so the shared dependence is accounted
// for instead of being double counted.
//
#include "faulttree/fault_tree.hpp"
#include <cstddef>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace bncore {
class Graph;
class JunctionTree;
class BatchExecutionEngine;
} // namespace bncore
 
namespace faulttree {
 
inline constexpr std::size_t kMaxGateInputs = 20;
 
class Quantifier {
public:
  explicit Quantifier(const FaultTree &tree);
  ~Quantifier();
 
  Quantifier(const Quantifier &) = delete;
  Quantifier &operator=(const Quantifier &) = delete;
 
  [[nodiscard]] double topEventProbability() const;
 
  [[nodiscard]] double probabilityOf(const std::string &name) const;
 
  void setBasicEventProbability(const std::string &name, double probability);
 
  [[nodiscard]] std::vector<std::string> basicEventNames() const;
 
  [[nodiscard]] bool isDefined(const std::string &name) const;
 
private:
  void build();
 
  FaultTree tree_;                                         
  std::unique_ptr<bncore::Graph> graph_;                   
  std::unique_ptr<bncore::JunctionTree> junction_tree_;    
  std::unique_ptr<bncore::BatchExecutionEngine> engine_;   
  std::unordered_map<std::string, std::size_t> var_of_node_; 
};
 
} // namespace faulttree