Exact answer known1D · pressurizedCandidate

Looped water network

Does the model split flow correctly around loops in a network?

Test A1P-010
Todini (1988)
Version 1.0.0

Right answer: Exact solution · Todini (1988)
Results: 3 models · closest under 0.01 % off · see them ↓
Must: keep every junction head within 5 cm

Sketch, not to scale.

The model file

The suite writes this EPANET 2 input file from the test's inputs. Each engine's own copy, as it ran, is in Run it yourself under its result below.

Download A1P-010.inp 1 KB Open it on the map →

On the map: click any element to see its line in the file and every engine's result there over time.

Junction heads
Node	Exact (m)	EPANET 2.2 (m)	Diff (mm)
2	203.247	203.247	+0.2
3	190.462	190.463	+0.5
4	198.449	198.449	+0.3
5	183.803	183.804	+0.7
6	195.445	195.445	+0.4
7	190.552	190.552	+0.5

Pipe flows
Pipe	Exact (m³/h)	EPANET 2.2 (m³/h)
1	1120.00	1120.00
2	336.88	336.88
3	683.12	683.12
4	32.56	32.56
5	530.56	530.56
6	200.56	200.56
7	236.88	236.88
8	0.56	0.56

What happens

A small two-loop network fed by gravity. Water can reach each junction by more than one route, so flows and pressures must be solved together.

Why it matters

Real distribution networks are full of loops. This is the core calculation every network model performs.

A good model must

keep every junction head within 5 cm
keep pipe flows within 0.1 %

How models did

In rank order: by each model's percent difference from the right answer, the largest over the test's accuracy checks (lower is better; results within 10 % of each other share a rank). Mass error, timing and NSE are shown beside it, not folded in. Each model runs the same inputs. Compare them in the results viewer →

Rank	Model	Difference	Largest difference in	Run time
1=	WNTR own hydraulic solver	<0.01 %	Junction heads	0.07 s
1=	EPANET 2.2 US EPA	<0.01 %	Junction heads	0.01 s
3	Hydra water distribution	0.028 %	Junction heads	0.01 s

WNTR

WNTR 1.5 (US EPA and Sandia), its own Python solver of the network equations (WNTRSimulator), independent of EPANET's code; Hazen-Williams friction only

#1= under 0.01 % off

Run time, finest grid: 0.07 s · AMD EPYC 9V74 80-Core Processor, 2 cores, 15.6 GB, Linux 6.17.0-1022-azure (GitHub Actions (github-hosted, ubuntu24))

Settings: wntr.sim.WNTRSimulator (WNTR's own Newton solver of the network equations, in Python)

Junction heads

• 0.34 mm off

<0.01 % of the 26 m head loss across the network

Pipe flows

• < 0.0001 % off

Scored with method 3.0 · Score card: WNTR 1.5.0 WNTRSimulator

Run it yourself

WNTR 1.5.0 WNTRSimulator · runs on Linux · produced by scripts/run_network_cases.py in track-a.yml.

git clone https://github.com/scott-jeffers/benchmark1d2d && cd benchmark1d2d
git checkout 71dc10fc07a9
python -m pip install -e ".[dev,engines]"
python scripts/run_network_cases.py --wntr

The model files the suite wrote for this run (.zip, 0.6 KB): the exact inputs the solver read (one folder per grid, where the test has several), with their SHA-256.

The script writes the EPANET input file from the test's inputs; the model files below are that file.

The test itself (inputs, exact answer, checks): A1P-010.zip. Check the score card with benchmark1d2d verify-card: its signature by the suite's public development key shows the card has not changed since it was written, not who wrote it.

EPANET 2.2

EPA EPANET 2.2, the standard water-network solver

#1= under 0.01 % off

Run time, finest grid: 0.01 s · AMD EPYC 9V74 80-Core Processor, 2 cores, 15.6 GB, Linux 6.17.0-1022-azure (GitHub Actions (github-hosted, ubuntu24))

Settings: epanet (WNTR 1.5.0, libepanet22)

Junction heads

• 0.68 mm off

<0.01 % of the 26 m head loss across the network

Pipe flows

• < 0.0001 % off

Scored with method 3.0 · Score card: EPA EPANET 2.2

Run it yourself

EPA EPANET 2.2 · runs on Linux · produced by scripts/run_network_cases.py in track-a.yml.

git clone https://github.com/scott-jeffers/benchmark1d2d && cd benchmark1d2d
git checkout 71dc10fc07a9
python -m pip install -e ".[dev,engines]"
python scripts/run_network_cases.py

The model files the suite wrote for this run (.zip, 0.6 KB): the exact inputs the solver read (one folder per grid, where the test has several), with their SHA-256.

The script writes the EPANET input file from the test's inputs; the model files below are that file.

Hydra

Hydra 17 (NEER AI, Rust): its water-distribution engine on the EPANET data model, run through its CLI with default settings

#3 0.028 % off

Run time, finest grid: 0.01 s · AMD EPYC 9V74 80-Core Processor, 2 cores, 15.6 GB, Linux 6.17.0-1022-azure (GitHub Actions (github-hosted, ubuntu24))

Settings: hydra CLI 4.1.1 (wds engine, EPANET-format binary output)

Junction heads

• 7.4 mm off

0.028 % of the 26 m head loss across the network

Pipe flows

• < 0.0001 % off

Scored with method 3.0 · Score card: Hydra 17.0.0 water distribution

Run it yourself

Hydra 17.0.0 water distribution · version 17.0.0/4.1.1 · runs on Linux · produced by scripts/run_network_cases.py in track-a.yml.

git clone https://github.com/scott-jeffers/benchmark1d2d && cd benchmark1d2d
git checkout 71dc10fc07a9
python -m pip install -e ".[dev,engines]"
HYDRA=$(python scripts/fetch_hydra.py .hydra)  # the pinned Hydra 17 CLI
python scripts/run_network_cases.py --hydra-exe "$HYDRA"

The model files for this run will be published with its next run.

The script writes the EPANET input file from the test's inputs; the model files below are that file.

Not run yet: HEC-RAS 7.0, TELEMAC-2D, ANUGA, GeoClaw, LISFLOOD-FP, TUFLOW, MIKE 21, Iber, BASEMENT, Delft3D FM

Run it and add yours →

Status of this test

Candidate. To become frozen it needs: maintainer review recorded.

Download inputs (.zip)Cite this test View on GitHub

Technical details for reviewers Checks, reference, inputs, sources

Checks and why each limit was chosen

Check	Difference measured as a percentage of	Latest	Why this check
nodal_head Linf of h · in the score	of the 26 m head loss across the network	–	Worst junction head within 5 cm. The SI Hazen–Williams coefficients in use differ by up to 0.1 % (10.667 here, ≈10.67 from EPANET's US-unit 4.727), which moves heads by at most 0.03 m on this network's 26 m of loss; single-precision output adds about 2 mm at 200 m.
link_flow L2 of Q · in the score	already a percentage	–	Pipe flows within 0.1 % (relative L2). Flows do not depend on the Hazen–Williams coefficient's absolute value, only on continuity and loop balance; 0.1 % is the default EPANET convergence criterion (sum of flow changes over total flow ≤ 0.001).
convergence not applicable	–	–	Steady looped network with a closed-form-equivalent reference: there is no grid or time step to refine.

Reference

Exact solution from references.todini.steady_network.

Promotion checklist

Only frozen tests have fixed inputs and answers. This list is computed from the manifest and the published score cards; the rules are in the method.

✓Data licence verifiedfor candidateanalytic-public
✓All inputs availablefor candidateall committed or fetched by SHA-256
✓Reference (truth) availablefor candidateanalytic generator
✓Every tolerance justifiedfor candidateeach gating criterion has a rationale
✓A published run passesfor frozen3 passing score card(s)
✓Order of accuracy shownfor frozennot applicable: Steady looped network with a closed-form-equivalent reference: there is no grid or time step to refine.
✓Two independent codes passfor frozenpassing codes: EPA EPANET 2.2, Hydra 17.0.0 water distribution, WNTR 1.5.0 WNTRSimulator
✗Maintainer review recordedfor frozenno maintainer review recorded

Inputs

File	Role	Format	SHA-256	Get it
`inputs/network.json`	network	json	`e93cd1cba8d7…`	Download

About this test

Physics

The Alperovits–Shamir two-loop gravity network: one reservoir at 210 m, six junctions, eight 1 km pipes with Hazen–Williams \(C = 130\). Steady flow satisfies continuity at every junction and zero head loss around each loop. The reference is the Todini–Pilati global gradient algorithm iterated to \(|\Delta H| < 10^{-12}\) m, which is exact for practical purposes.

What it checks

That a network solver closes mass and energy balances to its stated accuracy. Flows depend only on the balances, so they must agree to 0.1 %. Heads also depend on the Hazen–Williams coefficient's SI form (10.667 here; EPANET's US-unit 4.727 converts to ≈ 10.67), so they are held to 5 cm. EPA EPANET 2.2 agrees to under 1 mm and 0.001 %.

Node and pipe names overlap ("1"–"7" are both): results must carry element_type so the scorer can tell them apart.

Citation

Todini, E., and Pilati, S. (1988). "A gradient algorithm for the analysis of pipe networks." Computer Applications in Water Supply, Vol. 1, 1–20. Alperovits, E., and Shamir, U. (1977). "Design of optimal water distribution systems." Water Resour. Res., 13(6), 885–900.

Sources

Todini, E., Pilati, S. (1988). A gradient algorithm for the analysis of pipe networks.
Alperovits, E., Shamir, U. (1977). Design of optimal water distribution systems. doi:10.1029/WR013i006p00885

Test A1P-010_todini_multiloop · version 1.0.0 · data licence analytic-public