Exact minimal cutsets for PRA fault trees.

Afterburner is a minimal cutset generator compatible with risk modeling and risk monitoring software. It works the way established quantifiers do and can take the place of FTREX with the same cutsets.

Scroll ↓

The host calls Afterburner the way it calls any quantifier, and Afterburner writes the files the host expects. Your model, your truncation and your recovery rules do not change.

See the timing results by model · Read the summary · Benchmark your model

How it works

  1. Reads the model. Afterburner reads the fault tree file the host exports, with its gates, events, values, top events, truncation and options. It checks the logic first: circular logic and undefined events are reported, not guessed.
  2. Plans the work. It orders the events and works out which parts of the tree can be built independently, so they can run at the same time on different processor threads.
  3. Builds cutsets as a decision diagram. The cutsets of each gate are held in a zero-suppressed decision diagram (ZDD), a compact structure in which cutsets that share events share storage. Gates are built from the bottom of the tree up, each from its inputs.
  4. Truncates while it builds. A cutset whose value falls below the truncation is removed as soon as it is formed, not at the end, so the work stays close to the size of the answer you keep. Every truncation decision uses exact arithmetic.
  5. Keeps the minimal cutsets and checks them. Non-minimal cutsets are removed. Before the cutset file is written, a separate part of the program checks every cutset again.

More than speed

Checks its own answer

Before the cutset file is written, a separate part of the program checks every cutset again: its value against the truncation, that it leads to its top event, that it appears only once, and the exact sum and minimal cutset upper bound (MCUB). The file is written only after the check passes.

Exact arithmetic throughout

Event values are read as exact decimals, and cutset values, sums and every truncation decision are computed exactly. A cutset right at the truncation limit is never kept or dropped because of rounding.

Divides the work by memory and processors

Afterburner splits the calculation across the processor threads and sizes the work to the memory the machine has, adjusting as the run goes. The section below says how.

Speed features never change the answer

The optional speed-ups work within a fixed memory allowance. When it is used up, they step aside and the standard path does the work, so the cutsets are the same either way.

Two levels of diagnostics you can share

/DIAG adds a "where the time went" report to the log, part by part. /DIAG=2 goes deeper, for a model that is giving trouble. Neither report holds a gate, event, top or file name, or a path, so you can send it to us and we can tune Afterburner to your models without your model ever leaving your site. A run that is stopped early still leaves the report so far.

Never guesses

Circular logic and undefined events are reported. An option or model feature Afterburner does not support stops the run with an error (.ERR) file and exit code -1; an option that would change the result is never ignored.

Tunes itself to each model and machine

Afterburner makes more than a dozen tuning decisions on its own for every run, so there is nothing to tune by hand. None of them changes the cutsets: they decide only how the work is done. The log records what was chosen and why.

To the model

It reads the structure of the fault tree, such as its complemented (NOT) logic, its k-of-n gates and where the initiating events sit, and picks the calculation methods that suit it. Methods that would not help a model are left out of its run.

To the machine

It sets the number of threads from the processors and the free memory. It sizes its working caches to how many threads are busy, and gives its optional speed-ups a memory allowance of their own. If memory gets tight during a run, it cuts back to stay within what the machine has.

From earlier runs

It remembers how much memory each model needed at each truncation on this machine, and starts the next run of the same model with the thread count that fits. A first run starts from a safe estimate.

What you can set

Optional. The results on this site use the automatic choices, with the /DIAG report on.

/MT=N
Use N threads instead of the automatic choice, for example to leave processors free for other work.
/DIAG
Add the "where the time went" report to the log.
/DIAG=2
A deeper report for a model that is giving trouble. It makes the run slower. Both reports are free of model names, so they are safe to send us.

The truncation, the top events and the usual switches a host sends are read as they always are.

Works like the quantifiers you already use

Afterburner follows the conventions PRA quantifiers share, so the host, the files and the results look the way they always have.

Reads and writes the host's files

Reads the fault tree (.FTP) file that CAFTA or PhoenixRM writes and writes the .RAW cutset file the host reads back. It accepts the command line hosts already send a quantifier: the truncation, the top event list and the usual switches. The exit code is the total cutset count.

Gives the same cutsets as FTREX

On every plant model and truncation we compared, Afterburner returned the same number of cutsets as FTREX under at least one of its settings.

Handles PRA logic

AND and OR gates, k-of-n (voting) gates, complemented (NOT) logic, initiating events with at most one initiator per cutset, house events, circular logic and undefined events.

Runs on its own

No other quantifier needs to be installed. Afterburner computes every result it reports.

Note: Afterburner replaces only the cutset generation step. QRecover and the recovery rules run after it as they do today.

Using it with Phoenix and Architect software

In any Phoenix or Architect software that runs a quantifier, such as CAFTA or Phoenix Risk Monitor, point the quantifier settings at the Afterburner executable, as you would for any other quantifier. The model, the truncation and the host's options reach Afterburner the way they reach any quantifier.

Requirements

  • The computer must run 64-bit Windows.
  • The processor must support AVX2: Intel processors from 2013 on, AMD processors from 2015 on. On a processor without it, Afterburner stops with a clear message.
  • Memory should suit the model and the truncation. Deep truncations of large models need more.