EX-PACS: A DASA Illustrative Example on a Picture Archiving and Communication System

The illustrative example of Dimensional Analysis for Software Architecture (DASA), worked end to end on a hospital Picture Archiving and Communication System (PACS): a service-oriented medical image archive whose archival, retrieval, and metadata services scale independently to absorb burst clinical traffic. Two design iterations model the archive first as a single M/M/c/K queue and then as a seven-node Jackson open queueing network, re-express both in a custom dimensional basis of Time, Structure, and Data, and read the resulting design trade-offs off a Yoly Chart. This repository is a reproducible deliverable, not a library: it produces the figures and coefficient datasets that ground the example, consuming the PyDASA library.

Documentation

The docs/ folder holds the example in three parts, read in order:

1. docs/case-study.md - what the example is: the archive, its workload and modality payload profile, the dimensional framework, the single-node archival service of iteration 1, and the seven-node broker-mediated read/write network of iteration 2 with its routing matrix, five workload scenarios, and per-node parameters.
2. docs/procedure.md - how it runs: the DASA method, its four-stage cycle and seven steps, the Component-Connector Matrix and Enhanced Quality Scenario artefacts, and the idea behind each of the two notebooks.
3. docs/report.md - what it shows: the DASA modelling derivation (relevance list, dimensional matrix, Pi-groups, the four coefficients, the viable region), then the results at component, functionality, and architectural level, the design consequences, and the threats to validity.

What it decides

The archive is modelled dimensionally and evaluated against five design goals. The Pi-theorem reduces ten relevant variables over three fundamental dimensions to seven dimensionless groups, from which four operational coefficients are derived:

Coefficient	Definition	Reads
Occupancy $\theta$	$L / K$	queue fullness
Stall $\sigma$	$W \cdot \lambda / K$	delay-throughput coupling
Effective Yield $\eta$	$\chi \cdot K / (\mu \cdot c)$	error-aware resource effectiveness
Memory Use $\phi$	$M_{\mathrm{act}} / M_{\mathrm{buf}}$	buffer saturation

PACS uses the delivered throughput convention $\chi = (1 - \varepsilon) \cdot \lambda$, treating service errors as losses rather than as reprocessed work.

Design goal	Predicate	Outcome
Latency	$W_j \leq 500$ ms	met, approximately 1 ms to 2 ms per node
Throughput	$\chi_W \geq 20$, $\chi_R \geq 80$ req/s	approached; error compounding costs approximately 1 %
Utilisation	$\rho_j \leq 0.50$	met at every node
Memory	$M_{\mathrm{act},j} \leq M_{\mathrm{buf},j}$	met at every node
Shared database	$\lambda_{DB} \approx 99$ req/s absorbed	met without saturation

The DB node is the shared bottleneck under every workload mix, and the write path is the binding design case despite carrying the smaller share of traffic.

Iterations

Notebook	Model	What it does
PACS-Ex-Iter1.ipynb	single M/M/c/K node	establishes the Time / Structure / Data basis, derives the four coefficients, sweeps 27 configurations, plots the first Yoly Chart
PACS-Ex-Iter2.ipynb	7-node Jackson network	scales the same coefficients to IB, IW, IR, DB, WN, RN, OB over 216 configurations in each of 5 routing scenarios, and aggregates to end-to-end paths

Setup

Requires Python 3.12+.

python -m venv venv
source venv/Scripts/activate         # Git Bash on Windows; use venv/bin/activate on Linux/macOS

# 1. Install PyDASA (not on public PyPI) from source:
pip install "git+https://github.com/DASA-Design/PyDASA.git@v0.7.1"

# 2. Install the rest:
pip install -r requirements.txt

If the PyDASA tag or location differs, adjust the first command; the pin in requirements.txt (pydasa==0.7.1) documents the expected version.

Running

Both notebooks run top to bottom with no arguments. Executing them regenerates every figure under img/:

jupyter nbconvert --to notebook --execute --inplace PACS-Ex-Iter1.ipynb
jupyter nbconvert --to notebook --execute --inplace PACS-Ex-Iter2.ipynb

The notebooks are shipped with their outputs, so they read self-contained on GitHub without being run.

Layout

├── PACS-Ex-Iter1.ipynb    # iteration 1: single M/M/c/K archival service
├── PACS-Ex-Iter2.ipynb    # iteration 2: 7-node Jackson network
├── src/
│   ├── analytic/          # M/M/c/K queues, Jackson solver, PACS network simulation
│   ├── view/              # Yoly Chart plotters + shared figure primitives
│   └── utils/             # shared numerical helpers
├── data/config/           # single source of truth for the parameters of both iterations
├── img/
│   ├── iter1/             # iteration 1 figures (PNG + SVG)
│   └── iter2/             # iteration 2 figures (PNG + SVG)
├── docs/                  # case study, procedure, report + architecture diagrams
└── tests/                 # pytest, mirrors src/

Data convention

data/config/ is the single source of truth. Both configs use the PyDASA Variable-dict schema keyed by LaTeX symbol, carrying each variable's dimension, units, setpoint, and sweep grid. PACS-vars-iter2.json additionally holds the seven artifact blocks and the five per-scenario routing matrices. The notebooks read these and write their figures to img/; every figure is emitted as both PNG and SVG.

Tests

pytest tests/ -q

License

GPL-3.0. See LICENSE.