EasyVVUQ: Open-Source VVUQ Engine

• EasyVVUQ is an open-source Python library for VVUQ that manages sampling, campaign execution, and analysis through a campaign-centered design.
• It integrates seamlessly with diverse execution backends, enabling non-intrusive workflows from laptops to exascale systems for complex simulations.
• The library employs advanced techniques like Monte Carlo, polynomial chaos expansion, and sensitivity analysis to ensure reliable and scalable uncertainty quantification.

Searching arXiv for recent and foundational EasyVVUQ papers to ground the article. EasyVVUQ is an open-source Python library designed to support Verification, Validation, and Uncertainty Quantification (VVUQ) for computational models. Within VECMAtk it is the dedicated VVUQ engine, providing non-intrusive sampling, campaign management, collation, analysis, and some validation patterns for simulations run on anything from a laptop to multi-petascale computers; in later work it also serves as the base engine for the serverless extension CloudVVUQ and as the central orchestration layer in an exascale uncertainty quantification workflow for cardiovascular flow simulation (Groen et al., 2020, Kica et al., 2023, Xue et al., 21 Aug 2025).

1. Position within the VVUQ software ecosystem

EasyVVUQ is presented as a core component rather than a peripheral add-on. In VECMAtk, it is one of the four “main components” and is the component that implements generic Uncertainty Quantification Patterns and some Verification & Validation Patterns, offers reusable VVUQ functionality across domains, and remains middleware-agnostic: it does not itself run jobs, but generates and manages ensembles that are then executed via FabSim3, QCG-PilotJob, Dask, or other tools (Groen et al., 2020).

Component	Role	Responsibility
EasyVVUQ	VVUQ engine	Sampling, campaign management, collation, analysis, validation patterns
FabSim3	Workflow orchestration	Ensemble automation and HPC job management
QCG tools	Scheduling and monitoring	Scalable job scheduling and monitoring on HPC systems
MUSCLE 3	Multiscale coupling	Macro–micro and spatially separated submodels
CloudVVUQ	Serverless extension	Serverless execution layer using EasyVVUQ internally

In a distinct but compatible formulation, EasyVVUQ is described as a high-level library that lets practitioners define input parameters and their uncertainty, generate samples using multiple strategies, manage and execute large campaigns of simulations, collect outputs into a structured database, and perform statistical analysis and sensitivity analysis on the outputs (Kica et al., 2023). The central abstraction is the Campaign object, which encapsulates parameter definitions and their distributions, the sampling method, the mapping from samples to runs of the user’s simulation code, storage of results, and analysis. This campaign-centered design is the main organizing principle of EasyVVUQ across both HPC-oriented and cloud-oriented workflows (Kica et al., 2023).

A recurrent architectural theme is separation of concerns. EasyVVUQ handles the VVUQ logic and campaign structuring; FabSim3, QCG-PilotJob, or a serverless executor handle execution; domain solvers and post-processing tools handle physics and specialized analysis. In the exascale aortic stenosis study, for example, EasyVVUQ generates the sampling plans and structures the campaign, FabSim3 handles execution and job submission to Frontier, and HemeLB acts as the black-box solver producing pressure and wall shear stress fields (Xue et al., 21 Aug 2025).

2. Campaign abstractions and non-intrusive workflow

EasyVVUQ structures a standard non-intrusive VVUQ workflow into five stages: application description, sampling, execution, collation, and analysis (Groen et al., 2020). Application description consists of an Encoder, which converts a parameter set into simulation input files; a Decoder, which parses simulation outputs and extracts quantities of interest (QoIs); and an execution action, which describes how to run a single simulation. Sampling generates the ensemble of parameter sets. Execution is deliberately external. Collation collects outputs from all runs, stores them in an SQL backend, and tracks status. Analysis performs statistical analysis, uncertainty propagation, and sensitivity analysis (Groen et al., 2020).

The same structure appears in the aortic stenosis workflow, where the overall framework has three stages: parameter sampling and campaign management with EasyVVUQ and FabSim3, high-fidelity ensemble simulation with HemeLB on Frontier, and spatial statistical modeling and visualization of QoIs. In generic EasyVVUQ terms, this maps to a Campaign object tying together a Sampler, an Encoder, a Decoder, and a Collater (Xue et al., 21 Aug 2025). In that study, EasyVVUQ defines the uncertain parameters and their distributions, builds sampling plans using polynomial chaos expansion quadrature nodes, generates input files for HemeLB for each sample, and provides the structure for a campaign of runs and their outputs. Once runs complete, the outputs are post-processed into spatial ensembles for downstream probabilistic isosurface analysis (Xue et al., 21 Aug 2025).

A typical user workflow therefore proceeds by defining model parameters and their ranges or distributions, choosing a sampling strategy, generating a set of input samples, running the model for each sample, storing simulation results in a campaign database, applying EasyVVUQ analysis methods, and inspecting plots and indices to understand parameter influence and uncertainty propagation (Kica et al., 2023). In practical terms, this non-intrusive model is well suited to complex CFD, agent-based, epidemiological, and multiscale codes because EasyVVUQ interacts via files, templates, and structured outputs rather than requiring modifications to solver internals (Xue et al., 21 Aug 2025).

The campaign database and collation model are important for restartability and scale. EasyVVUQ uses an SQL backend to store sample definitions and results, is stated to handle “10000s of samples or more,” and tracks successful, failed, and pending runs. Stage-wise sampling allows additional samples to be appended to an existing campaign if variance estimates are not yet robust, without discarding previous results (Groen et al., 2020).

3. Statistical, sensitivity, and surrogate methods

EasyVVUQ operates on the general computational-model abstraction

$$\mathbf{y} = f(\mathbf{x}), \quad \mathbf{x} \in \mathbb{R}^n,$$

where the input parameters are treated as random variables and the model outputs become random variables induced by the uncertainty in those inputs (Kica et al., 2023). Uncertainty quantification in this setting aims to estimate properties of the output such as the mean, variance, and empirical probability distribution through repeated runs of the underlying simulator (Kica et al., 2023).

The library supports multiple sampling and analysis strategies. The material explicitly identifies Monte Carlo, stochastic collocation, polynomial chaos expansion (PCE), variance-driven sensitivity analysis, sparse grids including dimension-adaptive schemes, and basic statistical methods including bootstrapping (Groen et al., 2020, Kica et al., 2023). For local sensitivity analysis, the relevant quantity is a derivative-based local sensitivity index,

$$S_j = \frac{\partial Y}{\partial X_j}\Bigg|_{\mathbf{x}_0},$$

which captures the effect of a small perturbation around a reference point (Kica et al., 2023). For global sensitivity analysis, EasyVVUQ computes variance-based indices such as the first-order Sobol index,

$S_j = \frac{V_j}{\mathrm{Var}(Y)},$

and, in the time-dependent setting used for COVID-19 modelling,

$$S_i(t) = \frac{\mathrm{Var}\big(\mathbb{E}[Y(t)\mid X_i]\big)}{\mathrm{Var}(Y(t))}.$$

These quantify the fraction of output variance attributable to a single uncertain input (Kica et al., 2023, Groen et al., 2020).

PCE is especially prominent in the exascale cardiovascular case. There, EasyVVUQ uses a non-intrusive PCE sampler with uniform input distributions, which are mapped to appropriate orthogonal polynomials and Gauss–Legendre quadrature for uniform priors. The polynomial order is total order $p_o = 2$, and the total number of quadrature nodes is given as

$N_q = (p_o + 1)^d,$

where $d$ is the number of uncertain parameters (Xue et al., 21 Aug 2025). The expansion is written as

$$Q(\boldsymbol{\theta}) \approx \sum_k \alpha_k\, \Psi_k(\boldsymbol{\theta}),$$

with coefficients approximated from model evaluations at quadrature nodes. This formulation is used to keep the number of samples manageable when each ensemble member is an expensive large-eddy simulation on GPU-accelerated exascale hardware (Xue et al., 21 Aug 2025).

EasyVVUQ also supports validation patterns. In the fusion application, the ValidationSimilarity VVP compares the probability distributions of QoIs from simulations and experiments using Hellinger distance, Jensen–Shannon distance, and Wasserstein distance (Groen et al., 2020). This is significant because it places validation alongside UQ and sensitivity analysis within the same campaign-based formalism, rather than treating validation as a separate workflow.

4. Execution models, scalability, and orchestration

EasyVVUQ is middleware-agnostic by design. It does not itself manage job scheduling, queuing systems, or resource policies; execution is delegated to complementary workflow management tools and schedulers (Groen et al., 2020, Xue et al., 21 Aug 2025). In HPC settings, the principal integrations described are FabSim3 for automation and workflow orchestration, and QCG-PilotJob with EQI for scalable pilot-job execution (Groen et al., 2020). In the aortic stenosis study, the relationship is stated explicitly: “While EasyVVUQ generates the sampling plans, the execution and job submission to leadership-class computing facilities are handled through complementary workflow management tools such as FabSim3” (Xue et al., 21 Aug 2025).

This architecture scales to large campaigns. The examples in VECMAtk demonstrate EasyVVUQ in settings with 15,121 collocation samples for COVID-19 modelling, up to 16,384 jobs in forced migration studies, and large urban air pollution and fusion ensembles (Groen et al., 2020). In the cardiovascular exascale study, all ensemble runs are executed on Frontier. The inlet velocity ensemble consists of 17 HemeLB simulations; each run uses 20 GPU-accelerated nodes, each node with $4 \times$ AMD MI250X GPUs, at 100 $\mu$m resolution and runtime of approximately one hour per realization. A second ensemble of 6 simulations varies the Smagorinsky constant (Xue et al., 21 Aug 2025). Because the runs are parallel and independent, the workload is embarrassingly parallel and therefore well aligned with exascale execution (Xue et al., 21 Aug 2025).

The serverless extension CloudVVUQ generalizes the execution layer to cloud function platforms while keeping EasyVVUQ as the sampling and analysis engine. CloudVVUQ supports AWS Lambda, Google Cloud Functions (1st gen), and Google Cloud Run (Kica et al., 2023). The core mechanism is to generate samples locally, send each sample as a JSON payload via HTTP to a serverless function or container that wraps the computational model, collect the responses, insert the collected results back into an EasyVVUQ Campaign, and then apply EasyVVUQ’s analysis methods (Kica et al., 2023). The new API centers on an Executor class such as EasyExecutor, intended to allow users to avoid changing their existing EasyVVUQ code in any significant way (Kica et al., 2023).

CloudVVUQ’s client side uses asynchronous processing with Asyncio and Aiohttp, a counting semaphore for concurrency control, retries for non-200 responses or errors, and result aggregation into a campaign database (Kica et al., 2023). This execution model is also a separation-of-concerns design: EasyVVUQ continues to define parameters, sampling, campaign generation, and analysis; the executor layer manages transport, concurrency, and result collection.

5. Representative applications and domain-specific use

The domain spread of EasyVVUQ is broad. Applications explicitly identified include fusion plasmas, forced human migration, climate modelling, advanced materials, urban air pollution, COVID-19 modelling, biomedicine, lower limb haemodynamics, cardiac electrophysiology, and exascale cardiovascular flow simulation (Groen et al., 2020, Kica et al., 2023, Xue et al., 21 Aug 2025). Across these domains, the recurring pattern is that uncertain parameters are declared, a sampler generates an ensemble, an external execution layer runs the simulations, and EasyVVUQ collates and analyzes the outputs.

The COVID-19 / FACS example is the most detailed VECMAtk case study. The model is the Flu And Coronavirus Simulator, an agent-based model simulating the spread of SARS-CoV-2 at local scales. Six input parameters are treated as uncertain with uniform ranges: infection rate, mortality period, recovery period, mild recovery period, incubation period, and period to hospitalisation. EasyVVUQ uses Chaospy within a stochastic collocation method with a sparse-grid sampling plan that generates 15,121 samples. FabSim3 submits and runs these simulations on an HPC resource, after which EasyVVUQ decoders parse the time series of deaths and first-order Sobol sensitivity indices are computed as a function of time (Groen et al., 2020). The reported result is that in the first approximately 20 days all parameters except the non-mild recovery period significantly affect deaths, while later the infection rate and mild recovery period dominate sensitivity (Groen et al., 2020).

The exascale aortic stenosis study illustrates EasyVVUQ’s role in anatomically resolved uncertainty quantification. Two uncertain parameters are considered separately: inlet peak velocity $$S_j = \frac{\partial Y}{\partial X_j}\Bigg|_{\mathbf{x}_0},$$0, with

$$S_j = \frac{\partial Y}{\partial X_j}\Bigg|_{\mathbf{x}_0},$$1

and the Smagorinsky constant $$S_j = \frac{\partial Y}{\partial X_j}\Bigg|_{\mathbf{x}_0},$$2, the LES subgrid-scale turbulence parameter controlling the modeled eddy viscosity (Xue et al., 21 Aug 2025). The QoIs are the volumetric pressure field $$S_j = \frac{\partial Y}{\partial X_j}\Bigg|_{\mathbf{x}_0},$$3 and the surface wall shear stress $$S_j = \frac{\partial Y}{\partial X_j}\Bigg|_{\mathbf{x}_0},$$4, with

$$S_j = \frac{\partial Y}{\partial X_j}\Bigg|_{\mathbf{x}_0},$$5

After ensemble generation by EasyVVUQ and execution on Frontier, the per-vertex distribution of each QoI is modeled as Gaussian,

$$S_j = \frac{\partial Y}{\partial X_j}\Bigg|_{\mathbf{x}_0},$$6

and probabilistic isosurface analysis is used to compute Shannon entropy and isosurface-crossing probability on the geometry (Xue et al., 21 Aug 2025).

For the topology distribution $$S_j = \frac{\partial Y}{\partial X_j}\Bigg|_{\mathbf{x}_0},$$7 of marching-cubes cases in a cell $$S_j = \frac{\partial Y}{\partial X_j}\Bigg|_{\mathbf{x}_0},$$8, the entropy is

$$S_j = \frac{\partial Y}{\partial X_j}\Bigg|_{\mathbf{x}_0},$$9

and the isosurface-crossing probability is

$S_j = \frac{V_j}{\mathrm{Var}(Y)},$0

These metrics are volume-rendered and mapped onto the aortic anatomy (Xue et al., 21 Aug 2025). The main domain findings are that inlet velocity variation produces high uncertainty downstream of the stenosis where turbulence develops while upstream regions remain stable, and that Smagorinsky constant variation has little effect on the large-scale pressure field but increases wall shear stress uncertainty in localized high-shear regions. In both cases, the stenotic throat manifests low entropy, indicative of robust identification of elevated wall shear stress (Xue et al., 21 Aug 2025). This is a salient example of EasyVVUQ supplying the ensemble while domain-specific post-processing supplies specialized spatial uncertainty metrics.

Serverless applications further show the portability of EasyVVUQ’s campaign model. In the lower limb haemodynamics example, 42 input parameters and 50 outputs are analyzed over 54,272 samples using Google Cloud Functions, with CloudVVUQ completing the workflow in about 48 seconds and reporting a speedup of approximately 195$S_j = \frac{V_j}{\mathrm{Var}(Y)},$1 versus sequential execution (Kica et al., 2023). In the Ten Tusscher ventricular cell model, 1000 samples on Cloud Run yield a speedup of approximately 366$S_j = \frac{V_j}{\mathrm{Var}(Y)},$2, while a larger experiment with 1728 samples reaches 723$S_j = \frac{V_j}{\mathrm{Var}(Y)},$3 and up to 1536 active containers (Kica et al., 2023). These studies do not alter EasyVVUQ’s role as the base engine for sampling, campaigns, and analysis; they change only the execution substrate.

6. Limits, common misconceptions, and development trajectory

A common misconception is that EasyVVUQ is itself an execution engine. The materials repeatedly distinguish VVUQ logic from job execution. EasyVVUQ does not manage SLURM, resource allocation, queue policies, or leadership-class scheduler interaction; it should be paired with FabSim3, QCG-PilotJob, Dask, CloudVVUQ, or another backend, depending on the environment (Groen et al., 2020, Kica et al., 2023, Xue et al., 21 Aug 2025). A related misconception is that EasyVVUQ implements all downstream domain analytics. In the cardiovascular visualization framework, EasyVVUQ ensures that there is a coherent ensemble for each QoI by managing sampling and runs, but entropy and crossing probability are explicitly specialized visualization algorithms built on top of the ensemble data rather than EasyVVUQ functionality itself (Xue et al., 21 Aug 2025).

Another misconception is that serverless execution replaces HPC in general. The serverless study states instead that it is “a practical and efficient approach to selected cases of running VVUQ calculations” (Kica et al., 2023). Serverless plus EasyVVUQ is presented as most appropriate when single-run runtimes fit platform limits, the workload is embarrassingly parallel, and large numbers of independent runs are needed. Traditional HPC remains preferable when single runs are very heavy, require many cores or nodes, or need features such as tight node-level resource control and high-performance interconnects (Kica et al., 2023).

Methodological limits also appear clearly in the exascale study. Even with PCE, each ensemble member is a full LES run, which constrains the number of parameters and polynomial order. The relation

$S_j = \frac{V_j}{\mathrm{Var}(Y)},$4

highlights the curse of dimensionality: the paper uses one-dimensional uncertain parameters at a time, and suggests that high-dimensional settings would require careful selection of polynomial order, possibly sparse PCE or adaptive sampling, and sensitivity analysis to reduce dimensionality before full campaigns (Xue et al., 21 Aug 2025). This suggests that EasyVVUQ is strongest when paired with disciplined experimental design rather than indiscriminate parameter expansion.

The development trajectory described in VECMAtk emphasizes steady extension rather than conceptual redesign. Reported improvements include support for vector-valued QoIs, improved sparse-grid stochastic collocation, dimension-adaptive collocation, support for Dask as an execution backend, and a strengthened test suite (Groen et al., 2020). A plausible implication is that EasyVVUQ’s long-term significance lies in its stable abstractions—campaigns, encoders, decoders, samplers, collation, and analysis—which have remained compatible with multiple execution paradigms, from desktop workflows to pilot jobs, serverless infrastructures, and exascale ensemble simulation.