Classes

• class AsyncScramWorker
  Defines a class for asynchronous execution of SCRAM engine.
• class ScramWorker
  Defines a class for synchronous execution.
  • struct DLError
    Dynamic library errors.
  • class Error
    The Error class is the base class for all exceptions specific to the SCRAM code.
  • struct IOError
    For input/output related errors.
  • struct IllegalOperation
    This error can be used to indicate that call for a function or operation is not legal.
  • class Logger
    This is a general purpose logger; however, its main usage is asserted to be for debugging.
  • struct LogicError
    Signals internal logic errors, for example, pre-condition failure or use of functionality in ways not designed to.
  • class Reporter
    Facilities to report analysis results.
  • struct SettingsError
    The error in analysis settings.
  • class Timer
    Automatic (scoped) timer to log process duration.
  • struct VersionError
    The minimum required version is not satisfied.
    • class Analysis
      Base abstract class for all analysis with settings.
    • class Bdd
      Analysis of PDAGs with Binary Decision Diagrams.
      • class Consensus
        Provides access to consensus calculation private facilities.
      • struct Function
        Holder of computation resultant functions and gate representations.
    • class CacheTable
      A hash table without collision resolution.
    • class Constant
      Representation of a node that is a Boolean constant TRUE.
    • class CustomPreprocessor
      Undefined template class for specialization of Preprocessor for needs of specific analysis algorithms.
    • class CustomPreprocessor< Bdd >
      Specialization of preprocessing for BDD based analyses.
    • class CustomPreprocessor< Mocus >
      Specialization of preprocessing for MOCUS based analyses.
    • class CustomPreprocessor< Zbdd >
      Specialization of preprocessing for ZBDD based analyses.
    • class CutSetProbabilityCalculator
      Quantitative calculator of a probability value of a single cut set.
    • class EventTreeAnalysis
      Event tree analysis functionality.
      • struct PathCollector
        Expressions and formulas collected in an event tree path.
      • struct Result
        The analysis results binding to the unique analysis target.
      • struct SequenceCollector
        Walks the event tree paths and collects sequences.
    • class FaultTreeAnalysis
      Fault tree analysis functionality.
    • class FaultTreeAnalyzer
      Fault tree analysis facility with specific algorithms.
    • class Gate
      An indexed gate for use in a PDAG.
    • class ImportanceAnalysis
      Analysis of importance factors of risk model variables.
    • class ImportanceAnalyzer
      Analyzer of importance factors with the help from probability analyzers.
    • class ImportanceAnalyzer< Bdd >
      Specialization of importance analyzer with Binary Decision Diagrams.
    • class ImportanceAnalyzerBase
      Base class for analyzers of importance factors with the help from probability analyzers.
    • struct ImportanceFactors
      Collection of importance factors for variables.
    • struct ImportanceRecord
      Mapping of an event and its importance.
    • struct IntrusivePtrCast
      Provides pointer and reference cast wrappers for intrusive Vertex pointers.
    • class Ite
      Representation of non-terminal if-then-else vertices in BDD graphs.
    • struct Literal
      Event or its complement that may appear in products.
    • class McubCalculator
      Quantitative calculator of probability values with the Min-Cut-Upper Bound approximation.
    • class Mocus
      This class analyzes normalized, preprocessed, and indexed fault trees to generate minimal cut sets with the MOCUS algorithm.
    • class Node
      An abstract base class that represents a node in a PDAG.
    • class NodeParentManager
      A manager of information about parents.
    • class NonTerminal
      Representation of non-terminal vertices in BDD graphs.
    • struct PairHash
      Function for hashing a pair of ordered numbers.
    • class Pdag
      PDAG is a propositional directed acyclic graph.
      • class NodeIndexGenerator
        Generator of unique indices for graph nodes.
      • class NullGateRegistrar
        Registers pass-through or Null logic gates belonging to the graph.
      • struct ProcessedNodes
        Holder for nodes that are created from fault tree events.
      • struct Substitution
        Non-declarative substitutions.
    • class Preprocessor
      The class provides main preprocessing operations over a PDAG to simplify the fault tree and to help analysis run more efficiently.
      • class DecompositionProcessor
        Functor for processing of decomposition setups with common nodes.
      • class GateSet
        Container of unique gates.
        • struct Equal
          Functor for equality test for gates by their arguments.
        • struct Hash
          Functor for hashing gates by their arguments.
      • struct MergeTable
        Helper struct for algorithms that must make an optimal decision how to merge or factor out common arguments of gates into new gates.
    • class ProbabilityAnalysis
      Main quantitative analysis class.
    • class ProbabilityAnalyzer
      Fault-tree-analysis-aware probability analyzer.
    • class ProbabilityAnalyzer< Bdd >
      Specialization of probability analyzer with Binary Decision Diagrams.
    • class ProbabilityAnalyzerBase
      Base class for Probability analyzers.
    • class Product
      Collection of unique literals.
      • struct LiteralExtractor
        Converter of indices in products to Literals.
    • class ProductContainer
      A container of analysis result products with Literals.
      • struct ProductExtractor
        Converter of analysis products with indices into products with literals.
    • class RareEventCalculator
      Quantitative calculator of probability values with the Rare-Event approximation.
    • class RiskAnalysis
      Main system that performs analyses.
      • struct Context
        Provides the optional context of the analysis.
      • struct EtaResult
        The analysis results grouped by an event-tree.
      • struct Result
        The analysis results binding to the unique analysis target.
        • struct Id
          The analysis target type as a unique identifier.
    • class SetNode
      Representation of non-terminal nodes in ZBDD.
    • class Settings
      Builder for analysis settings.
    • struct Sil
      Safety Integrity Level metrics.
    • class Terminal
      Representation of terminal vertices in BDD graphs.
    • struct TripletHash
      Functor for hashing triplets of ordered numbers.
    • class UncertaintyAnalysis
      Uncertainty analysis and statistics for top event or gate probabilities with probability distributions of basic events.
    • class UncertaintyAnalyzer
      Uncertainty analysis facility.
    • class UniqueTable
      A hash table for keeping BDD reduced.
    • class Variable
      Boolean variables in a Boolean formula or graph.
    • class Vertex
      Representation of a vertex in BDD graphs.
    • class WeakIntrusivePtr
      A weak pointer to store in BDD unique tables.
    • class Zbdd
      Zero-Suppressed Binary Decision Diagrams for set manipulations.
      • class const_iterator
        Iterator over products in a ZBDD container.
        • class module_iterator
          Iterator over sets in the module ZBDD represented by a proxy node.
      • class CutSetContainer
        Storage for generated cut sets in MOCUS.
    • class Alignment
      Alignment configuration for the whole model per analysis.
    • class AlphaFactorModel
      Alpha factor model characterizes failure of exactly k members of the group due to common cause.
    • class Attribute
      MEF Element Attributes.
    • class BasicEvent
      Representation of a basic event in a fault tree.
    • class BetaDeviate
      Beta distribution.
    • class BetaFactorModel
      Common cause failure model that assumes, if common cause failure occurs, then all components or members fail simultaneously or within short time.
    • struct Bifunctor
      Creates a functor for functions with two arguments.
    • class Block
      Compound instructions.
    • class Branch
      The branch representation in event trees.
    • class CcfEvent
      A basic event that represents a multiple failure of a group of events due to a common cause.
    • class CcfGroup
      Abstract base class for all common cause failure models.
    • class CollectExpression
      The operation of collecting expressions for event tree sequences.
    • class CollectFormula
      The operation of connecting fault tree events into the event tree.
    • class Component
      Component is for logical grouping of events, gates, and other components.
    • class Composite
      The composition of multiple mef::Containers.
    • class ConstantExpression
      Indicates a constant value.
    • class Container
      The MEF Container of unique elements.
    • class ContainerElement
      Elements in MEF containers.
    • struct Context
      The context for test-event expressions.
    • struct CycleError
      Unacceptable cycles in model structures.
    • struct DomainError
      Invalid domain for values or arguments.
    • struct DuplicateElementError
      This error indicates that elements must be unique.
    • class Element
      The MEF Element with attributes and a label.
      • struct AttributeKey
        Attribute key extractor.
    • class Event
      Abstract base class for general fault tree events.
    • class EventTree
      Event Tree representation with MEF constructs.
    • class Exponential
      Negative exponential distribution with hourly failure rate and time.
    • class Expression
      Abstract base class for all sorts of expressions to describe events.
    • class ExpressionFormula
      CRTP for Expressions with the same formula to evaluate and sample.
    • class ExternExpression
      Expression evaluating an extern function with expression arguments.
    • class ExternFunction
      Extern function abstraction to be referenced by expressions.
    • class ExternFunction< void >
      Abstract base class for ExternFunction concrete types.
    • class ExternLibrary
      The MEF construct to extend expressions with external libraries.
    • class FaultTree
      Fault tree representation as a container of gates, basic and house events, and other information.
    • class Fork
      Functional event forks.
    • class Formula
      Boolean formula with connectives and arguments.
      • struct Arg
        Formula argument with a complement flag.
      • class ArgSet
        The set of formula arguments.
    • class FunctionalEvent
      Representation of functional events in event trees.
    • struct Functor
      Creates a functor out of function pointer to common cmath functions.
    • class GammaDeviate
      Gamma distribution.
    • class Gate
      A representation of a gate in a fault tree.
    • class Glm
      Exponential with probability of failure on demand, hourly failure rate, hourly repairing rate, and time.
    • class Histogram
      Histogram distribution.
    • class HouseEvent
      Representation of a house event in a fault tree.
    • class Id
      Mixin class for assigning unique identifiers to elements.
    • class IfThenElse
      Conditional application of instructions.
    • class Initializer
      This class operates on input files to initialize analysis constructs like models, fault trees, and events.
      • struct Extractor
      • struct Extractor< T, -1 >
        Specialization of Extractor to extract all expressions into arg vector.
    • class InitiatingEvent
      Event-tree Initiating Event.
    • class Instruction
      Instructions and rules for event tree paths.
    • class InstructionVisitor
      The base abstract class for instruction visitors.
    • class Ite
      If-Then-Else ternary expression.
    • class Link
      A link to another event tree in end-states only.
    • class LognormalDeviate
      Log-normal distribution.
      • struct Flavor
        Support for parametrization differences.
      • class Logarithmic
        Computation with the log-normal mean and error factor.
      • class Normal
        Computation with normal mean and standard distribution.
    • class Mean
      The average of argument expression values.
    • class MglModel
      Multiple Greek Letters model characterizes failure of sub-groups of the group due to common cause.
    • class MissionTime
      The special parameter for system mission time.
    • class Model
      This class represents a risk analysis model.
    • class NamedBranch
      Named branches that can be referenced and reused.
    • class NaryExpression
      n-ary expressions.
    • class NaryExpression< T, -1 >
      Multivariate expression.
    • class NaryExpression< T, 1 >
      Unary expression.
    • class NaryExpression< T, 2 >
      Binary expression.
    • class NodeMark
      Mixin class for providing marks for graph nodes.
    • class NormalDeviate
      Normal distribution.
    • class NullVisitor
      Visits only instructions and ignores non-instructions.
    • class Parameter
      This class provides a representation of a variable in basic event description.
    • class Path
      Functional-event state paths in event trees.
    • class PeriodicTest
      Periodic test with 3 phases: deploy, test, functioning.
      • class Complete
        The full representation of periodic test with 11 arguments.
      • struct Flavor
        The base class for various flavors of periodic-test computation.
      • class InstantRepair
        The tests and repairs are instantaneous and always successful.
      • class InstantTest
        The tests are instantaneous and always successful, but repairs are not.
    • class Phase
      Phases of alignments the models spends its time fraction.
    • class PhiFactorModel
      Phi factor model is a simplification, where fractions of k-member group failure is given directly.
    • class RandomDeviate
      Abstract base class for all deviate expressions.
    • class Role
      Mixin class that manages private or public roles for elements as needed.
    • class Rule
      A reusable collection of instructions.
    • class Sequence
      Representation of sequences in event trees.
    • class SetHouseEvent
      The operation to change house-events.
    • class Substitution
      The general representation for Delete Terms, Recovery Rules, and Exchange Events.
    • class Switch
      Switch-Case conditional operations.
      • struct Case
        Individual cases in the switch-case operation.
    • class TableRange
      Wraps the element container tables into ranges of plain references to hide the memory smart or raw pointers.
      • class iterator
        The proxy forward iterator to extract values instead of pointers.
    • class TestEvent
      The abstract base class for non-deviate test-event expressions.
    • class TestFunctionalEvent
      Upon event-tree walk, tests whether a functional event has occurred.
    • class TestInitiatingEvent
      Upon event-tree walk, tests whether an initiating event has occurred.
    • struct UndefinedElement
      The error for undefined elements in a model.
    • class UniformDeviate
      Uniform distribution.
    • class Usage
      Mixin class for providing usage marks for elements.
    • struct ValidityError
      Model validity errors.
    • class Visitable
      Default visit for instruction type of T.
    • class Weibull
      Weibull distribution with scale, shape, time shift, and time.
      • struct container_of
        Finds the container type for the given element type.
      • struct container_of_impl
        Implementation of container_of to deal w/ empty type list.
      • struct container_of_impl< E, void >
        Specialization for an empty type list.
    • class Document
      XML DOM tree document.
    • class Element
      XML Element adaptor.
      • class Range
        The range for elements.
        • class iterator
          Iterator over range elements.
    • struct Error
      The base for all XML related errors.
    • struct ParseError
      XML parsing errors.
    • class Stream
      XML Stream document.
    • class StreamElement
      Writer of data formed as an XML element to a stream.
    • struct StreamError
      Errors in using XML streaming facilities.
    • class Validator
      RelaxNG validator.
    • struct ValidityError
      XML document validity errors.
    • struct XIncludeError
      XInclude resolution issues.
      • class FileStream
        Adaptor for stdio FILE stream with write generic interface.
      • class Indenter
        Manages XML element indentation upon output.
        • class Indentation
          RAII class to manage the current indentation string.

---

Updated on 2025-11-11 at 16:51:09 +0000