Scenario Comparison Tutorial
Complete guide to comparing epidemic intervention strategies.
- What is Scenario Comparison?
- Available Scenarios
- Intervention Strategies
- Code Examples
- Visualizing Results
- Interpreting Metrics
- Real-World Applications
- Advanced Usage
- Common Pitfalls
Scenario comparison allows you to evaluate the effectiveness of different intervention strategies against a baseline (no intervention).
| Question | Answer |
|---|---|
| Is quarantine effective? | Compare with/without quarantine |
| Which strategy works better? | Compare quarantine vs vaccination |
| What if we combine strategies? | Test combined scenario |
| How much reduction? | Quantitative metrics |
Description: No control measures, disease spreads freely.
from sir_simulator.advanced_features.scenario_comparison import ScenarioComparator
comp = ScenarioComparator()
scenarios, metrics = comp.compare_all_scenarios(days=120)
baseline = scenarios['Baseline']Characteristics:
- Highest peak infections
- Earliest peak
- Largest total cases
Description: Reduce contact between people (social distancing, lockdowns).
quarantine = comp.quarantine_scenario(
days=150,
start_day=10, # Start quarantine day 10
end_day=80, # End quarantine day 80
reduction_factor=0.2 # 80% reduction in transmission
)Interventions included:
- School closures
- Work-from-home
- Lockdowns
- Travel restrictions
Description: Immunize susceptible population.
vaccination = comp.vaccination_scenario(
days=150,
start_day=5, # Start vaccination day 5
daily_vaccinations=15, # Vaccinate 15 people/day
vaccine_efficacy=0.9 # 90% effective
)Interventions included:
- Mass vaccination campaigns
- Priority groups (elderly, healthcare workers)
- Booster shots
Description: Both strategies implemented simultaneously.
combined = comp.combined_scenario(
days=150,
quarantine_start=10,
quarantine_end=80,
quarantine_reduction=0.2,
vaccination_start=5,
daily_vaccinations=12
)Benefits:
- Best of both worlds
- Often more effective than either alone
- Realistic for modern pandemics
| Parameter | Description | Typical Range |
|---|---|---|
start_day |
When quarantine begins | 5-20 days |
end_day |
When quarantine ends | 60-120 days |
reduction_factor |
Transmission reduction | 0.1-0.5 (10%-50%) |
| Parameter | Description | Typical Range |
|---|---|---|
start_day |
When vaccination starts | 1-30 days |
daily_vaccinations |
People vaccinated per day | 5-100 |
vaccine_efficacy |
How well vaccine works | 0.7-0.95 (70%-95%) |
| Strategy | Peak Reduction | Time to Eradication |
|---|---|---|
| Quarantine only | 60-80% | Slow |
| Vaccination only | 50-70% | Moderate |
| Combined | 80-95% | Fast |
from sir_simulator.advanced_features.scenario_comparison import ScenarioComparator
# Create comparator with custom parameters
comp = ScenarioComparator(
population=1000,
initial_infected=5,
beta=0.25, # Infection rate
gamma=0.1 # Recovery rate
)
# Run all scenarios
scenarios, metrics = comp.compare_all_scenarios(days=120)
# View results
print(metrics)Output:
scenario peak_infected peak_day reduction
0 Baseline 235 37 0.0%
1 Quarantine 21 10 90.9%
2 Vaccination 88 32 62.5%
3 Combined 20 10 91.2%
# Get specific scenario data
baseline_df = scenarios['Baseline']
quarantine_df = scenarios['Quarantine']
vaccination_df = scenarios['Vaccination']
combined_df = scenarios['Combined']
# Extract infected curve
baseline_infected = baseline_df['infected']
quarantine_infected = quarantine_df['infected']# Strong quarantine (90% reduction)
comp_strong = ScenarioComparator(population=1000, beta=0.25, gamma=0.1)
strong_quarantine = comp_strong.quarantine_scenario(
days=150,
start_day=7,
end_day=60,
reduction_factor=0.1 # 90% reduction
)
# Weak quarantine (30% reduction)
comp_weak = ScenarioComparator(population=1000, beta=0.25, gamma=0.1)
weak_quarantine = comp_weak.quarantine_scenario(
days=150,
start_day=15,
end_day=50,
reduction_factor=0.7 # 30% reduction
)import matplotlib.pyplot as plt
comp = ScenarioComparator(beta=0.25, gamma=0.1)
scenarios, metrics = comp.compare_all_scenarios(days=120)
# Colors and styles
colors = {
'Baseline': 'blue',
'Quarantine': 'green',
'Vaccination': 'orange',
'Combined': 'red'
}
plt.figure(figsize=(12, 6))
for name, df in scenarios.items():
plt.plot(df['day'], df['infected'],
label=f"{name} (Peak: {df['infected'].max():.0f})",
color=colors.get(name, 'gray'),
linewidth=2)
plt.xlabel('Day', fontsize=12)
plt.ylabel('Infected Population', fontsize=12)
plt.title('Epidemic Scenario Comparison', fontsize=14, fontweight='bold')
plt.legend(loc='upper right', fontsize=10)
plt.grid(True, alpha=0.3)
plt.axhline(y=0, color='black', linestyle='-', linewidth=0.5)
plt.tight_layout()
plt.show()import matplotlib.pyplot as plt
import numpy as np
comp = ScenarioComparator(beta=0.25, gamma=0.1)
scenarios, metrics = comp.compare_all_scenarios(days=120)
# Create bar chart
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))
# Peak infected bar chart
scenario_names = metrics['scenario'].values
peak_infected = metrics['peak_infected'].values
colors_bar = ['blue', 'green', 'orange', 'red']
bars1 = ax1.bar(scenario_names, peak_infected, color=colors_bar, edgecolor='black', linewidth=1.5)
ax1.set_ylabel('Peak Infected', fontsize=12)
ax1.set_title('Peak Infection by Scenario', fontsize=14, fontweight='bold')
ax1.grid(True, alpha=0.3, axis='y')
# Add value labels on bars
for bar, value in zip(bars1, peak_infected):
ax1.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 2,
str(value), ha='center', va='bottom', fontweight='bold')
# Reduction percentage bar chart
reductions = metrics['reduction'].str.rstrip('%').astype(float)
colors_bar = ['gray', 'green', 'orange', 'red']
bars2 = ax2.bar(scenario_names[1:], reductions[1:], color=colors_bar[1:], edgecolor='black', linewidth=1.5)
ax2.set_ylabel('Reduction (%)', fontsize=12)
ax2.set_title('Reduction vs Baseline', fontsize=14, fontweight='bold')
ax2.grid(True, alpha=0.3, axis='y')
# Add value labels on bars
for bar, value in zip(bars2, reductions[1:]):
ax2.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 1,
f"{value:.0f}%", ha='center', va='bottom', fontweight='bold')
plt.tight_layout()
plt.show()import numpy as np
import matplotlib.pyplot as plt
# Test different quarantine parameters
start_days = [5, 10, 15, 20, 30]
reduction_factors = [0.1, 0.2, 0.3, 0.4, 0.5]
results = np.zeros((len(start_days), len(reduction_factors)))
for i, start_day in enumerate(start_days):
for j, reduction in enumerate(reduction_factors):
comp = ScenarioComparator(beta=0.25, gamma=0.1)
quarantine = comp.quarantine_scenario(
days=150,
start_day=start_day,
end_day=80,
reduction_factor=reduction
)
baseline = comp.baseline_scenario(days=150)
# Calculate peak reduction
baseline_peak = baseline['infected'].max()
quarantine_peak = quarantine['infected'].max()
reduction_pct = (baseline_peak - quarantine_peak) / baseline_peak * 100
results[i, j] = reduction_pct
# Create heatmap
fig, ax = plt.subplots(figsize=(10, 8))
im = ax.imshow(results, cmap='RdYlGn', aspect='auto', vmin=0, vmax=100)
# Add labels
ax.set_xticks(np.arange(len(reduction_factors)))
ax.set_yticks(np.arange(len(start_days)))
ax.set_xticklabels([f"{r:.1f}" for r in reduction_factors])
ax.set_yticklabels(start_days)
ax.set_xlabel('Reduction Factor (lower = stricter)', fontsize=12)
ax.set_ylabel('Start Day', fontsize=12)
ax.set_title('Quarantine Effectiveness (% Peak Reduction)', fontsize=14, fontweight='bold')
# Add colorbar
plt.colorbar(im, ax=ax, label='Peak Reduction (%)')
# Add text annotations
for i in range(len(start_days)):
for j in range(len(reduction_factors)):
text = ax.text(j, i, f"{results[i, j]:.0f}%",
ha="center", va="center", color="black", fontsize=9, fontweight='bold')
plt.tight_layout()
plt.show()| Metric | Description | Interpretation |
|---|---|---|
peak_infected |
Maximum infected at once | Hospital capacity needed |
peak_day |
When peak occurs | When to prepare resources |
reduction |
% reduction vs baseline | Effectiveness of intervention |
metrics = pd.DataFrame({
'scenario': ['Baseline', 'Quarantine', 'Vaccination', 'Combined'],
'peak_infected': [235, 21, 88, 20],
'peak_day': [37, 10, 32, 10],
'reduction': ['0.0%', '90.9%', '62.5%', '91.2%']
})
print(metrics)What this tells us:
- Baseline would overwhelm hospitals (235 patients)
- Quarantine reduces peak by 91% (only 21 patients)
- Vaccination reduces by 63% (88 patients)
- Combined is most effective (20 patients, 91% reduction)
| Country | Strategy | Peak Reduction | Outcome |
|---|---|---|---|
| New Zealand | Strict quarantine | 95% | Very low cases |
| South Korea | Testing + tracing | 80% | Controlled outbreak |
| Sweden | No lockdown | 0% (baseline) | High cases |
# Test different vaccination strategies
comp = ScenarioComparator(beta=0.3, gamma=0.1)
# Strategy A: Vaccinate 50 people/day starting day 1
vaccine_A = comp.vaccination_scenario(
start_day=1,
daily_vaccinations=50,
vaccine_efficacy=0.9
)
# Strategy B: Vaccinate 100 people/day starting day 10
vaccine_B = comp.vaccination_scenario(
start_day=10,
daily_vaccinations=100,
vaccine_efficacy=0.9
)
# Compare peaks
peak_A = vaccine_A['infected'].max()
peak_B = vaccine_B['infected'].max()
print(f"Strategy A peak: {peak_A:.0f}")
print(f"Strategy B peak: {peak_B:.0f}")def cost_benefit_analysis(scenario_df, baseline_df, cost_per_day, cost_per_vaccine=0):
"""
Calculate cost and benefit of intervention
"""
# Calculate deaths (assuming 1% mortality)
baseline_deaths = baseline_df['infected'].sum() * 0.01
scenario_deaths = scenario_df['infected'].sum() * 0.01
lives_saved = baseline_deaths - scenario_deaths
# Calculate cost (example)
intervention_days = len(scenario_df) # Simplified
total_cost = intervention_days * cost_per_day + cost_per_vaccine
# Cost per life saved
cost_per_life = total_cost / lives_saved if lives_saved > 0 else float('inf')
return {
'lives_saved': lives_saved,
'total_cost': total_cost,
'cost_per_life_saved': cost_per_life
}
comp = ScenarioComparator(beta=0.25, gamma=0.1)
baseline = comp.baseline_scenario(days=150)
quarantine = comp.quarantine_scenario(days=150, start_day=10, end_day=80, reduction_factor=0.2)
analysis = cost_benefit_analysis(quarantine, baseline, cost_per_day=1e6, cost_per_vaccine=0)
print(f"Lives saved: {analysis['lives_saved']:.0f}")
print(f"Cost per life saved: ${analysis['cost_per_life_saved']:,.0f}")def parameter_sweep(beta_values, gamma_values):
"""Analyze many parameter combinations"""
results = []
for beta in beta_values:
for gamma in gamma_values:
comp = ScenarioComparator(beta=beta, gamma=gamma)
scenarios, metrics = comp.compare_all_scenarios(days=120)
baseline_peak = metrics[metrics['scenario'] == 'Baseline']['peak_infected'].values[0]
quarantine_peak = metrics[metrics['scenario'] == 'Quarantine']['peak_infected'].values[0]
reduction = (baseline_peak - quarantine_peak) / baseline_peak * 100
results.append({
'beta': beta,
'gamma': gamma,
'R0': beta / gamma,
'baseline_peak': baseline_peak,
'quarantine_peak': quarantine_peak,
'reduction_pct': reduction
})
return pd.DataFrame(results)
# Run sweep
beta_range = [0.2, 0.3, 0.4, 0.5]
gamma_range = [0.05, 0.1, 0.15, 0.2]
results_df = parameter_sweep(beta_range, gamma_range)
print(results_df.head(10))# Too late - outbreak already peaked
comp.quarantine_scenario(start_day=40) # Peak at day 37, too late
# Optimal - before peak
comp.quarantine_scenario(start_day=10) # Before peak, effective# Too early - outbreak rebounds
comp.quarantine_scenario(end_day=30) # Rebound after lifting
# Proper - after outbreak controlled
comp.quarantine_scenario(end_day=80) # No rebound# Unrealistic - can't vaccinate that fast
comp.vaccination_scenario(daily_vacccinations=1000, population=10000)
# Realistic
comp.vaccination_scenario(daily_vaccinations=50, population=10000)| Concept | Summary |
|---|---|
| Scenarios | Baseline, Quarantine, Vaccination, Combined |
| Key Metrics | Peak infected, Peak day, Reduction % |
| Quarantine | Reduces transmission, best if early |
| Vaccination | Builds immunity, requires time |
| Combined | Most effective strategy |
- API Reference - Complete function documentation
- FAQ - Common questions and answers
