fta_parser.cpp

Go to the documentation of this file.

#include "faulttree/fta_parser.hpp"
 
#include "faulttree/xml_lite.hpp"
 
#include <sstream>
#include <string>
 
namespace faulttree {
 
namespace {
 
double parseProbability(const std::string &text, const std::string &node_name) {
  try {
    std::size_t consumed = 0;
    double value = std::stod(text, &consumed);
    while (consumed < text.size() &&
           std::isspace(static_cast<unsigned char>(text[consumed])) != 0) {
      ++consumed;
    }
    if (consumed != text.size()) {
      throw FaultTreeError("basic event '" + node_name +
                           "' has a malformed failureProbability '" + text + "'");
    }
    return value;
  } catch (const std::invalid_argument &) {
    throw FaultTreeError("basic event '" + node_name +
                         "' has a malformed failureProbability '" + text + "'");
  } catch (const std::out_of_range &) {
    throw FaultTreeError("basic event '" + node_name +
                         "' has an out-of-range failureProbability '" + text + "'");
  }
}
 
int parseK(const std::string &text, const std::string &node_name) {
  if (text.empty()) { return 0; }
  try {
    std::size_t consumed = 0;
    int value = std::stoi(text, &consumed);
    if (consumed != text.size()) {
      throw FaultTreeError("K/N gate '" + node_name + "' has a malformed k '" +
                           text + "'");
    }
    return value;
  } catch (const std::invalid_argument &) {
    throw FaultTreeError("K/N gate '" + node_name + "' has a malformed k '" +
                         text + "'");
  } catch (const std::out_of_range &) {
    throw FaultTreeError("K/N gate '" + node_name + "' has an out-of-range k '" +
                         text + "'");
  }
}
 
std::string parseNode(const xml::Element &element, FaultTree &tree) {
  if (element.attribute("id") == nullptr) { return {}; }
 
  const xml::Element *info = element.child("node");
  if (info == nullptr) {
    throw FaultTreeError("an ftaNode is missing its <node> definition");
  }
  const std::string *name_attr = info->attribute("name");
  if (name_attr == nullptr || name_attr->empty()) {
    throw FaultTreeError("an ftaNode is missing its node name");
  }
  const std::string name = *name_attr;
 
  // Identity is the node name: a node that appears again anywhere in the file
  // is the same node, which is what shares repeated (common-cause) events.
  if (tree.hasNode(name)) { return name; }
 
  const std::string type = element.attributeOr("type", "");
  Node node;
  node.name = name;
 
  if (type == "2" || type == "3") {
    if (element.child("linkedBBN") != nullptr) {
      throw FaultTreeError("basic event '" + name +
                           "' is linked to a BBN variable, which this "
                           "quantifier does not support");
    }
    node.type = GateType::Basic;
    node.probability =
        parseProbability(element.attributeOr("failureProbability", "0"), name);
  } else if (type == "4") {
    const xml::Element *link = element.child("transferUpFTADiagram");
    if (link == nullptr) {
      throw FaultTreeError("transfer gate '" + name +
                           "' has no transferUpFTADiagram reference");
    }
    const std::string ref = link->attributeOr("ref", "");
    if (ref.empty()) {
      throw FaultTreeError("transfer gate '" + name + "' has an empty reference");
    }
    // The legacy resolver models a transfer as an AND over the referenced
    // diagram, so a transfer contributes nothing of its own.
    node.type = GateType::And;
    node.children.push_back(ref);
  } else if (type == "5") {
    // Diagram bookkeeping, not logic: GeNIe emits a type 5 node listing the
    // diagram's transfer-up children (<tranferUpChild ref=...>, its spelling).
    // The legacy resolver had no branch for it and fell through to the gate
    // case with an uninitialised gate type, so it never quantified meaningfully.
    return {};
  } else if (type == "0" || type == "1" || type == "6" || type == "7") {
    if (type == "0") {
      node.type = GateType::And;
    } else if (type == "1") {
      node.type = GateType::Or;
    } else if (type == "6") {
      node.type = GateType::KofN;
    } else {
      node.type = GateType::Not;
    }
    node.k = parseK(element.attributeOr("k", ""), name);
 
    for (const auto &child : element.children) {
      if (child.name != "ftaNode") { continue; }
      std::string child_name = parseNode(child, tree);
      if (!child_name.empty()) { node.children.push_back(child_name); }
    }
  } else {
    // The legacy resolver left the gate type uninitialised here; we refuse
    // rather than quantify something undefined.
    throw FaultTreeError("node '" + name + "' has unsupported type '" + type + "'");
  }
 
  tree.addNode(std::move(node));
  return name;
}
 
FaultTree buildFromRoot(const xml::Element &root, const std::string &origin) {
  if (root.name != "ftaDiagram") {
    throw FaultTreeError("expected a <ftaDiagram> root in " + origin +
                         ", found <" + root.name + ">");
  }
 
  FaultTree tree;
  std::string top;
  for (const auto &child : root.children) {
    if (child.name != "ftaNode") { continue; }
    std::string name = parseNode(child, tree);
    // The diagram's first node is its top event; later siblings are subtrees
    // reachable through transfer gates.
    if (!name.empty() && top.empty()) { top = name; }
  }
  if (top.empty()) { throw FaultTreeError(origin + " has no top node"); }
 
  tree.setTop(top);
  tree.validate();
  return tree;
}
 
} // namespace
 
FaultTree parseFtaString(const std::string &text) {
  return buildFromRoot(xml::parse(text), "the fault tree diagram");
}
 
FaultTree parseFtaFile(const std::string &path) {
  return buildFromRoot(xml::parseFile(path), "'" + path + "'");
}
 
} // namespace faulttree