Metadata-Version: 2.4
Name: opsrdo
Version: 1.0.2
Summary: Robust design optimisation of building frames under seismic uncertainty with OpenSeesPy: nonlinear pushover and time history, surrogates, benchmarks
Author: Gaurav Datta, Giuseppe Carlo Marano, Arman Hajiha
License-Expression: MIT
Project-URL: Homepage, https://github.com/ARtIStE-Research-Group/OpenSeesPy-RDO
Project-URL: Documentation, https://github.com/ARtIStE-Research-Group/OpenSeesPy-RDO/tree/HEAD/docs/manual
Project-URL: Issues, https://github.com/ARtIStE-Research-Group/OpenSeesPy-RDO/issues
Project-URL: Changelog, https://github.com/ARtIStE-Research-Group/OpenSeesPy-RDO/blob/HEAD/CHANGELOG.md
Keywords: OpenSeesPy,robust design optimization,seismic design,uncertainty quantification,reinforced concrete,steel frames,Eurocode 8,Gaussian process,benchmark
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Science/Research
Classifier: Intended Audience :: Education
Classifier: Operating System :: Microsoft :: Windows
Classifier: Operating System :: POSIX :: Linux
Classifier: Operating System :: MacOS
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Scientific/Engineering
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: openseespy>=3.5; platform_system != "Windows"
Requires-Dist: openseespy==3.6.0.3; platform_system == "Windows"
Requires-Dist: openseespywin==3.6.0.3; platform_system == "Windows"
Requires-Dist: numpy>=1.24
Requires-Dist: scipy>=1.10
Requires-Dist: pymoo>=0.6
Requires-Dist: matplotlib>=3.6
Requires-Dist: pyyaml>=6
Provides-Extra: surrogate
Requires-Dist: scikit-learn>=1.2; extra == "surrogate"
Provides-Extra: studies
Requires-Dist: SALib>=1.4; extra == "studies"
Provides-Extra: yaml
Requires-Dist: pyyaml>=6; extra == "yaml"
Provides-Extra: bo
Requires-Dist: optuna>=3.4; extra == "bo"
Provides-Extra: app
Requires-Dist: streamlit>=1.40; extra == "app"
Requires-Dist: pandas>=1.5; extra == "app"
Provides-Extra: desktop
Requires-Dist: streamlit>=1.40; extra == "desktop"
Requires-Dist: pandas>=1.5; extra == "desktop"
Requires-Dist: pywebview>=5; extra == "desktop"
Provides-Extra: excel
Requires-Dist: openpyxl>=3.1; extra == "excel"
Provides-Extra: all
Requires-Dist: scikit-learn>=1.2; extra == "all"
Requires-Dist: SALib>=1.4; extra == "all"
Requires-Dist: pyyaml>=6; extra == "all"
Requires-Dist: streamlit>=1.40; extra == "all"
Requires-Dist: pandas>=1.5; extra == "all"
Requires-Dist: optuna>=3.4; extra == "all"
Requires-Dist: openpyxl>=3.1; extra == "all"
Provides-Extra: dev
Requires-Dist: pytest>=7; extra == "dev"
Requires-Dist: scikit-learn>=1.2; extra == "dev"
Requires-Dist: SALib>=1.4; extra == "dev"
Requires-Dist: pyyaml>=6; extra == "dev"
Requires-Dist: streamlit>=1.40; extra == "dev"
Requires-Dist: pandas>=1.5; extra == "dev"
Requires-Dist: optuna>=3.4; extra == "dev"
Requires-Dist: markdown>=3.4; extra == "dev"
Requires-Dist: openpyxl>=3.1; extra == "dev"
Dynamic: license-file

# OpenSeesPy-RDO

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.23792452.svg)](https://doi.org/10.5281/zenodo.23792452)
[![tests](https://github.com/ARtIStE-Research-Group/OpenSeesPy-RDO/actions/workflows/tests.yml/badge.svg)](https://github.com/ARtIStE-Research-Group/OpenSeesPy-RDO/actions/workflows/tests.yml)
[![online demo](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](https://opsrdo-demo.streamlit.app)

**Robust seismic design of building frames under uncertainty with OpenSeesPy.**

OpenSeesPy-RDO sizes RC and steel moment frames so that their seismic performance is not only
good on average but also *insensitive* to uncertainty in materials, loads and seismic
demand. It couples nonlinear fibre-section pushover analysis in OpenSeesPy with the
Eurocode 8 N2 method, Latin hypercube sampling and multi-objective NSGA-II, and it
ships benchmark frames whose smallest member can be solved exhaustively, so robust
optima are known with certainty.

> Version **1.0.0**. Install with `pip install "opsrdo[app]"`, then `opsrdo app`. See [Scope and limitations](#scope-and-limitations).
> User manual: [`docs/manual/`](docs/manual/00_index.md) (one-file HTML: `docs/manual/OpenSeesPy-RDO_manual.html`).

**Try it online:** **https://opsrdo-demo.streamlit.app** (the app with the packaged examples, nothing to install;
limited run sizes). **Learn:** a [teaching pack](teaching/README.md) of three notebooks (robust measures, the
winner's curse, a nonlinear RC frame). The demo runs the app in demo mode (`opsrdo app --demo`; hosting in
[`docs/online_demo.md`](docs/online_demo.md)).

## General frames

Besides the benchmark frames, any planar RC frame can be defined member by member in YAML or JSON (unequal bays
and storeys, setbacks, missing columns, named sections with separate top and bottom steel), checked, analysed and
optimised: `opsrdo general --frame example:frames/general_setback.yaml`. See [`docs/general_frames.md`](docs/general_frames.md).

**3D frames and taller steel frames.** Spatial RC frames can be defined member by member (`type: general3d`:
setbacks, openings, mass eccentricity; manual section 4.2b), and the SAC Los Angeles 9- and 20-storey steel frames
are examples next to the 3-storey one, with optional deteriorating (IMK) girder hinges for near-collapse states.

**One analysis of a frame.** `opsrdo analyse gravity | modal | spectrum | time_history | pushover --frame FILE` (and
the app's Analyses tab) runs a deterministic analysis: EN 1998-1 modal response spectrum (SRSS/CQC), linear or
nonlinear time history, pushover with the N2 target (manual section 4.3). Reports can also be written as Excel and
PDF (`opsrdo report --excel --pdf`), and `opsrdo records organise | check` prepares downloaded record sets.

**Engineering decisions.** `opsrdo decide` (and the app's Decisions tab): is more testing of an existing building
worth it, do EN 1998-3 confidence factors agree with the robust result, how does the code drift estimate with q
compare with the nonlinear response, the +-5 % eccentricity rule, and the cost-risk-CO2 trade-off (manual chapter 13).

**Every command takes every problem.** `opsrdo problem validate | evaluate | search | exhaustive`, `opsrdo report` and
the app's Robustness check tab accept a declared problem, a regular or general frame file (a general frame's `design`
block lists candidate sections) or a built-in name (B0-B4, T1-T4, S1): `opsrdo problem search --file
example:frames/general_setback.yaml`.

## Use it with your own model

Any OpenSeesPy (or other Python) model can use the robust-design pipeline: declare the design variables, random
variables and limit states in YAML and write one function `simulate(design, theta) -> {response: value}`.

```bash
opsrdo problem validate --file example:problems/sac3/problem.yaml
opsrdo problem evaluate --file example:problems/sac3/problem.yaml --x 1,1,1,2,2 --samples 8
opsrdo problem search   --file example:problems/sac3/problem.yaml --method joint_z1 --budget 96
```

Models in OpenSees Tcl or any other program work too: `command:` instead of `simulate:` runs the program through an
input and an output file (`opsrdo init my_model --template opensees-tcl`; manual section 2.8).

The example is the SAC Los Angeles 3-storey steel moment frame (pushover + N2, drift and column limit states;
illustrative hazard; periods and beam gravity loads checked against FEMA-355C, see `src/opsrdo/examples/problems/sac3/model.py`). Format and details:
[`docs/architecture.md`](docs/architecture.md#declaring-a-problem-bring-your-own-model-v015).

## Scope and related tools

OpenSeesPy-RDO is developed within the ARtIStE research group (Politecnico di Torino) as a companion to ARCOPY
([10.5281/zenodo.23686655](https://doi.org/10.5281/zenodo.23686655)). The two tools answer different questions:
ARCOPY finds the lowest-cost feasible retrofit of an existing RC frame with deterministic, linear analysis, EC2 member
checks and reports; OpenSeesPy-RDO finds designs that remain within their limits under uncertainty, with nonlinear
analysis, robust formulations, surrogates and a benchmark protocol, and checks how reliable a chosen design really is.
They are separate code bases: OpenSeesPy-RDO shares no code with ARCOPY ([`docs/independence.md`](docs/independence.md)),
and any combined use goes through exported data files. Dakota and quoFEM provide general uncertainty-quantification
machinery.

## Authors

**Gaurav Datta**, **Giuseppe Carlo Marano** and **Arman Hajiha**, ARtIStE Research Group, Department of Structural,
Geotechnical and Building Engineering (DISEG), Politecnico di Torino.

Results come from real runs and automated tests, and several claims were corrected when the data disagreed. Known
issues and open questions are recorded in [`REVIEW_GUIDE.md`](REVIEW_GUIDE.md).

## Why

Deterministic structural optimisation tends to push designs to the edge of
feasibility, where small deviations from nominal values cause constraint violation.
Robust design optimisation (RDO) addresses this by optimising the mean *and* the
variability of performance. Recent work has formulated RDO for RC bridge piers and
for damper retrofits of steel frames, and benchmark problems with known global
optima now exist for *deterministic* optimum design of RC frames (Mergos, 2024).
This project provides an open, reusable workflow and benchmark set for the robust
counterpart: new RC building frames under uncertainty, with discrete, buildable
sections and nonlinear analysis.

## Features

Core (stable)
- Parametric 2D RC frame generator with discrete, buildable catalogues; JSON/YAML input files.
- OpenSeesPy fibre-section model with force-based elements and P-Delta; robust pushover driver.
- EN 1998-1 elastic spectrum and N2 target displacement (Annex B).
- Latin hypercube uncertainty (concrete, steel, load/mass, demand) with common random numbers.
- Screening checks, cost and embodied CO2, robust (3-objective) and deterministic NSGA-II
  via pymoo with caching and multiprocessing; exhaustive search for small benchmarks.
- Robustness measured as mean + k·std or as an empirical quantile.

Modules

| # | Module | Status | Command / API |
|---|---|---|---|
| 1 | Convergence, seed and Sobol studies | stable | `opsrdo study convergence \| seeds \| sobol` |
| 2 | Gaussian-process surrogate-assisted optimisation | experimental | `opsrdo surrogate` |
| 3 | Records, EC8 scaling, synthetic motions, NLTH | experimental | `--demand nlth --records DIR` |
| 4 | 3D frames, random accidental eccentricity, TIR | experimental | `--benchmark B3 --tir-limit 1.4` |
| 5 | Extended EC8 DCM and ACI 318-19 SMF checks | experimental | `--checks ec8 \| aci` |
| 6 | Scenario loss and total-cost objective | experimental | `--loss --objective total_cost` |

## Installation

```bash
git clone https://github.com/ARtIStE-Research-Group/OpenSeesPy-RDO.git
cd OpenSeesPy-RDO
pip install -e ".[dev,all]"
pytest -q          # 279 tests incl. the validation suite and app tests
```

OpenSeesPy is installed from PyPI as a dependency; it is not redistributed here. **On Windows use Python 3.11**: the
Windows builds of OpenSeesPy load only there, and the package pins the working one (3.6.0.3; 3.7.0.3 does not
import). `opsrdo doctor` checks the installation and says how to fix what is missing.

Without cloning (until a PyPI release): `pip install "opsrdo[all] @ git+https://github.com/ARtIStE-Research-Group/OpenSeesPy-RDO.git"`.
Python 3.10-3.12.

## Start in five minutes

```bash
opsrdo init my_project                      # asks which kind of project; or --template own-model | steel-frame | shear-building | rc-frame
cd my_project
opsrdo problem validate --file problem.yaml
opsrdo problem evaluate --file problem.yaml --preset quick
opsrdo problem search   --file problem.yaml --preset standard
opsrdo report           --file problem.yaml --preset standard   # report_problem.html + .json
```

**Robustness report.** `opsrdo report` searches for a design (or takes `--x`), then verifies it on fresh scenarios
drawn with a reserved seed that no method sees, and writes a self-contained HTML report (print it to PDF from a
browser) and a JSON file with every number: the chosen design and its cost; for each limit state the value the
method **claimed**, the **verified** robust value, the nominal value and the probability of exceeding the limit,
with a histogram; the uncertainty (each random variable and its register source); the method and budget; the
assumptions; and a reproducibility block (version, git commit, seeds, file hashes, command). Works with declared
problems (`--file`) and the built-in RC benchmarks (`--benchmark B0 --x 2,0,1,1`). The `quick` preset suits small
design spaces; for frames such as SAC (1,024 designs) use `standard` or more.

`opsrdo examples list` shows the examples shipped with the package; any command accepts them as
`example:<path>`, e.g. `opsrdo problem evaluate --file example:problems/sac3/problem.yaml`, and
`opsrdo examples copy DIR` copies them to a folder you can edit. Presets: `quick` (8 scenarios per design, 64
analyses for a search), `standard` (16, 320), `publication` (32, 1,024); `--samples` and `--budget` override them.

The own-model template is a steel cantilever whose sections are tuned so that the choice matters: HEA360 truly
fails the drift limit (robust drift 2.11 %, 9 % of scenarios above 2 %, from 2,048 scenarios) and HEA400 truly
passes (1.55 %). With the `quick` preset, cost-ordered Monte Carlo with eight scenarios per design
(`--method mc8`) picked HEA360 in two of three seeds, while the joint Gaussian-process search, TPE and the others
picked HEA400. That is the winner's curse this package studies, in five minutes.

## Preliminary robust assessment

The app's first tab, "Assess a frame", checks a frame as designed or as built across the
uncertain scenarios, shows what drives the risk, finds the cheapest change that passes
and writes a report. Existing buildings use EN 1998-3 knowledge levels and are compared
with the conventional EC8-3 check. Screening only; see [`docs/assessment.md`](docs/assessment.md).

## An open framework: problems, benchmarks, datasets

Beyond the RC frame code, the package defines a general contract for robust structural
design problems (`opsrdo.api.Problem`), so other structures, simulators, optimisers and
learners can plug in and be compared. See [`docs/architecture.md`](docs/architecture.md),
the [benchmark protocol](docs/benchmark_protocol.md), the [dataset format](docs/dataset_format.md),
the first [open datasets](datasets/README.md) and the [register of 50 uncertainty
sources](docs/uncertainty_register.md) (what is modelled, what is fixed, what is missing).

Studies on sampling designs, baseline methods and alternative formulations: `studies/sampling`, `studies/baselines`
(honest, partly negative results: differences between search methods are mostly within noise on the analytic problems).
Select the scenario sampling design with `--sampling lhs_opt` (recommended for N up to about 64).

```python
from opsrdo.api import ShearBuildingProblem, exhaustive_problem, reference_optimum, validate_problem
p = ShearBuildingProblem()          # analytic problem, no FE program needed
assert validate_problem(p) == []
best = reference_optimum(exhaustive_problem(p, p.sample(256, seed=1)), p.limit)
```

## Desktop application

A double-click application for Windows, macOS and Linux, with everything bundled (no
Python needed), is built automatically for each release; see [`docs/desktop.md`](docs/desktop.md).
From source: `opsrdo desktop`.

## Graphical app

```bash
pip install -e ".[app]"
opsrdo app
```

The app opens in your browser and runs entirely on your computer. Its first tab, **Guided**, takes any problem
through five steps (model, uncertainty, check with the drivers of the risk, improve, verified report), and can build
a new problem from tables with sourced default uncertainties (manual section 4.4). It also shows how well the
surrogate behind a search is calibrated (leave-one-out, interval coverage) and refines it, and saves or opens the
whole work as one `.rdo` project file (`opsrdo project save | info | open`). Choose a
benchmark, define a 2D frame or load a frame file; evaluate a design under all
samples (drift histogram, code checks, pushover curve with the N2 target); run
NSGA-II, surrogate-assisted or exhaustive optimisation with a progress bar; and
explore the results with sliders for k and the drift limit. Results can be
downloaded, and results.json files from the command line can be opened in the
Results tab. The "Robustness check" tab runs the robustness report for a declared problem or a benchmark, and
"Spectra and limits" plots design spectra (EC8 Type 1 and 2, ASCE 7-16, a user table) and browses the limit-state
library (`{library: id}` in problem files).

## Quick start

```bash
# Robust optimisation of benchmark B1 (3 storeys, 3 bays, 12 design variables)
opsrdo run --benchmark B1 --mode robust --samples 16 --pop 24 --gen 15 --workers 4

# Deterministic baseline on the same frame
opsrdo run --benchmark B1 --mode deterministic --pop 24 --gen 15

# Enumerate every design of the small benchmark B0 (108 designs)
opsrdo exhaustive --benchmark B0 --samples 16 --workers 4

# Evaluate one design vector (integer catalogue indices)
opsrdo evaluate --benchmark B1 --samples 16 --x 4,2,3,2,4,2,3,2,3,1,2,1

# Your own frame, extended EC8 checks and a total-cost (cost + expected loss) objective
opsrdo run --frame example:frames/four_storey.yaml --checks ec8 --loss --objective total_cost

# Nonlinear time-history demand with your PEER records (or --synthetic N for testing)
opsrdo run --benchmark B1 --demand nlth --records path/to/AT2_files --t1 0.6 --demand-beta 0.15

# 3D frame with random accidental eccentricity and a robust torsional-irregularity limit
opsrdo run --benchmark B3 --tir-limit 1.4

# Surrogate-assisted optimisation for larger frames
opsrdo surrogate --benchmark B2 --n-init 16 --iters 5 --batch 6

# Studies for reporting
opsrdo study convergence --benchmark B0 --x 2,0,1,1
opsrdo study sobol --benchmark B0 --x 2,0,1,1 --n-base 32
```

Each run writes `results.csv`, `results.json` (full records and settings) and
`pareto.png` to `results/<benchmark>_<mode>/`.

Python API:

```python
from opsrdo import Settings, UncertaintyModel, get_benchmark
from opsrdo.optimize import run_nsga2, pareto_records

spec = get_benchmark("B1")
samples = UncertaintyModel().sample(spec, n=16, seed=2026)
res, problem = run_nsga2(spec, samples, Settings(drift_limit=0.02), mode="robust")
front = pareto_records(res, problem)
```

## Benchmarks (provisional)

| ID | Frame | Groups | Variables | Design space |
|---|---|---|---|---|
| B0 | 2 storeys, 1 bay | 1 | 4 | 108 (exhaustive) |
| B1 | 3 storeys, 3 bays | 3 | 12 | ≈ 1.8 × 10⁹ |
| B2 | 6 storeys, 3 bays | 3 | 12 | ≈ 1.8 × 10⁹ |
| B3 | 3D, 3 storeys, 2 × 2 bays | 2 | 8 | ≈ 1.5 × 10⁶ (experimental) |
| B4 | 3D, as B3 with 10 % mass eccentricity and edge-column variables | 2 | 10 | ≈ 7.4 × 10⁷ (experimental) |

Common settings: storey height 3.2 m, bay 5.0 m, gk = 25 kN/m, qk = 10 kN/m,
C30/37, B500, ag = 0.25 g, ground type C, drift limit 2 %, *k* = 1.645.

### Reference results

Full details, commands and caveats: [`reference_results/README.md`](reference_results/README.md).

**B0, exhaustive (108 designs × 16 samples).** The robust optimum (0.40 m columns,
1.0 % steel; 0.50 m beams, 1.0 %) costs 1492 against 1289 for the cheapest design
whose mean drift meets the limit (0.30 m, 2.0 %; 0.40 m, 1.4 %): robust feasibility
changes the design type at +16 % cost.

**B1, NSGA-II.**

| | Cost | Mean + 1.645σ drift | P(drift > 2 %) |
|---|---|---|---|
| Deterministic optimum | 5654 | 2.28 % | 12.5 % |
| Robust optimum | 7074 (+25 %) | 1.96 % | 6.25 % |

The deterministic optimum meets the limit at nominal values (1.52 %) but not under
uncertainty.

**B2, surrogate-assisted (24 true evaluations, 8 samples).** Cheapest robust-feasible
design costs 13362 (mean drift 1.39 %, mean + 1.645σ = 1.97 %); surrogate
leave-one-out R² rose from about 0.56 to 0.67 as designs were added.

**B3, 3D surrogate-assisted.** Runs as designed, but shows that a plan-symmetric
benchmark cannot exercise torsion-aware design (TIR 1.04-1.06 for all designs); see
REVIEW_GUIDE §3.6.

Studies on B0 show the drift mean converging well but the std estimate being
tail-sensitive, and the demand factor carrying ≈ 96 % of the drift variance; both are
open questions in the review guide. Cost is in placeholder units.

## AI study: uncertainty-aware surrogates

`studies/ai_surrogates/` compares machine-learning surrogates for estimating robust
statistics. A joint-space Gaussian process (`--model joint`) estimated drift σ 2-4
times more accurately than per-design sampling for the same analyses. Inside the
optimiser, requiring its upper confidence bound to meet the limit gave genuinely
feasible robust designs on B1 with 10 times fewer analyses than NSGA-II. A tuning study
shows the model's uncertainty is conservative; `--confidence 1.0` is the calibrated
choice (truly feasible in every tested setting at 0.1-5 % extra cost). Details, caveats and figures in the study README.

## Method in brief

Documentation: [`docs/methodology.md`](docs/methodology.md) (formulation and assumptions),
[`docs/validation.md`](docs/validation.md) (validation against independent calculations),
and [`docs/worked_examples.md`](docs/worked_examples.md) (EC8/ACI check example).

See [`docs/methodology.md`](docs/methodology.md) for the formulation, modelling
assumptions, default statistics, all checks and every module. Changes are listed in
[`CHANGELOG.md`](CHANGELOG.md); contribution rules in [`CONTRIBUTING.md`](CONTRIBUTING.md).

## Scope and limitations

OpenSeesPy-RDO supports design and assessment decisions with nonlinear analysis under uncertainty. It does not replace
code-compliance checking: as with any analysis software, results must be checked by a qualified engineer.

- **Checked against:** 47 PEER RC column tests, hand calculations (N2, stiffness, spectra), the FEMA-355C SAC frames
  (periods and gravity loads) and independent reference scripts (manual chapter 10).
- **Not modelled:** shear and joint failure, bond slip, infills and soil-structure interaction; RC collapse is therefore
  not captured reliably.
- **Code checks** (EC8 DCM, ACI 318-19 SMF) are simplified screening subsets, not a full member design.
- **N2** suits regular, first-mode-dominated structures; check irregular frames with time history (manual 4.2b).
- **Default values** for cost, CO2, loss and uncertainty are illustrative: set your own for real projects.

Known issues and open questions for contributors: [`REVIEW_GUIDE.md`](REVIEW_GUIDE.md).

## Citing

Please cite the software using [`CITATION.cff`](CITATION.cff) or its Zenodo DOI,
[10.5281/zenodo.23792452](https://doi.org/10.5281/zenodo.23792452) (all versions; each release also has its own DOI):

> Datta, G., Marano, G. C., Hajiha, A. (2026). OpenSeesPy-RDO: Robust design optimisation of building frames under seismic uncertainty with
> OpenSeesPy (1.0.2). Zenodo. https://doi.org/10.5281/zenodo.23792452

## Related work

- Marano, G. C., Hajiha, A., Datta, G. (2026). ARCOPY: Seismic assessment and cost-based retrofit optimization of RC
  frames with OpenSeesPy (V1.2.0). Zenodo. https://doi.org/10.5281/zenodo.23686655

- Mergos, P. E. (2024). Benchmark problems in optimum structural design of 3D
  reinforced concrete frames. *Journal of Building Engineering*, 91, 109554.
- Hassanzadeh, A., Moradi, S., Burton, H. V. (2024). Performance-based design
  optimization of structures: State-of-the-art review. *Journal of Structural
  Engineering*, 150(8).
- Blank, J., Deb, K. (2020). pymoo: Multi-objective optimization in Python.
  *IEEE Access*, 8, 89497–89509.
- Zhu, M., McKenna, F., Scott, M. H. (2018). OpenSeesPy: Python library for the
  OpenSees finite element framework. *SoftwareX*, 7, 6–11.

## License

MIT, see [`LICENSE`](LICENSE). OpenSees/OpenSeesPy are distributed under their own
license terms; check compatibility for your use case.
