Examples

This section contains examples demonstrating LINE Solver Python capabilities, organized by complexity and topic. All examples are available as Jupyter notebooks in the python/examples/ directory.

Basic Examples

Open Queueing Networks

Basic Open Network (examples/basic/openQN/oqn_basic.ipynb)

Simple open queueing network with multiple solvers comparison.

One-Line Open Model (examples/basic/openQN/oqn_oneline.ipynb)

Minimal open model created in a single line of code.

Four-Queue Network (examples/basic/openQN/oqn_fourqueues.ipynb)

Open network with four interconnected queues.

Class-Switching Routing (examples/basic/openQN/oqn_cs_routing.ipynb)

Open network with class-switching routing behavior.

Trace-Driven Model (examples/basic/openQN/oqn_trace_driven.ipynb)

Open network driven by empirical trace data.

Multiple Sinks (examples/basic/openQN/oqn_vsinks.ipynb)

Open network with multiple sink nodes.

Closed Queueing Networks

One-Line Closed Model (examples/basic/closedQN/cqn_oneline.ipynb)

Minimal closed model created in a single line of code.

Multi-Queue Network (examples/basic/closedQN/cqn_twoqueues_multi.ipynb)

Closed network with multiple queues and routing.

Multi-Server Network (examples/basic/closedQN/cqn_multiserver.ipynb)

Closed network with multi-server queues.

Repairmen Model (examples/basic/closedQN/cqn_repairmen.ipynb)

Machine repair model with multiple repairmen.

Multi-Repairmen Model (examples/basic/closedQN/cqn_repairmen_multi.ipynb)

Extended repairmen model with complex routing.

BCMP Theorem Example (examples/basic/closedQN/cqn_bcmp_theorem.ipynb)

Example demonstrating BCMP network properties.

DPS Scheduling (examples/basic/closedQN/cqn_scheduling_dps.ipynb)

Closed network with Discriminatory Processor Sharing.

MMPP/2 Service (examples/basic/closedQN/cqn_mmpp2_service.ipynb)

Closed network with MMPP/2 service process.

Two-Class Erlang (examples/basic/closedQN/cqn_twoclass_erl.ipynb)

Two-class closed network with Erlang distributions.

Two-Class HyperExp (examples/basic/closedQN/cqn_twoclass_hyperl.ipynb)

Two-class closed network with hyper-exponential distributions.

Three-Class HyperExp (examples/basic/closedQN/cqn_threeclass_hyperl.ipynb)

Three-class closed network with hyper-exponential distributions.

Mixed Queueing Networks

Basic Mixed Network (examples/basic/mixedQN/mqn_basic.ipynb)

Network with both open and closed job classes.

Single-Server FCFS (examples/basic/mixedQN/mqn_singleserver_fcfs.ipynb)

Mixed network with single-server FCFS scheduling.

Single-Server PS (examples/basic/mixedQN/mqn_singleserver_ps.ipynb)

Mixed network with single-server processor sharing.

Multi-Server FCFS (examples/basic/mixedQN/mqn_multiserver_fcfs.ipynb)

Mixed network with multi-server FCFS scheduling.

Multi-Server PS (examples/basic/mixedQN/mqn_multiserver_ps.ipynb)

Mixed network with multi-server processor sharing.

Fork-Join Networks

Basic Fork-Join, open (examples/basic/forkJoin/fj_basic_open.ipynb)

Simple fork-join parallel processing model with an open class.

Basic Fork-Join, closed (examples/basic/forkJoin/fj_basic_closed.ipynb)

The same topology driven by a closed class.

Basic Nesting (examples/basic/forkJoin/fj_basic_nesting.ipynb)

Fork-join network with nested parallel sections.

Three Branches (examples/basic/forkJoin/fj_threebranches.ipynb)

Fork-join with three parallel processing branches.

Serial Fork-Join (Closed) (examples/basic/forkJoin/fj_serialfjs_closed.ipynb)

Serial combination of fork-join sections in closed network.

Route Overlap (examples/basic/forkJoin/fj_route_overlap.ipynb)

Fork-join with overlapping routing paths.

With Delays (examples/basic/forkJoin/fj_delays.ipynb)

Fork-join network including delay nodes.

Complex Serial (examples/basic/forkJoin/fj_complex_serial.ipynb)

Complex serial arrangement of fork-join sections.

Class-Switching Pre-Fork (examples/basic/forkJoin/fj_cs_prefork.ipynb)

Class-switching before fork operations.

Class-Switching Multi-Visits (examples/basic/forkJoin/fj_cs_multi_visits.ipynb)

Class-switching with multiple revisits in fork-join.

Priority and Scheduling Models

Identical Priority Classes (examples/basic/prioModel/prio_identical.ipynb)

Multiple job classes with identical priorities.

FCFS Priority Open (examples/basic/prioModel/prio_hol_open.ipynb)

Open network with first-come first-served priority scheduling.

FCFS Priority Closed (examples/basic/prioModel/prio_hol_closed.ipynb)

Closed network with first-come first-served priority scheduling.

PS Priority (examples/basic/prioModel/prio_psprio.ipynb)

Processor sharing with priority classes.

Class Switching Models

Implicit Class Switching (examples/basic/classSwitching/cs_implicit.ipynb)

Network with implicit class switching behavior.

Single Diamond (examples/basic/classSwitching/cs_single_diamond.ipynb)

Diamond-shaped routing with class switching.

Multi Diamond (examples/basic/classSwitching/cs_multi_diamond.ipynb)

Multiple diamond routing patterns with class switching.

Transient Class (examples/basic/classSwitching/cs_transient_class.ipynb)

Class switching with transient job classes.

Cache Models

FIFO Replacement (examples/basic/cacheModel/cache_replc_fifo.ipynb)

Cache model with FIFO replacement policy.

Round-Robin Replacement (examples/basic/cacheModel/cache_replc_rr.ipynb)

Cache model with round-robin replacement policy.

Routing-Based Cache (examples/basic/cacheModel/cache_replc_routing.ipynb)

Cache model with routing-based replacement.

Replacement Policy Comparison (examples/basic/cacheModel/cache_compare_replc.ipynb)

Comparison of different cache replacement policies.

Layered Queueing Networks

Basic LQN (examples/basic/layeredModel/lqn_basic.ipynb)

Basic layered queueing network model.

Serial LQN (examples/basic/layeredModel/lqn_serial.ipynb)

Serial arrangement of layered stochastic services.

Two Tasks (examples/basic/layeredModel/lqn_twotasks.ipynb)

Layered model with two interacting tasks.

Setup and Delay-Off (examples/basic/layeredModel/lqn_setup.ipynb)

Layered model whose servers switch off when idle and pay a setup time on reactivation.

BPMN Workflow (examples/basic/layeredModel/lqn_bpmn.ipynb)

BPMN workflow modeled as layered queueing network.

Multi-Solver LQN (examples/basic/layeredModel/lqn_multi_solvers.ipynb)

Layered model solved with multiple solvers.

Workflow Example (examples/basic/layeredModel/lqn_workflows.ipynb)

Complex workflow modeled with layered networks.

OFBiz Example (examples/basic/layeredModel/lqn_ofbiz.ipynb)

Real-world OFBiz application modeled as LQN.

Stochastic Petri Nets

Basic Open SPN (examples/basic/stochPetriNet/spn_basic_open.ipynb)

Open stochastic Petri net model.

Basic Closed SPN (examples/basic/stochPetriNet/spn_basic_closed.ipynb)

Closed stochastic Petri net model.

Two Places Closed (examples/basic/stochPetriNet/spn_closed_twoplaces.ipynb)

Closed SPN with two places.

Four Places Closed (examples/basic/stochPetriNet/spn_closed_fourplaces.ipynb)

Closed SPN with four places.

Seven Places Open (examples/basic/stochPetriNet/spn_open_sevenplaces.ipynb)

Open SPN with seven places.

Two Modes (examples/basic/stochPetriNet/spn_twomodes.ipynb)

SPN with two operational modes.

Four Modes (examples/basic/stochPetriNet/spn_fourmodes.ipynb)

SPN with four operational modes.

Inhibiting Arcs (examples/basic/stochPetriNet/spn_inhibiting.ipynb)

SPN with inhibiting arc constraints.

Advanced Examples

State Probabilities

Aggregated State Probabilities (examples/advanced/stateProbabilities/statepr_aggr.ipynb)

Computing aggregated state probabilities for network analysis.

Large Model Aggregation (examples/advanced/stateProbabilities/statepr_aggr_large.ipynb)

Aggregated state probabilities for large-scale models.

System Aggregation (examples/advanced/stateProbabilities/statepr_sys_aggr.ipynb)

System-level aggregated state probability analysis.

Large System Aggregation (examples/advanced/stateProbabilities/statepr_sys_aggr_large.ipynb)

System aggregation for large-scale network models.

All Probabilities FCFS (examples/advanced/stateProbabilities/statepr_allprobs_fcfs.ipynb)

Complete state probability enumeration for FCFS scheduling.

All Probabilities PS (examples/advanced/stateProbabilities/statepr_allprobs_ps.ipynb)

Complete state probability enumeration for processor sharing.

State-Dependent Routing

Open State-Dependent Routing (examples/advanced/stateDepRouting/sdroute_open.ipynb)

Open network with routing decisions based on system state.

Closed State-Dependent Routing (examples/advanced/stateDepRouting/sdroute_closed.ipynb)

Closed network with state-dependent routing policies.

Two-Class State-Dependent (examples/advanced/stateDepRouting/sdroute_twoclasses_closed.ipynb)

Two-class closed network with state-dependent routing.

Initial State Specification

FCFS Exponential Init (examples/advanced/initState/init_state_fcfs_exp.ipynb)

FCFS network with exponential service and specified initial state.

FCFS Non-Exponential Init (examples/advanced/initState/init_state_fcfs_nonexp.ipynb)

FCFS network with non-exponential service and initial state.

PS Initial State (examples/advanced/initState/init_state_ps.ipynb)

Processor sharing network with specified initial state.

Load-Dependent Services

Multi-Server PS (examples/advanced/loadDependent/ld_multiserver_ps.ipynb)

Multi-server processor sharing with load-dependent rates.

Multi-Server PS Two-Class (examples/advanced/loadDependent/ld_multiserver_ps_twoclasses.ipynb)

Two-class multi-server PS with load dependence.

Multi-Server FCFS (examples/advanced/loadDependent/ld_multiserver_fcfs.ipynb)

Multi-server FCFS with load-dependent service rates.

Class Dependence (examples/advanced/loadDependent/ld_class_dependence.ipynb)

Load dependence based on specific job classes.

Random Environment Models

Two-Stage Repairmen (examples/advanced/randomEnv/renv_twostages_repairmen.ipynb)

Two-stage random environment with repairmen model.

Three-Stage Repairmen (examples/advanced/randomEnv/renv_threestages_repairmen.ipynb)

Three-stage random environment with repairmen model.

Four-Stage Repairmen (examples/advanced/randomEnv/renv_fourstages_repairmen.ipynb)

Four-stage random environment with repairmen model.

Switchover Times

Basic Switchover (examples/advanced/switchoverTimes/switchover_basic.ipynb)

Queueing model with switchover times between service modes.

Reward Models

Reward-Based CTMC Analysis (examples/advanced/rewardModel/rewardModel_mm1k.ipynb)

Demonstrates custom reward functions for CTMC analysis using setReward, getReward, and getAvgReward methods.

Layered Cache-Queueing Models

Single Host (examples/advanced/layeredCQ/lcq_singlehost.ipynb)

Layered cache-queueing model with single host.

Three Hosts (examples/advanced/layeredCQ/lcq_threehosts.ipynb)

Layered cache-queueing model with three hosts.

Further Example Areas

Beyond the categories above, python/examples/ carries four top-level areas, each with a notebook per script:

discrete/

Discrete-time (slotted) models: Geo/Geo/1, its loss variant, and discrete-time cycles with load dependence.

inference/

Parameter estimation and demand inference: EKF, ERPS, MCMC, MLE, QMLE, trace-driven fitting, and the UBO/UBR estimator families.

opt/

Optimization over models: server and population sizing, load balancing, host-demand fitting, sensitivity reports and Pareto frontiers.

solvers/

Side-by-side solver comparisons (NC vs MVA vs CTMC vs SPN representations).

Notebooks Are Generated From the Scripts

Every .ipynb under python/examples/ is DERIVED from the .py beside it by python/tools/gen_notebooks.py; its code cells are the script’s own statements. Edit the .py and regenerate:

cd python
python3 tools/gen_notebooks.py            # rewrite every stale notebook
python3 tools/gen_notebooks.py --check    # report drift, write nothing

Hand-edits to a notebook are lost on the next regeneration, and the generator refuses any split that would change what the script runs.

Getting Started

For new users, we recommend starting with these examples in order:

  1. Basic M/M/1 - examples/gallery/gallery_mm1.ipynb

  2. Open Network - examples/basic/openQN/oqn_basic.ipynb

  3. Closed Network - examples/basic/closedQN/cqn_twoqueues_multi.ipynb

  4. Mixed Network - examples/basic/mixedQN/mqn_basic.ipynb

Example Code Pattern

Most examples follow this general pattern:

from line_solver import *
import numpy as np

# Enable verbose output
GlobalConstants.set_verbose(VerboseLevel.STD)

# Create model
model = Network('MyModel')

# Define nodes
source = Source(model, 'Source')
queue = Queue(model, 'Queue', SchedStrategy.FCFS)
sink = Sink(model, 'Sink')

# Define job classes and service processes
jobclass = OpenClass(model, 'Jobs')
source.set_arrival(jobclass, Exp(1.0))
queue.set_service(jobclass, Exp(2.0))

# Define routing
P = model.init_routing_matrix()
P.add_route(jobclass, source, queue, 1.0)
P.add_route(jobclass, queue, sink, 1.0)
model.link(P)

# Solve with preferred solver
solver = MVA(model)
avg_table = solver.avg_table()
print(avg_table)