Uncertainty Quantification
A Standard or Comprehensive NeqSim task must report P10/P50/P90 and a tornado
diagram. In practice that gets written from scratch in every notebook, and the
same four defects recur: sampling that clusters because it is plain
pseudo-random at n = 200, a Monte Carlo loop that re-solves the flowsheet for a
gas price that never touches it, no check that the run converged, and a tornado
presented as if it were a sensitivity analysis when it cannot see interaction.
This skill supplies the sampling, the statistics, the caching, the convergence
gate and the report block. It does not own the model — the task supplies that.
When to Use
- A task must produce
uncertainty for results.json: P10/P50/P90, mean,
standard deviation, probability of a negative outcome, tornado.
- A Monte Carlo loop wraps an expensive NeqSim flowsheet and the evaluation
budget is the binding constraint.
- Parameters must be screened before a sensitivity budget is committed.
- An interaction between uncertain inputs is suspected and a tornado is not
enough.
- An existing uncertainty block must be audited: enough samples, converged,
correct percentile convention?
When Not to Use
- As an optimiser. Searching for the best setpoints is
neqsim-optimization-and-doe; this skill propagates uncertainty through a
fixed design.
- To invent input ranges. A distribution with no basis produces a precise
answer to an arbitrary question — record where each range came from.
- For correlated inputs. Every marginal is sampled independently; correlation
between, say, price and cost inflation is not represented.
- As a substitute for a risk register. A probability distribution on an output
is not a hazard assessment.
Inputs
| Input |
Meaning |
parameters |
list of Distribution objects, each with name, unit, kind |
kind |
"technical" (drives the expensive stage) or "economic" (cheap stage only) |
model |
f(values) -> float, for a single-stage study |
technical / economic |
the two-stage split: g(technical) -> intermediate, h(intermediate, economic) -> float |
sampling_method |
"lhs" (default), "random", or "halton" |
seed |
integer for reproducibility |
n |
sample count; at least 200 for a simulation-backed run |
Outputs
| Output |
Meaning |
StudyResult.summary |
count, mean, std, min, max, p10/p50/p90, standard error, drift, P(negative) |
StudyResult.cache_report |
technical/economic evaluations and cache hits |
UncertaintyStudy.tornado() |
swing-ranked TornadoEntry list |
UncertaintyReport.to_results_json() |
the uncertainty block |
UncertaintyReport.blockers() |
why the block may not be presented as converged |
backends.sobol_indices(...) |
first-order S1 and total-order ST with confidence intervals |
backends.fit_polynomial_chaos(...) |
surrogate, mean, std, S1, evaluation count |
Engineering Method
1. Marginals separated from the sampler. Every distribution exposes an
inverse CDF, and the sampler only produces points in the unit hypercube. One set
of parameter definitions therefore drives a pseudo-random run, a Latin-hypercube
run, a Halton run, and an optional SALib design without redefinition — and a
triangular input is never silently replaced by a uniform one because a sampler
wanted bounds.
2. Latin hypercube by default. At the sample counts a NeqSim-backed study
can afford (a few hundred), plain pseudo-random sampling leaves visible gaps in
the marginals. Latin hypercube places exactly one point per stratum in every
dimension, so the estimate of a percentile is far less sensitive to the seed.
3. Technical / economic split. The expensive stage is cached on its inputs:
$$
y = h\big(g(\mathbf{x}\text{tech}),; \mathbf{x}\text{econ}\big)
$$
Where this genuinely pays is the tornado: every economic row sits at base
technical values, so four economic parameters cost one flowsheet solve instead
of eight. In the Monte Carlo itself a continuous technical parameter takes a
new value on every sample, so there is nothing to reuse — cache_hits will be
zero and the report says so rather than implying a saving that did not happen.
4. Percentile convention. p10 is the 10th percentile, the low estimate,
so p10 <= p50 <= p90 always holds — this is what the task gate enforces. It is
the opposite of the petroleum resource convention, where P10 is the optimistic
volume. The block states the convention explicitly; never flip the numbers to
match a habit.
5. Convergence gate. Drift of the median between the first and second half
of the run is reported as a percentage of the P10-P90 spread, not of the
median's own magnitude — an NPV distribution straddling zero would otherwise
report enormous drift for a perfectly converged run. Above 5 % of spread, the
percentiles are not quotable.
6. Tornado ranks; Sobol' explains. A one-at-a-time tornado moves one input
with the rest at base, so it measures only the main effect along a single line.
Variance-based Sobol' indices split the output variance into first-order S1
and total-order ST; a parameter with ST >> S1 matters only through
interaction and a tornado will rank it as irrelevant. The bundled Ishigami
example demonstrates exactly that failure.
7. Polynomial chaos when evaluations are the constraint. A PCE surrogate
fitted on a designed sample reproduces the mean, variance and Sobol' indices
from the coefficients. In the bundled example it reaches the analytical Ishigami
mean of 3.5 in 168 evaluations, against 5120 for the Saltelli design — the
argument for using it when each evaluation is a flowsheet solve.
Python Usage Pattern
Monte Carlo with a technical/economic split:
from uncertainty_quantification import Triangular, UncertaintyReport, UncertaintyStudy
parameters = [
Triangular(name="GIP", unit="GSm3", low=105.0, base_value=135.0, high=169.0),
Triangular(name="Gas price", unit="NOK/Sm3", low=0.8, base_value=1.5,
high=2.5, kind="economic"),
]
def technical(values): # the expensive NeqSim stage
process.getAutomation().setVariableValue("Feed.flowRate", values["GIP"], "kg/hr")
process.run()
return {"production": read_production(process)}
def economic(intermediate, values):
return npv(intermediate["production"], values["Gas price"])
study = UncertaintyStudy(
parameters=parameters, output_name="NPV after tax", output_unit="MNOK",
sampling_method="lhs", seed=42, technical=technical, economic=economic,
simulation_engine="NeqSim (SRK EOS, ProcessModel)",
)
result = study.run(300, skip_failures=True)
report = UncertaintyReport(
parameters=parameters, result=result, output_name="NPV after tax",
output_unit="MNOK", tornado=study.tornado(),
simulation_engine=study.simulation_engine,
)
assert report.blockers() == [], report.blockers()
results["uncertainty"] = report.to_results_json()
Global sensitivity when a tornado is not enough:
from uncertainty_quantification.backends import (
salib_available, saltelli_samples, sobol_indices,
)
if salib_available():
design = saltelli_samples(parameters, 256, seed=42) # 256 * (n_vars + 2) runs
outputs = [study.evaluate(point) for point in design]
report.sensitivity = sobol_indices(parameters, outputs)
Surrogate route when each evaluation is a flowsheet solve:
from uncertainty_quantification.backends import fit_polynomial_chaos, sample_surrogate
fit = fit_polynomial_chaos(parameters, study.evaluate, order=3, seed=42)
sample = sample_surrogate(fit, 100000) # percentiles from a cheap sample
Validation Checklist
Common Mistakes
- Flipping the percentile convention. Quoting a petroleum P10 (optimistic)
in a block the gate reads as the 10th percentile inverts the whole story.
- Running Monte Carlo on a simplified Python correlation while a NeqSim
class exists for the calculation. The task rules require the real model;
the staged split and the surrogate backend exist so it stays affordable.
- Treating the tornado as a sensitivity analysis. It is a main-effect
ranking along one line through base. Interactions are invisible to it.
- Too few samples. A 50-sample P90 is noise; the convergence check exists to
make that visible before it reaches a report.
- Expecting the cache to help a continuous technical parameter. It cannot —
every sample is a new state. Tag a parameter
economic only when it truly
does not enter the expensive stage.
- Silently dropping non-converged runs. Use
skip_failures=True so they are
counted and reported.
- Sampling correlated inputs independently and presenting the resulting
spread as the real uncertainty.
Limitations
- Marginals are sampled independently; no copula or correlation matrix.
- Only continuous marginals are provided (plus a deterministic placeholder);
discrete and categorical uncertainty is not modelled.
- The tornado is one-at-a-time and cannot resolve interaction; use the SALib
backend for that.
- Halton degrades above roughly ten dimensions because of correlation between
the higher prime bases.
- The split-half drift is a screening convergence indicator, not a formal
Monte Carlo error bound; the standard error of the mean is reported alongside.
- Polynomial chaos assumes a smooth response; a discontinuity (a phase change, a
constraint becoming active) breaks the surrogate, and the fit will not warn.
Related NeqSim Functionality
neqsim.process.automation.ProcessAutomation#evaluateBatchJson scores a list
of setpoint candidates, on a ProcessSystem.copy() per thread when
maxParallel > 1 — the natural way to evaluate a Monte Carlo or Saltelli
design without disturbing the live model.
neqsim.process.automation.ProcessAutomation#evaluate is the single-sample
form: it applies setpoints, runs to convergence and returns a feasible flag,
so a non-converged sample can be counted with skip_failures=True.
neqsim.process.util.optimizer.MonteCarloSimulator and
neqsim.process.fielddevelopment.evaluation.MonteCarloRunner are NeqSim's own
flowsheet- and field-level Monte Carlo drivers;
neqsim.statistics.montecarlosimulation.MonteCarloSimulation covers
parameter-fitting uncertainty. Use them when the study stays inside Java; use
this skill when the loop is in Python, when the sampler or the convergence gate
matters, or when SALib/chaospy are needed.
neqsim.util.agentic.TaskResultValidator validates the emitted uncertainty
block in Java; devtools/validate_task_results.py is the equivalent CI gate,
and both enforce p10 <= p50 <= p90.
Related Skills
neqsim-benchmark-reference-data — validate the model before propagating
uncertainty through it. An unbenchmarked model produces a precise distribution
around an unverified answer.
neqsim-optimization-and-doe — the search counterpart. Optimise the design,
then propagate uncertainty through the chosen design with this skill.
neqsim-asset-value-npv-screening, neqsim-capex-opex-screening,
neqsim-economy-basis-screening — the usual economic models placed in the
economic stage.
neqsim-reservoir-depletion-screening — the usual technical stage for a
field-development study.
neqsim-reliability-data-screening — availability feeding a production
profile as an uncertain input.
References
- Saltelli, A., Ratto, M., Andres, T., Campolongo, F., Cariboni, J., Gatelli, D.,
Saisana, M., & Tarantola, S. (2008). Global Sensitivity Analysis: The Primer.
Wiley.
- Sobol', I. M. (2001). Global sensitivity indices for nonlinear mathematical
models and their Monte Carlo estimates. Mathematics and Computers in
Simulation, 55(1-3), 271-280.
- Morris, M. D. (1991). Factorial sampling plans for preliminary computational
experiments. Technometrics, 33(2), 161-174.
- McKay, M. D., Beckman, R. J., & Conover, W. J. (1979). A comparison of three
methods for selecting values of input variables in the analysis of output from
a computer code. Technometrics, 21(2), 239-245.
- Halton, J. H. (1960). On the efficiency of certain quasi-random sequences of
points in evaluating multi-dimensional integrals. Numerische Mathematik,
2(1), 84-90.
- Xiu, D., & Karniadakis, G. E. (2002). The Wiener-Askey polynomial chaos for
stochastic differential equations. SIAM Journal on Scientific Computing,
24(2), 619-644.
- Herman, J., & Usher, W. (2017). SALib: an open-source Python library for
sensitivity analysis. Journal of Open Source Software, 2(9), 97.
- Feinberg, J., & Langtangen, H. P. (2015). Chaospy: an open source tool for
designing methods of uncertainty quantification. Journal of Computational
Science, 11, 46-57.
- Ishigami, T., & Homma, T. (1990). An importance quantification technique in
uncertainty analysis for computer models. Proceedings of ISUMA '90, 398-403.
- ISO 31000:2018, Risk management - Guidelines — the risk register that an
uncertainty distribution supports but does not replace.
- SPE-PRMS (2018), Petroleum Resources Management System — the resource
convention in which P10 is the high estimate.
1---2name: neqsim-uncertainty-quantification-23calculation_basis: "advisory"4version: "0.1.0"5description: "Monte Carlo uncertainty, tornado and global sensitivity for NeqSim tasks: P10/P90 marginals, LHS/Halton sampling, a cached technical/economic split, ascending p10<=p50<=p90 percentiles, convergence check, optional SALib Sobol/Morris and chaospy surrogate, and the uncertainty block the report and CI gate consume. USE WHEN: reporting P10/P50/P90, a tornado or a probability of a negative outcome, wrapping an expensive simulation, ranking parameters, or auditing an uncertainty block."6last_verified: "2026-08-08"7requires:8 python_packages: []9 java_packages: []10 env: []11 network: []12metadata:13 source: https://skillmd.com/skills/equinor/neqsim-uncertainty-quantification-214---1516# Uncertainty Quantification1718A Standard or Comprehensive NeqSim task must report P10/P50/P90 and a tornado19diagram. In practice that gets written from scratch in every notebook, and the20same four defects recur: sampling that clusters because it is plain21pseudo-random at n = 200, a Monte Carlo loop that re-solves the flowsheet for a22gas price that never touches it, no check that the run converged, and a tornado23presented as if it were a sensitivity analysis when it cannot see interaction.2425This skill supplies the sampling, the statistics, the caching, the convergence26gate and the report block. It does not own the model — the task supplies that.2728## When to Use2930- A task must produce `uncertainty` for `results.json`: P10/P50/P90, mean,31 standard deviation, probability of a negative outcome, tornado.32- A Monte Carlo loop wraps an expensive NeqSim flowsheet and the evaluation33 budget is the binding constraint.34- Parameters must be screened before a sensitivity budget is committed.35- An interaction between uncertain inputs is suspected and a tornado is not36 enough.37- An existing uncertainty block must be audited: enough samples, converged,38 correct percentile convention?3940## When *Not* to Use4142- As an optimiser. Searching for the best setpoints is43 `neqsim-optimization-and-doe`; this skill propagates uncertainty through a44 fixed design.45- To invent input ranges. A distribution with no basis produces a precise46 answer to an arbitrary question — record where each range came from.47- For correlated inputs. Every marginal is sampled independently; correlation48 between, say, price and cost inflation is not represented.49- As a substitute for a risk register. A probability distribution on an output50 is not a hazard assessment.5152## Inputs5354| Input | Meaning |55| --- | --- |56| `parameters` | list of `Distribution` objects, each with `name`, `unit`, `kind` |57| `kind` | `"technical"` (drives the expensive stage) or `"economic"` (cheap stage only) |58| `model` | `f(values) -> float`, for a single-stage study |59| `technical` / `economic` | the two-stage split: `g(technical) -> intermediate`, `h(intermediate, economic) -> float` |60| `sampling_method` | `"lhs"` (default), `"random"`, or `"halton"` |61| `seed` | integer for reproducibility |62| `n` | sample count; at least 200 for a simulation-backed run |6364## Outputs6566| Output | Meaning |67| --- | --- |68| `StudyResult.summary` | count, mean, std, min, max, p10/p50/p90, standard error, drift, P(negative) |69| `StudyResult.cache_report` | technical/economic evaluations and cache hits |70| `UncertaintyStudy.tornado()` | swing-ranked `TornadoEntry` list |71| `UncertaintyReport.to_results_json()` | the `uncertainty` block |72| `UncertaintyReport.blockers()` | why the block may not be presented as converged |73| `backends.sobol_indices(...)` | first-order `S1` and total-order `ST` with confidence intervals |74| `backends.fit_polynomial_chaos(...)` | surrogate, mean, std, `S1`, evaluation count |7576## Engineering Method7778**1. Marginals separated from the sampler.** Every distribution exposes an79inverse CDF, and the sampler only produces points in the unit hypercube. One set80of parameter definitions therefore drives a pseudo-random run, a Latin-hypercube81run, a Halton run, and an optional SALib design without redefinition — and a82triangular input is never silently replaced by a uniform one because a sampler83wanted bounds.8485**2. Latin hypercube by default.** At the sample counts a NeqSim-backed study86can afford (a few hundred), plain pseudo-random sampling leaves visible gaps in87the marginals. Latin hypercube places exactly one point per stratum in every88dimension, so the estimate of a percentile is far less sensitive to the seed.8990**3. Technical / economic split.** The expensive stage is cached on its inputs:9192$$93y = h\big(g(\mathbf{x}_\text{tech}),\; \mathbf{x}_\text{econ}\big)94$$9596Where this genuinely pays is the **tornado**: every economic row sits at base97technical values, so four economic parameters cost one flowsheet solve instead98of eight. In the Monte Carlo itself a *continuous* technical parameter takes a99new value on every sample, so there is nothing to reuse — `cache_hits` will be100zero and the report says so rather than implying a saving that did not happen.101102**4. Percentile convention.** `p10` is the 10th percentile, the *low* estimate,103so `p10 <= p50 <= p90` always holds — this is what the task gate enforces. It is104the opposite of the petroleum resource convention, where P10 is the optimistic105volume. The block states the convention explicitly; never flip the numbers to106match a habit.107108**5. Convergence gate.** Drift of the median between the first and second half109of the run is reported as a percentage of the **P10-P90 spread**, not of the110median's own magnitude — an NPV distribution straddling zero would otherwise111report enormous drift for a perfectly converged run. Above 5 % of spread, the112percentiles are not quotable.113114**6. Tornado ranks; Sobol' explains.** A one-at-a-time tornado moves one input115with the rest at base, so it measures only the main effect along a single line.116Variance-based Sobol' indices split the output variance into first-order `S1`117and total-order `ST`; a parameter with `ST >> S1` matters *only through118interaction* and a tornado will rank it as irrelevant. The bundled Ishigami119example demonstrates exactly that failure.120121**7. Polynomial chaos when evaluations are the constraint.** A PCE surrogate122fitted on a designed sample reproduces the mean, variance and Sobol' indices123from the coefficients. In the bundled example it reaches the analytical Ishigami124mean of 3.5 in 168 evaluations, against 5120 for the Saltelli design — the125argument for using it when each evaluation is a flowsheet solve.126127## Python Usage Pattern128129Monte Carlo with a technical/economic split:130131```python132from uncertainty_quantification import Triangular, UncertaintyReport, UncertaintyStudy133134parameters = [135 Triangular(name="GIP", unit="GSm3", low=105.0, base_value=135.0, high=169.0),136 Triangular(name="Gas price", unit="NOK/Sm3", low=0.8, base_value=1.5,137 high=2.5, kind="economic"),138]139140def technical(values): # the expensive NeqSim stage141 process.getAutomation().setVariableValue("Feed.flowRate", values["GIP"], "kg/hr")142 process.run()143 return {"production": read_production(process)}144145def economic(intermediate, values):146 return npv(intermediate["production"], values["Gas price"])147148study = UncertaintyStudy(149 parameters=parameters, output_name="NPV after tax", output_unit="MNOK",150 sampling_method="lhs", seed=42, technical=technical, economic=economic,151 simulation_engine="NeqSim (SRK EOS, ProcessModel)",152)153result = study.run(300, skip_failures=True)154155report = UncertaintyReport(156 parameters=parameters, result=result, output_name="NPV after tax",157 output_unit="MNOK", tornado=study.tornado(),158 simulation_engine=study.simulation_engine,159)160assert report.blockers() == [], report.blockers()161results["uncertainty"] = report.to_results_json()162```163164Global sensitivity when a tornado is not enough:165166```python167from uncertainty_quantification.backends import (168 salib_available, saltelli_samples, sobol_indices,169)170171if salib_available():172 design = saltelli_samples(parameters, 256, seed=42) # 256 * (n_vars + 2) runs173 outputs = [study.evaluate(point) for point in design]174 report.sensitivity = sobol_indices(parameters, outputs)175```176177Surrogate route when each evaluation is a flowsheet solve:178179```python180from uncertainty_quantification.backends import fit_polynomial_chaos, sample_surrogate181182fit = fit_polynomial_chaos(parameters, study.evaluate, order=3, seed=42)183sample = sample_surrogate(fit, 100000) # percentiles from a cheap sample184```185186## Validation Checklist187188- [ ] At least 200 samples for a simulation-backed run (1000 for a correlation189 or a surrogate).190- [ ] `report.blockers()` is empty, or every entry is explained in the report.191- [ ] Median drift is below 5 % of the P10-P90 spread.192- [ ] `p10 <= p50 <= p90`, and the report states the convention.193- [ ] Every input range has a stated basis, recorded next to the parameter.194- [ ] `seed` and `sampling_method` are reported so the run is reproducible.195- [ ] Failed evaluations are counted and disclosed, not silently dropped.196- [ ] The tornado is labelled as a main-effect ranking, not a full sensitivity197 analysis, unless Sobol' indices were computed.198- [ ] The emitted block passes `python devtools/validate_task_results.py <task>`.199- [ ] A tornado figure and an output histogram or CDF accompany the table.200201## Common Mistakes202203- **Flipping the percentile convention.** Quoting a petroleum P10 (optimistic)204 in a block the gate reads as the 10th percentile inverts the whole story.205- **Running Monte Carlo on a simplified Python correlation** while a NeqSim206 class exists for the calculation. The task rules require the real model;207 the staged split and the surrogate backend exist so it stays affordable.208- **Treating the tornado as a sensitivity analysis.** It is a main-effect209 ranking along one line through base. Interactions are invisible to it.210- **Too few samples.** A 50-sample P90 is noise; the convergence check exists to211 make that visible before it reaches a report.212- **Expecting the cache to help a continuous technical parameter.** It cannot —213 every sample is a new state. Tag a parameter `economic` only when it truly214 does not enter the expensive stage.215- **Silently dropping non-converged runs.** Use `skip_failures=True` so they are216 counted and reported.217- **Sampling correlated inputs independently** and presenting the resulting218 spread as the real uncertainty.219220## Limitations221222- Marginals are sampled independently; no copula or correlation matrix.223- Only continuous marginals are provided (plus a deterministic placeholder);224 discrete and categorical uncertainty is not modelled.225- The tornado is one-at-a-time and cannot resolve interaction; use the SALib226 backend for that.227- Halton degrades above roughly ten dimensions because of correlation between228 the higher prime bases.229- The split-half drift is a screening convergence indicator, not a formal230 Monte Carlo error bound; the standard error of the mean is reported alongside.231- Polynomial chaos assumes a smooth response; a discontinuity (a phase change, a232 constraint becoming active) breaks the surrogate, and the fit will not warn.233234## Related NeqSim Functionality235236- `neqsim.process.automation.ProcessAutomation#evaluateBatchJson` scores a list237 of setpoint candidates, on a `ProcessSystem.copy()` per thread when238 `maxParallel > 1` — the natural way to evaluate a Monte Carlo or Saltelli239 design without disturbing the live model.240- `neqsim.process.automation.ProcessAutomation#evaluate` is the single-sample241 form: it applies setpoints, runs to convergence and returns a `feasible` flag,242 so a non-converged sample can be counted with `skip_failures=True`.243- `neqsim.process.util.optimizer.MonteCarloSimulator` and244 `neqsim.process.fielddevelopment.evaluation.MonteCarloRunner` are NeqSim's own245 flowsheet- and field-level Monte Carlo drivers;246 `neqsim.statistics.montecarlosimulation.MonteCarloSimulation` covers247 parameter-fitting uncertainty. Use them when the study stays inside Java; use248 this skill when the loop is in Python, when the sampler or the convergence gate249 matters, or when SALib/chaospy are needed.250- `neqsim.util.agentic.TaskResultValidator` validates the emitted `uncertainty`251 block in Java; `devtools/validate_task_results.py` is the equivalent CI gate,252 and both enforce `p10 <= p50 <= p90`.253254## Related Skills255256- `neqsim-benchmark-reference-data` — validate the model *before* propagating257 uncertainty through it. An unbenchmarked model produces a precise distribution258 around an unverified answer.259- `neqsim-optimization-and-doe` — the search counterpart. Optimise the design,260 then propagate uncertainty through the chosen design with this skill.261- `neqsim-asset-value-npv-screening`, `neqsim-capex-opex-screening`,262 `neqsim-economy-basis-screening` — the usual economic models placed in the263 `economic` stage.264- `neqsim-reservoir-depletion-screening` — the usual `technical` stage for a265 field-development study.266- `neqsim-reliability-data-screening` — availability feeding a production267 profile as an uncertain input.268269## References270271- Saltelli, A., Ratto, M., Andres, T., Campolongo, F., Cariboni, J., Gatelli, D.,272 Saisana, M., & Tarantola, S. (2008). *Global Sensitivity Analysis: The Primer*.273 Wiley.274- Sobol', I. M. (2001). Global sensitivity indices for nonlinear mathematical275 models and their Monte Carlo estimates. *Mathematics and Computers in276 Simulation*, 55(1-3), 271-280.277- Morris, M. D. (1991). Factorial sampling plans for preliminary computational278 experiments. *Technometrics*, 33(2), 161-174.279- McKay, M. D., Beckman, R. J., & Conover, W. J. (1979). A comparison of three280 methods for selecting values of input variables in the analysis of output from281 a computer code. *Technometrics*, 21(2), 239-245.282- Halton, J. H. (1960). On the efficiency of certain quasi-random sequences of283 points in evaluating multi-dimensional integrals. *Numerische Mathematik*,284 2(1), 84-90.285- Xiu, D., & Karniadakis, G. E. (2002). The Wiener-Askey polynomial chaos for286 stochastic differential equations. *SIAM Journal on Scientific Computing*,287 24(2), 619-644.288- Herman, J., & Usher, W. (2017). SALib: an open-source Python library for289 sensitivity analysis. *Journal of Open Source Software*, 2(9), 97.290- Feinberg, J., & Langtangen, H. P. (2015). Chaospy: an open source tool for291 designing methods of uncertainty quantification. *Journal of Computational292 Science*, 11, 46-57.293- Ishigami, T., & Homma, T. (1990). An importance quantification technique in294 uncertainty analysis for computer models. *Proceedings of ISUMA '90*, 398-403.295- ISO 31000:2018, *Risk management - Guidelines* — the risk register that an296 uncertainty distribution supports but does not replace.297- SPE-PRMS (2018), *Petroleum Resources Management System* — the resource298 convention in which P10 is the high estimate.