fault_tree.hpp

Go to the documentation of this file.

#pragma once
//
// Fault tree model: a named DAG of gates over basic events.
//
// The model deliberately mirrors the semantics the legacy HCL resolver
// implemented for GeNIe/SMILE `.fta` files (src/HCL/hcl/HCLFTResolver.cpp), so
// that trees authored against the old stack quantify identically here.
//
// Node identity is the `<node name="...">` string, not the XML `id`. A node
// that appears in several places in the file is defined once and referenced
// everywhere else, which is what makes repeated (common-cause) basic events
// shared rather than duplicated.
//
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace faulttree {
 
class FaultTreeError : public std::runtime_error {
public:
  explicit FaultTreeError(const std::string &what) : std::runtime_error(what) {}
};
 
enum class GateType {
  Basic, 
  And,   
  Or,    
  KofN,  
  Not    
};
 
struct Node {
  std::string name;
  GateType type = GateType::Basic;
  double probability = 0.0;            
  int k = 1;                           
  std::vector<std::string> children;   
};
 
class FaultTree {
public:
  void addNode(Node node);
 
  [[nodiscard]] bool hasNode(const std::string &name) const;
 
  [[nodiscard]] const Node &node(const std::string &name) const;
 
  [[nodiscard]] const std::vector<Node> &nodes() const { return nodes_; }
 
  [[nodiscard]] std::size_t size() const { return nodes_.size(); }
 
  void setTop(const std::string &name);
 
  [[nodiscard]] const std::string &top() const;
 
  [[nodiscard]] std::vector<std::string> basicEventNames() const;
 
  void setBasicEventProbability(const std::string &name, double probability);
 
  void validate() const;
 
private:
  Node &mutableNode(const std::string &name);
 
  std::vector<Node> nodes_;                              
  std::unordered_map<std::string, std::size_t> index_;   
  std::string top_;                                      
};
 
} // namespace faulttree