Event-path plots, step plots, distributions and tables

A stochastic result can be technically correct but communicated badly. This lesson matches each biological question to a suitable display and explains what the display does—and does not—show.

Four displays answer four different questions

Event timeline

Question: Which event occurred, and when?

Plot one marker per infection or recovery event at its exact continuous time.

State step plot

Question: How did compartment counts change through one epidemic?

Keep the state constant between irregular jump times.

Multiple sample paths

Question: How different can trajectories be?

Show a manageable subset with transparency, not hundreds of opaque lines.

Outcome distribution

Question: How frequently did different final results occur?

Use all independent runs in a histogram, empirical distribution or probability table.

The fundamental CTMC plotting rule

Use a step plot for compartment states. A CTMC state jumps at an event and remains constant until the next event. Connecting states with sloping lines falsely suggests that fractional people change continuously between events.

\[X(t)=X(t_k)\quad\text{for }t_k\le t<t_{k+1}.\]

In Matplotlib, plt.step(..., where="post") implements this right-continuous display.

Tables preserve exact values

Plots reveal patterns; tables provide exact numbers. A useful event table has one row per jump and includes event time, waiting time, event type and post-event state. A useful outcome table has one row per independent trajectory.

Table	Rows represent	Typical columns
Event log	Events in one trajectory	Time, waiting time, event, \(S,I,R\)
Outcome data	Independent trajectories	Final size, duration, peak, peak time
Summary table	Outcome measures	Median, 5th and 95th percentiles

Interactive Python laboratory

Run the code to create one coherent four-panel report: the event timeline and step path come from one selected epidemic, while the sample-path and distribution panels use many independent epidemics. Exact supporting tables are printed below the code.

Interactive PythonCTMC visual and tabular report

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

def simulate_sir(rng, N, I0, beta, gamma):
    S, I, R = N - I0, I0, 0
    time = 0.0

times = [time]
    I_values = [I]
    events = []
    peak_I = I
    peak_time = 0.0

while I > 0:
        infection_rate = beta * S * I / N
        recovery_rate = gamma * I
        total_rate = infection_rate + recovery_rate

waiting_time = rng.exponential(1 / total_rate)
        time += waiting_time

if rng.random() < infection_rate / total_rate:
            S -= 1
            I += 1
            event = "infection"
        else:
            I -= 1
            R += 1
            event = "recovery"

if I > peak_I:
            peak_I = I
            peak_time = time

times.append(time)
        I_values.append(I)
        events.append({
            "time": time,
            "waiting time": waiting_time,
            "event": event,
            "S": S,
            "I": I,
            "R": R
        })

outcome = {
        "final size": N - S,
        "duration": time,
        "peak I": peak_I,
        "peak time": peak_time
    }

return (
        np.array(times),
        np.array(I_values),
        pd.DataFrame(events),
        outcome
    )

# Model and reporting settings
N = 200
I0 = 3
beta = 0.25
gamma = 0.10
number_of_runs = 300
seed = 120
rng = np.random.default_rng(seed)

all_paths = []
outcome_rows = []
selected_event_log = None

for run in range(number_of_runs):
    times, I_values, event_log, outcome = simulate_sir(
        rng, N, I0, beta, gamma
    )

outcome["run"] = run + 1
    outcome_rows.append(outcome)

# Retain only a readable subset of paths for plotting
    if run < 20:
        all_paths.append((times, I_values))

if run == 0:
        selected_times = times
        selected_I = I_values
        selected_event_log = event_log

outcomes = pd.DataFrame(outcome_rows)

summary_table = outcomes[
    ["final size", "duration", "peak I", "peak time"]
].quantile([0.05, 0.50, 0.95])
summary_table.index = [
    "5th percentile", "median", "95th percentile"
]

print("First trajectory: first 12 events")
print(
    selected_event_log.head(12)
    .round(4)
    .to_string(index=False)
)
print()
print("Outcome summary across 300 trajectories")
print(summary_table.round(3).to_string())

# Create a unified four-panel report
fig, axes = plt.subplots(2, 2, figsize=(11, 8.2))

# A. Exact event timeline for one trajectory
event_y = selected_event_log["event"].map({
    "recovery": 0,
    "infection": 1
})
event_colours = selected_event_log["event"].map({
    "recovery": "#39815e",
    "infection": "#b42318"
})
axes[0, 0].scatter(
    selected_event_log["time"], event_y,
    c=event_colours, s=13, alpha=0.7
)
axes[0, 0].set_yticks([0, 1], ["Recovery", "Infection"])
axes[0, 0].set_xlabel("Continuous time (days)")
axes[0, 0].set_title("A. Event timeline: one epidemic")
axes[0, 0].grid(axis="x", alpha=0.2)

# B. Correct piecewise-constant state path
axes[0, 1].step(
    selected_times, selected_I, where="post",
    color="#b42318", linewidth=1.7
)
axes[0, 1].set_xlabel("Continuous time (days)")
axes[0, 1].set_ylabel("Infectious people")
axes[0, 1].set_title("B. Step path: one epidemic")
axes[0, 1].grid(alpha=0.2)

# C. A readable subset of independent paths
for times, I_values in all_paths:
    axes[1, 0].step(
        times, I_values, where="post",
        alpha=0.35, linewidth=0.9
    )
axes[1, 0].set_xlabel("Continuous time (days)")
axes[1, 0].set_ylabel("Infectious people")
axes[1, 0].set_title("C. Twenty independent sample paths")
axes[1, 0].grid(alpha=0.2)

# D. Distribution uses all simulated trajectories
axes[1, 1].hist(
    outcomes["final size"], bins=25,
    color="#79ae90", edgecolor="white"
)
axes[1, 1].axvline(
    outcomes["final size"].median(),
    color="#174c34", linestyle="--",
    label="Median"
)
axes[1, 1].set_xlabel("Final outbreak size")
axes[1, 1].set_ylabel("Number of trajectories")
axes[1, 1].set_title("D. Distribution across all 300 runs")
axes[1, 1].legend()
axes[1, 1].grid(axis="y", alpha=0.2)

fig.suptitle("CTMC SIR: paths, events and outcome distribution")
fig.tight_layout()

Output

Run the code to see the result.

How to read the four panels

Panel A: event density is high when the total rate is high. The vertical position labels event type; it is not a numerical magnitude.
Panel B: every vertical jump changes \(I\) by exactly one, while horizontal segments show no change between events.
Panel C: variation in peak, timing and extinction is visible, but twenty displayed paths are illustrative rather than a probability estimate.
Panel D: all 300 outcomes contribute. Separate clusters can reveal early fade-outs and major epidemics.

Match the display to the claim

Claim	Suitable evidence	Unsuitable evidence alone
Events occur at irregular times	Event timeline or one step path	Outcome histogram
Trajectories vary substantially	Multiple paths plus ensemble summaries	One selected path
Large outbreaks occur with a given frequency	Count/proportion from all independent runs	Spaghetti plot
Median final size has a stated value	Outcome table and marked distribution	Event log from one run

Presentation checks

State the number of independent trajectories and the random seed.
Label whether intervals describe outcomes or Monte Carlo uncertainty.
Include units on time axes and identify the population quantity.
Do not hide early extinctions by displaying only large outbreaks.
Do not use excessive decimal places for inherently noisy estimates.
Place biological interpretation beside the display, not only code.

Biological interpretation

The selected path explains event order, but it cannot establish what is common. The ensemble shows that identical parameters can generate different epidemic histories. The distribution and summary table quantify that variability and support statements about population burden.

Good communication keeps three levels distinct: an event, one trajectory, and a distribution across trajectories.

CTMC section completion

You can now define CTMC event rates, generate exponential waiting times, select and update events, program SIS/SIR/SEIR models, construct a generator, simulate ensembles, estimate probabilities, calculate outbreak outcomes, and communicate results with appropriate plots and tables.