Class RiskModel

java.lang.Object
neqsim.process.safety.risk.RiskModel
public class RiskModel extends Object
Probabilistic risk model for process safety analysis.

Provides Monte Carlo simulation, event tree analysis, and sensitivity analysis capabilities for quantitative risk assessment (QRA). Integrates with NeqSim's process simulation and safety scenario framework.

Typical Usage: 


RiskModel model = new RiskModel("HP Separator Study");
model.setProcessSystem(processSystem);

// Add initiating events with frequencies (per year)
model.addEvent(RiskEvent.builder().name("Small Leak").initiatingEvent(InitiatingEvent.LEAK_SMALL)
    .frequency(1e-3).consequenceCategory(ConsequenceCategory.MINOR).build());

// Run Monte Carlo analysis
RiskResult result = model.runMonteCarloAnalysis(10000);
result.exportToCSV("risk_results.csv");
Author:
NeqSim team

  • Field Details

    • name

      private final String name

    • events

      private final List<RiskEvent> events

    • processSystem

      private ProcessSystem processSystem

    • randomSeed

      private long randomSeed

    • storeMonteCarloSamples

      private boolean storeMonteCarloSamples

    • frequencyUncertaintyFactor

      private double frequencyUncertaintyFactor

    • probabilityUncertaintyStdDev

      private double probabilityUncertaintyStdDev

  • Constructor Details

    • RiskModel

      public RiskModel(String name)
      Creates a new risk model.
      Parameters:
      name - name of the risk study

  • Method Details

    • builder

      public static RiskModel.Builder builder()
      Builder pattern for RiskModel.
      Returns:
      new builder

    • setProcessSystem

      public void setProcessSystem(ProcessSystem system)

    • setRandomSeed

      public void setRandomSeed(long seed)

    • setFrequencyUncertaintyFactor

      public void setFrequencyUncertaintyFactor(double factor)

    • setProbabilityUncertaintyStdDev

      public void setProbabilityUncertaintyStdDev(double stdDev)

    • setStoreMonteCarloSamples

      public void setStoreMonteCarloSamples(boolean store)

    • addEvent

      public void addEvent(RiskEvent event)
      Adds a risk event to the model.
      Parameters:
      event - the risk event to add

    • addInitiatingEvent

      public RiskEvent addInitiatingEvent(String name, double frequency, RiskEvent.ConsequenceCategory category)
      Creates and adds a simple initiating event.
      Parameters:
      name - event name
      frequency - annual frequency
      category - consequence category
      Returns:
      the created event

    • addConditionalEvent

      public RiskEvent addConditionalEvent(String name, RiskEvent parentEvent, double probability, RiskEvent.ConsequenceCategory category)
      Adds a conditional event (branch in event tree).
      Parameters:
      name - event name
      parentEvent - the parent event
      probability - conditional probability
      category - consequence category if this branch occurs
      Returns:
      the created event

    • getEvents

      public List<RiskEvent> getEvents()
      Gets all events in the model.
      Returns:
      list of events

    • getInitiatingEvents

      public List<RiskEvent> getInitiatingEvents()
      Gets only initiating events (no parent).
      Returns:
      list of initiating events

    • runDeterministicAnalysis

      public RiskResult runDeterministicAnalysis()
      Runs deterministic risk calculation using point estimates.
      Returns:
      risk result with point estimates

    • runMonteCarloAnalysis

      public RiskResult runMonteCarloAnalysis(int iterations)
      Runs Monte Carlo simulation with uncertainty propagation.

      Frequencies are sampled from log-normal distributions. Probabilities are sampled from truncated normal distributions.

      Parameters:
      iterations - number of Monte Carlo iterations
      Returns:
      risk result with statistical metrics

    • runSensitivityAnalysis

      public SensitivityResult runSensitivityAnalysis(double lowFactor, double highFactor)
      Runs sensitivity analysis on event frequencies.

      Varies each event frequency by the specified factors and observes the effect on total risk.

      Parameters:
      lowFactor - multiplier for low case (e.g., 0.1)
      highFactor - multiplier for high case (e.g., 10.0)
      Returns:
      sensitivity analysis result

    • runSensitivityAnalysis

      public SensitivityResult runSensitivityAnalysis(double lowFactor, double highFactor, int numPoints)
      Runs sensitivity analysis with specified number of points.
      Parameters:
      lowFactor - multiplier for low case
      highFactor - multiplier for high case
      numPoints - number of points between low and high (including endpoints)
      Returns:
      sensitivity analysis result

    • runSimulationBasedAnalysis

      public RiskResult runSimulationBasedAnalysis()
      Runs simulation-based analysis for events with attached scenarios.

      For events that have ProcessSafetyScenario attached, uses the scenario consequence category. Future implementation could integrate with ProcessScenarioRunner for dynamic simulation.

      Returns:
      risk result with scenario-based consequences

    • calculateTotalRisk

      private double calculateTotalRisk()

    • getTotalFrequency

      private double getTotalFrequency()

    • sampleLogNormal

      private double sampleLogNormal(Random random, double median, double errorFactor)

    • sampleTruncatedNormal

      private double sampleTruncatedNormal(Random random, double mean, double stdDev)

    • getName

      public String getName()

    • toString

      public String toString()
      Overrides:
      toString in class Object