Opyrability, and what is new in 2.0

Adoption :)

37k+   PyPI downloads and counting, used across the northern and southern hemispheres.

In the wild - many different applications!

From steady state to dynamics

Steady-state operability asks whether the desired outputs are reachable at all. Dynamic operability asks whether they are reachable within a finite number of steps, and how fast.

For $x_{k+1} = f(x_k, u_k)$, $\; y_k = g(x_k)$, the achievable output set at step $k$ is

$$\mathrm{AOS}^{k}(x_0) = \big\{\, y_k = g(x_k) \;\big|\; u_j \in \mathrm{AIS},\ j = 0,\dots,k-1 \,\big\}, \qquad \mathrm{dOI}(k) = \frac{\mu\!\left(\mathrm{AOS}^{k} \cap \mathrm{DOS}\right)}{\mu(\mathrm{DOS})} \times 100\%$$

One call

from opyrability import dynamic_operability
import numpy as np

AIS = [[-1, 1], [-1, 1]]
DOS = [[-2, 2], [-2, 2]]
model = {'A': 0.9*np.eye(2),
         'B': np.eye(2),
         'C': np.eye(2)}

results = dynamic_operability(model,           # LTI dict or step fn
                              x0=np.zeros(2),  # initial state
                              AIS_bound=AIS,   # input set
                              DOS=DOS,         # target outputs
                              k_max=4)         # horizon
print(results['dOI'])  # [25. 90.25 100. 100.]

Example: membrane reactor for methane aromatization

PDE, distributed model

Transient mole balances on the molar holdups of each species (tube and shell) along the reactor length. Two equilibrium-limited reactions, with membrane $\mathrm{H_2}$ removal shifting them forward (Le Chatelier):

$$r_1 = -(1-v_b)\,\eta\,k_1\,C_{\mathrm{CH_4}}\,\frac{K_1 C_{\mathrm{CH_4}}^{2} - C_{\mathrm{C_2H_4}} C_{\mathrm{H_2}}^{2}}{K_1 C_{\mathrm{CH_4}}^{2}}, \qquad r_2 = -(1-v_b)\,\eta\,k_2\,C_{\mathrm{C_2H_4}}\,\frac{K_2 C_{\mathrm{C_2H_4}}^{3} - C_{\mathrm{C_6H_6}} C_{\mathrm{H_2}}^{3}}{K_2 C_{\mathrm{C_2H_4}}^{3}}$$

$$J_j = \frac{36\,Q}{\alpha_j}\,\pi D_t\,\Delta z \left( P_{t,j}^{1/4} - P_{s,j}^{1/4} \right) \qquad \text{Sieverts-type membrane permeation}$$

Discretized into $N=20$ elements, 4 tube + 4 shell species: a 160-state model. Opyrability needs only a one-minute step, dma_mr_cocurrent_step(x, u, d) returning (x_next, y).

Reachable-output funnel (interactive)

HYPER: a cyber-physical fuel-cell and gas-turbine system

HYPER: reachable-output funnel (interactive)

Choosing a dOI evaluation?

Disturbance scenarios and robust operability

scenario_results = dynamic_operability_scenarios(
    make_step,            # step(x, u) for a feed d
    make_initial_state,   # steady state for feed d
    AIS_bounds,
    scenarios={'Low quality well (92% CH4)':  92.0,
               'High quality well (96% CH4)': 96.0},
    DOS=DOS_bounds, k_max=6, engine='plotly')

HYPER under disturbance scenarios (interactive)

Install and go

Before, running the inverse mapping meant installing IPOPT through conda first.

Now, one command:

pip install opyrability

That is it. It includes everything you need, the solver included. cyipopt stays optional, only for method='ipopt'.

Powered by Pounce

Pounce is a pure-Rust interior-point NLP solver from John Kitchin's group at CMU, now the default for Opyrability's inverse mapping and design tools. Why is this important?

• installs as prebuilt wheels: nothing to compile, no third-party binaries, no MUMPS, no licensed HSL to track down
• bundles FERAL, its own sparse symmetric-indefinite linear solver with certified inertia, so the interior-point steps stay reliable without an external solver
• one pip install gives a fast, self-contained solver on Windows, macOS, and Linux

Pounce in action

Pounce is the default, so nothing changes in your call:

fDIS, fDOS, msg = nlp_based_approach(model,        # process model
                                     DOS,          # target outputs
                                     resolution,   # grid density
                                     u0,           # initial guess
                                     lb, ub)       # input bounds
# method='pounce' by default; 'ipopt' still available

Rank competing designs

Score two or more designs by their Operability Index, from the output or the input side, and see which is more operable before committing.

from opyrability import rank_designs

ranking = rank_designs(models={'Tall':    model_a,   # {label: model}
                               'Compact': model_b},
                       AIS_bound=AIS,                 # input set(s)
                       DOS_bound=DOS,                 # target outputs
                       resolution=[10, 10],           # grid density
                       perspective='outputs')         # or 'inputs'

Inverse mapping and intensification (NLP)

fDIS, fDOS, msg = nlp_based_approach(
    model,                # process model
    DOS,                  # target outputs
    resolution,           # grid density
    u0, lb, ub,           # guess, bounds
    problem='P2',         # 'P1' / 'P2' / 'P3'
    PI_target=objective)  # metric to intensify

Optimal modular design (MILP)

The multimodel polytopes turn the search for an optimal modular design into a single mixed-integer linear program, solved once per layer instead of many nonlinear solves.

u_opt, y_opt, phi, *_ = milp_based_approach(
    model,             # process model
    AIS_bound=AIS,     # input bounds
    PI_target=cost,    # metric to minimize
    DOS_bounds=DOS,    # target outputs
    AIS_resolution=5)  # grid density

One LP per layer, not many nonlinear solves: fast and mixed-integer linear.

MILP framework in the documentation

First-principles, process simulator, algebraic/equation-oriented, and/or ML surrogate

Opyrability maps whatever you can evaluate:

• a plain Python function
• an equation-oriented Pyomo model
• a data-driven/ML surrogate (scikit-learn)

The plots show operability analyses from several modeling environments, all through the same API.

ML surrogates under uncertainty

Drive it with your coding agent

Opyrability ships with OPYRABILITY.md: one file that teaches an AI coding assistant the vocabulary, function signatures and best practices, the expected model (M) syntax, when to use each function, and the mistakes to avoid.

🧑‍💻 💬 → → </> → → →

Documentation

# every API page runs code like this
from opyrability import (
    multimodel_rep, OI_eval)

AOS = multimodel_rep(model, AIS,
                     resolution=[10, 10])
OI = OI_eval(AOS, DOS)   # -> 60.2 %

Tested across multiple Python versions (3.11 - 3.14)

Contributing

Opyrability is open source and welcomes contributions. It will always be that way.

• Report a bug or request a feature: open an issue on GitHub
• Contribute code or a case study: fork the repo, branch, and open a pull request
• CI runs the full test suite on your pull request across Python 3.11 to 3.14

Upgrading from 1.4.x

• the default solver is now Pounce; for the IPOPT backend, pass method='ipopt' and install cyipopt from conda
• Python 3.9 and 3.10 are no longer supported (both reached EOL); the minimum is 3.11
• the conda package is retired; install with pip

Opyrability 2.0 at a glance

1. Dynamic operability: funnels + dOI, one call
2. Pounce default solver, pure pip install
3. rank designs, MILP based approach
4. P1 / P2 / P3 inverse mapping s.t. PI
5. Pyomo and ML surrogate models support
6. OPYRABILITY.md agent skill
7. 147 tests, Python 3.11 to 3.14

Docs · Code · Paper

pip install opyrability

Thanks

Development began in the CODES Group at West Virginia University, with San Dinh and under Fernando V. Lima, and continues at Carnegie Mellon University. Pounce is the work of John Kitchin and his group.