PathSim/PathView: Multi-Fidelity Fusion Simulation

• PathSim/PathView is an open-source dynamic simulation platform that integrates block-based multi-fidelity models for fusion fuel-cycle analysis.
• It employs a Python-based simulation engine (PathSim) for coordinated time-stepping and a React-based web interface (PathView) for graphical model creation and visualization.
• Its hierarchical architecture allows coupling of 0D, 1D reduced-order, and high-fidelity FEM models, validated against benchmark studies and poised for future integration with neutronics and CFD tools.

PathSim/PathView is an open-source, multi-fidelity dynamic simulation platform for fusion tritium fuel cycles in which a Python-based simulation engine, PathSim, is coupled to a web-based graphical modelling and visualization layer, PathView. Its defining objective is to combine fast system-level fuel-cycle models, physics-based reduced-order component models, and high-fidelity finite-element transport simulations inside one unified dynamic simulation environment, so that each fuel-cycle component can be represented at an appropriate physical fidelity while still participating in a single transient plant model (Delaporte-Mathurin et al., 20 Mar 2026).

1. Platform identity and division of roles

The paired name denotes a deliberate division of labour. PathSim is the simulation engine and model coordinator. It is described as a Python-based open-source software package for dynamical system modelling and transient simulation, based on a modular block-diagram approach, and responsible for coordinating all components in the global time-stepping loop. PathView is the graphical modelling and visualization layer on top of PathSim. It is described as a web-based graphical interface built with JavaScript/React for visually building, modifying, and inspecting system topology, configuring solver selection and event definitions, editing Python objects, plotting results with Plotly, and exporting stand-alone Python scripts executable through the PathSim API (Delaporte-Mathurin et al., 20 Mar 2026).

Component	Role	Technologies
PathSim	Simulation engine and model coordinator	Python
PathView	Graphical modelling, configuration, plotting, and code generation layer	JavaScript/React, Plotly

This split addresses a practical modelling problem. Large block-diagram models can be built directly in Python, but the platform presentation emphasizes that doing so becomes cumbersome and error-prone. PathView therefore serves as the visual systems-engineering front end, whereas PathSim remains the computational backbone. A common misconception is to treat PathView as the platform itself; the documented architecture instead assigns execution, coupling, and time integration to PathSim, with PathView acting as the graphical authoring and inspection environment (Delaporte-Mathurin et al., 20 Mar 2026).

2. Block-based and hierarchical simulation architecture

The architecture is fundamentally block-based and hierarchical. Models are constructed from blocks representing components or functions, including standard built-in PathSim blocks, custom user-defined blocks, wrappers around external tools such as FESTIM, and grouped subsystems for hierarchical abstraction. The stated design principle is interchangeability: blocks can be replaced by high fidelity full physics models or cheap surrogate models depending on the demands of the simulation (Delaporte-Mathurin et al., 20 Mar 2026).

Within the fuel-cycle applications described for the platform, components exchange quantities such as tritium inventories, mass flow rates, extraction efficiencies, boundary concentrations, permeation fluxes, and pressure updates. At the lowest fidelity, coupling is expressed as flux passing from one lumped component to another. At higher fidelity, a block may solve coupled one-dimensional ordinary differential equations or a finite-element model internally before returning the effective outputs needed by the wider system graph. The execution model is a global time-stepping loop in which system-level states are advanced, event logic can alter component parameters or availability, and embedded external models are called during the same transient simulation (Delaporte-Mathurin et al., 20 Mar 2026).

The phrase “unified dynamic simulation environment” is therefore architectural rather than mathematical. It does not imply that all blocks share the same governing equations. It means that disparate model classes—static models, residence time models, physics based models, and full FEM model integrations with FESTIM—are embedded in the same block-diagram representation, coupled through common interfaces, and stepped together in one simulation workflow (Delaporte-Mathurin et al., 20 Mar 2026).

3. Fidelity hierarchy and governing models

The platform is organized around three complementary fidelity levels.

At the lowest fidelity is the zero-dimensional residence time method used for plant-wide fuel-cycle representation. For component $i$, the tritium inventory satisfies

$$\frac{dI_i}{dt}=\sum_j F_{\mathrm{in}, j}-(1+\epsilon_i)\left(\frac{I_i}{\tau_i}\right)-\lambda I_i + S_i .$$

Here $I_i$ is tritium inventory, $\sum_j F_{\mathrm{in},j}$ is total inflow, $\tau_i$ is residence time, $\epsilon_i$ is non-radioactive loss fraction, $\lambda$ is the tritium decay constant, and $S_i$ is a source term. This is a lumped, spatially homogeneous representation in which transport physics is collapsed into characteristic residence times and effective loss terms. In the ARC demonstration, the model is simplified further by setting

$\epsilon_i = 0, \qquad \lambda = 0 ,$

thereby neglecting non-radioactive losses and radioactive decay (Delaporte-Mathurin et al., 20 Mar 2026).

The intermediate-fidelity level is exemplified by a custom PathSim block for tritium extraction from liquid PbLi in a bubble column reactor. The physical scenario is a simple, single-stage, countercurrent, unpacked bubble column. Its key state variables are liquid-phase tritium concentration $c_T(z)$ and gas-phase tritium mole fraction $$\frac{dI_i}{dt}=\sum_j F_{\mathrm{in}, j}-(1+\epsilon_i)\left(\frac{I_i}{\tau_i}\right)-\lambda I_i + S_i .$$0. The governing balances are given as

$$\frac{dI_i}{dt}=\sum_j F_{\mathrm{in}, j}-(1+\epsilon_i)\left(\frac{I_i}{\tau_i}\right)-\lambda I_i + S_i .$$1

for the liquid phase, and

$$\frac{dI_i}{dt}=\sum_j F_{\mathrm{in}, j}-(1+\epsilon_i)\left(\frac{I_i}{\tau_i}\right)-\lambda I_i + S_i .$$2

for the gas phase. Interfacial equilibrium is imposed through Sieverts’ law,

$$\frac{dI_i}{dt}=\sum_j F_{\mathrm{in}, j}-(1+\epsilon_i)\left(\frac{I_i}{\tau_i}\right)-\lambda I_i + S_i .$$3

and the interfacial mass-transfer flux of tritium atoms is

$$\frac{dI_i}{dt}=\sum_j F_{\mathrm{in}, j}-(1+\epsilon_i)\left(\frac{I_i}{\tau_i}\right)-\lambda I_i + S_i .$$4

For validation against Mohan et al., the specific interfacial area is taken as

$$\frac{dI_i}{dt}=\sum_j F_{\mathrm{in}, j}-(1+\epsilon_i)\left(\frac{I_i}{\tau_i}\right)-\lambda I_i + S_i .$$5

The model supports Open-Closed and Closed-Closed boundary conditions, is nondimensionalized, rewritten as four first-order ODEs, and solved iteratively using a boundary value problem solver; the conclusion also characterizes the approach as coupled one-dimensional ordinary differential equations solved using finite difference methods (Delaporte-Mathurin et al., 20 Mar 2026).

The highest fidelity level is obtained by coupling to FESTIM, an open-source finite-element framework for hydrogen isotope transport in materials. In the PathSim/PathView workflow, FESTIM contributes multi-dimensional transport, multi-material domains, surface interactions, trapping, and more realistic treatment of interfaces and spatial effects. PathSim wraps FESTIM as an external block, so that a finite-element simulation receives system-level boundary conditions and returns fluxes or related outputs to the plant model (Delaporte-Mathurin et al., 20 Mar 2026).

4. Demonstrated workflows and validation studies

The baseline system-level demonstration reconstructs an ARC-class fuel cycle previously studied in Matlab/Simulink. The PathView graph reproduces the whole-fuel-cycle topology, and the reported transient behaviour is characteristic: storage begins with the startup inventory, all other components begin at zero, storage depletes until bred tritium returns from the outer fuel cycle, and the system reaches a pseudo-steady state. This use case establishes that the platform can represent a reactor-scale transient inventory network, rather than only isolated component models (Delaporte-Mathurin et al., 20 Mar 2026).

The bubble column reactor demonstration is the principal example of fidelity substitution inside an existing plant graph. The authors report that original Malara results could not be reproduced exactly because some required correlations were missing or inconsistent, and the implemented model was instead validated against Mohan et al. (2010) using Malara-type correlations for bubble size and volumetric mass transfer coefficient. The reported result is exact reproduction of Mohan’s results for both Closed-Closed and Open-Closed cases. The validated BCR block is then inserted into the ARC fuel cycle as the Tritium Extraction System, after which plant-level studies compare one $$\frac{dI_i}{dt}=\sum_j F_{\mathrm{in}, j}-(1+\epsilon_i)\left(\frac{I_i}{\tau_i}\right)-\lambda I_i + S_i .$$6 m column with three $$\frac{dI_i}{dt}=\sum_j F_{\mathrm{in}, j}-(1+\epsilon_i)\left(\frac{I_i}{\tau_i}\right)-\lambda I_i + S_i .$$7 m columns in series, and one BCR with two BCRs in parallel under a shutdown event. These studies use PathSim’s event handling to model component downtime while retaining system-wide tritium generation and breeding elsewhere in the graph (Delaporte-Mathurin et al., 20 Mar 2026).

The FESTIM demonstrations are smaller in scale but clarify the coupling mechanism. In the slab diffusion benchmark, a FESTIM block imposes $$\frac{dI_i}{dt}=\sum_j F_{\mathrm{in}, j}-(1+\epsilon_i)\left(\frac{I_i}{\tau_i}\right)-\lambda I_i + S_i .$$8 on one boundary and $$\frac{dI_i}{dt}=\sum_j F_{\mathrm{in}, j}-(1+\epsilon_i)\left(\frac{I_i}{\tau_i}\right)-\lambda I_i + S_i .$$9 on the other, then returns hydrogen fluxes. The analytical downstream flux is given as

$I_i$0

In the depleted source problem, coupling is explicitly bidirectional: at each time step, FESTIM computes the flux of particles escaping an enclosure wall, and PathSim updates the internal pressure using the ideal gas law, which in turn modifies the next boundary condition. This is the clearest compact example of source/sink coupling across fidelity levels (Delaporte-Mathurin et al., 20 Mar 2026).

5. Relation to adjacent platforms and similarly named systems

The fusion PathSim/PathView platform is distinct from several unrelated systems and concepts that use similar terminology. In heterogeneous information networks, PathSim denotes a classic meta-path-based similarity measure, and NeuPath is a neural approximation to that similarity for inductive search; this is a graph-mining use of the name, not a dynamic simulation environment (Xiao et al., 2021). In mobile robotics, PathBench is a unified path-planning platform organized around simulator, generator, trainer, and analyzer components, with support for classical and learned planners, benchmarking metrics, and ROS integration; it overlaps with simulator/viewer ideas but is benchmark-centric rather than fuel-cycle-centric (Toma et al., 2021). In digital pathology, PathVis is a mixed-reality whole-slide image viewing and AI-assistance system for Apple Vision Pro, not a simulator and not the same system by name as PathSim or PathView (Veerla et al., 5 May 2025).

A different cluster of related names appears in biological pathway informatics and visualization. Pathway Tools is a pathway/genome informatics and systems biology environment built around Pathway/Genome Databases and MetaFlux simulation (Karp et al., 2015). Shu is a visualization platform for high-dimensional biological pathways that reuses Escher-compatible metabolic maps and emphasizes distributions and multiple conditions (Muriel et al., 2023). The spectral graph theory pathway-layout workflow of automatic pathway map drawing is a layout-and-rendering pipeline for biological pathways rather than a pathway analysis or simulation platform (Xiao et al., 2022). These systems share the lexical element “path” but address biological pathways, not fusion fuel-cycle components and transient tritium inventories.

This disambiguation matters because “PathSim/PathView” in the fusion context refers specifically to a block-based, multi-fidelity simulation workflow in which PathSim coordinates execution and PathView provides graphical modelling and visualization (Delaporte-Mathurin et al., 20 Mar 2026).

6. Strengths, limitations, and development trajectory

The platform’s strongest stated contribution is multi-fidelity integration within one open-source workflow. It allows a 0D residence-time model, an intermediate-fidelity 1D reduced-order component model, and a high-fidelity finite-element transport model to coexist in the same dynamic plant simulation. Closely related strengths are modularity, hierarchical modelling through subsystems, explicit event handling for downtime and redundancy studies, and the practical usability benefit of PathView for building large block-diagram models visually rather than exclusively through Python code (Delaporte-Mathurin et al., 20 Mar 2026).

The limitations are equally clear. Residence-time models remain physically crude at low fidelity. The bubble column reactor block is based on an older Malara formulation selected as a demonstration, not necessarily the most advanced representation available. The validation literature itself contains omissions and inconsistencies, which is why Mohan et al. rather than Malara became the operative benchmark. The paper does not quantify the computational cost of high-fidelity coupling, but its rationale for selective multi-fidelity modelling implies that full FEM models are too expensive to deploy everywhere. The FESTIM examples are proof-of-coupling cases rather than full integrated blanket or plasma-facing reactor simulations inside the ARC cycle (Delaporte-Mathurin et al., 20 Mar 2026).

The published development trajectory is explicitly outward-looking. The platform is positioned as a foundation for future integration with neutronics, fluid dynamics, and surrogate modelling tools; the specific future couplings named are OpenMC for neutronics, OpenFOAM for CFD, and surrogate models for accelerated component evaluation. Reproducibility is supported by the statement that all scripts, models, datasets, and postprocessing are available on GitHub at https://github.com/rossmacdonald98/PathView_Paper, alongside the open-source status of PathSim and FESTIM themselves (Delaporte-Mathurin et al., 20 Mar 2026).

Taken together, these features place PathSim/PathView in a specific niche within computational fusion engineering: not merely a GUI for block diagrams, and not merely a collection of isolated component solvers, but a workflow for preserving system-level connectivity and transient simulation while selectively upgrading individual subsystems from effective residence-time boxes to physics-informed ODE or finite-element models (Delaporte-Mathurin et al., 20 Mar 2026).