def time_evolution_optimistic_scenario_example():
"""
Example in which the sensitivities s^S and s^C are high for who uses the app, and the app is used by 60% of the
population.
"""
# gs = [asymptomatic, symptomatic]
n_iterations = 8
p_gs, beta0_gs = make_scenario_parameters_for_asymptomatic_symptomatic_model(
)
scenario = Scenario(
p_gs=p_gs,
beta0_gs=beta0_gs,
t_0=0,
ssapp=[0, 0.8],
ssnoapp=[0, 0.2],
scapp=0.8,
scnoapp=0.2,
xi=0.9,
papp=lambda t: 0.6,
p_DeltaATapp=DeltaMeasure(position=2),
p_DeltaATnoapp=DeltaMeasure(position=4),
)
step_data_list = compute_time_evolution(
scenario=scenario,
real_range=RealRange(0, tau_max, integration_step),
n_iterations=n_iterations,
verbose=True,
)
plot_time_evolution(step_data_list=step_data_list)
def dependency_on_share_of_symptomatics_homogeneous_model_example():
"""
Example of several computations of the limit Eff_∞ in homogeneous scenarios (i.e. with no app usage)
in which the fraction p_sym of symptomatic individuals and their contribution to R^0 vary.
"""
p_sym_list = [0.3, 0.4, 0.5, 0.6, 0.7]
x_axis_list = []
Effinfty_values_list = []
for p_sym in p_sym_list:
contribution_of_symptomatics_to_R0 = 1 - math.exp(
-4.993 * p_sym
) # Random choice, gives 0.95 when p_sym = 0.6
R0_sym = contribution_of_symptomatics_to_R0 / p_sym * R0
R0_asy = (1 - contribution_of_symptomatics_to_R0) / (1 - p_sym) * R0
# gs = [asymptomatic, symptomatic]
p_gs, beta0_gs = make_scenario_parameters_for_asymptomatic_symptomatic_model(
p_sym=p_sym,
contribution_of_symptomatics_to_R0=contribution_of_symptomatics_to_R0,
)
n_iterations = 6
scenario = make_homogeneous_scenario(
p_gs=p_gs,
beta0_gs=beta0_gs,
t_0=0,
ss=[0, 0.5],
sc=0.7,
xi=0.9,
p_DeltaAT=DeltaMeasure(position=2),
)
step_data_list = compute_time_evolution(
scenario=scenario,
real_range=RealRange(0, tau_max, integration_step),
n_iterations=n_iterations,
verbose=False,
)
Rinfty = step_data_list[-1].R
Effinfty = effectiveness_from_R(Rinfty)
x_axis_list.append(
f"p_sym = {p_sym},\nκ={round(contribution_of_symptomatics_to_R0, 2)},\nR^0_sym={round(R0_sym, 2)},\nR^0_asy={round(R0_asy, 2)}"
)
Effinfty_values_list.append(Effinfty)
plt.xticks(p_sym_list, x_axis_list, rotation=0)
plt.xlim(0, p_sym_list[-1])
plt.ylim(0, 0.8)
plt.ylabel("Eff_∞")
plt.grid(True)
plt.plot(p_sym_list, Effinfty_values_list, color="black",),
plt.show()
def time_evolution_with_varying_parameters():
"""
Run the algorithm several times, each with a different choice of the parameters s^S, s^C, xi, and p^app.
"""
tau_max = 30
integration_step = 0.1
n_iterations = 8
# gs = [asymptomatic, symptomatic]
p_gs, beta0_gs = make_scenario_parameters_for_asymptomatic_symptomatic_model(
)
ssnoapp = 0.2
scnoapp = 0.2
DeltaATapp = 2
DeltaATnoapp = 4
# Varying parameters
ssapp_list = [0.2, 0.5, 0.8]
scapp_list = [0.5, 0.8]
xi_list = [0.7, 0.9]
papp_list = [0.2, 0.5, 0.7, 0.9]
for ssapp in ssapp_list:
for scapp in scapp_list:
for xi in xi_list:
for papp in papp_list:
scenario = Scenario(
p_gs=p_gs,
beta0_gs=beta0_gs,
t_0=0,
ssapp=[0, ssapp],
ssnoapp=[0, ssnoapp],
scapp=scapp,
scnoapp=scnoapp,
xi=xi,
papp=lambda tau: papp,
p_DeltaATapp=DeltaMeasure(position=DeltaATapp),
p_DeltaATnoapp=DeltaMeasure(position=DeltaATnoapp),
)
step_data_list = compute_time_evolution(
scenario=scenario,
real_range=RealRange(0, tau_max, integration_step),
n_iterations=n_iterations,
verbose=False,
)
Rinfty = step_data_list[-1].R
Effinfty = effectiveness_from_R(Rinfty)
print(
f" {ssapp} & {scapp} & {xi} & {papp} & {round2(Rinfty)} & {round2(Effinfty)} \\\ "
)
def test_R_suppression(self):
_, beta0_gs = make_scenario_parameters_for_asymptomatic_symptomatic_model()
beta0_ti_gs = [lambda tau: beta0_gs[0](0, tau), lambda tau: beta0_gs[1](0, tau)]
xi = 0.8 # Any value in [0,1] will do
tau_max = 30
FTapp_ti_gs = [
lambda tau: 0,
lambda tau: 1 if tau >= 10 else 0,
]
FTnoapp_ti_gs = [
lambda tau: 0,
lambda tau: 1 if tau >= 20 else 0,
]
(
betaapp_ti_gs,
betanoapp_ti_gs,
Rapp_ti_gs,
Rnoapp_ti_gs,
) = compute_beta_and_R_components_from_FT(
FTapp_ti_gs=FTapp_ti_gs,
FTnoapp_ti_gs=FTnoapp_ti_gs,
beta0_ti_gs=beta0_ti_gs,
xi=xi,
tau_max=tau_max,
)
R0_gs = [integrate(f=beta0_ti_gs[g], a=0, b=tau_max) for g in [0, 1]]
# No suppression for asymptomatic:
assert all(
beta0_ti_gs[0](tau) == betaapp_ti_gs[0](tau) == betanoapp_ti_gs[0](tau)
for tau in (0, 3, 6, 9, 12, 15)
)
assert Rapp_ti_gs[0] == Rnoapp_ti_gs[0] == R0_gs[0]
# For symptomatic with app, suppression for tau >= 10
assert all(beta0_ti_gs[1](tau) == betaapp_ti_gs[1](tau) for tau in (0, 3, 6, 9))
assert all(
betaapp_ti_gs[1](tau) == (1 - xi) * beta0_ti_gs[1](tau)
for tau in (10, 13, 16, 19)
)
assert (1 - xi) * R0_gs[1] <= Rapp_ti_gs[1] <= R0_gs[1]
# For symptomatic without app, suppression for tau >= 20
assert all(
beta0_ti_gs[1](tau) == betanoapp_ti_gs[1](tau)
for tau in (0, 3, 6, 9, 12, 15, 18)
)
assert all(
betanoapp_ti_gs[1](tau) == (1 - xi) * beta0_ti_gs[1](tau)
for tau in (20, 25)
)
assert (1 - xi) * R0_gs[1] <= Rnoapp_ti_gs[1] <= R0_gs[1]
def dependency_on_app_adoption_example():
"""
Example of several computations of the limit Eff_∞ with app usage, where the fraction p^app of app adopters varies.
"""
n_iterations = 8
# gs = [asymptomatic, symptomatic]
p_gs, beta0_gs = make_scenario_parameters_for_asymptomatic_symptomatic_model()
papp_list = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
Effinfty_values_list = []
for papp in papp_list:
scenario = Scenario(
p_gs=p_gs,
beta0_gs=beta0_gs,
t_0=0,
ssapp=[0, 0.5],
ssnoapp=[0, 0.2],
scapp=0.7,
scnoapp=0.2,
xi=0.9,
papp=lambda t: papp,
p_DeltaATapp=DeltaMeasure(position=2),
p_DeltaATnoapp=DeltaMeasure(position=4),
)
step_data_list = compute_time_evolution(
scenario=scenario,
real_range=RealRange(0, tau_max, integration_step),
n_iterations=n_iterations,
verbose=False,
)
Rinfty = step_data_list[-1].R
Effinfty = effectiveness_from_R(Rinfty)
Effinfty_values_list.append(Effinfty)
fig = plt.figure(figsize=(10, 15))
Rinfty_plot = fig.add_subplot(111)
Rinfty_plot.set_xlabel("p^app")
Rinfty_plot.set_ylabel("Eff_∞")
Rinfty_plot.grid(True)
Rinfty_plot.set_xlim(0, 1)
Rinfty_plot.set_ylim(0, 1)
Rinfty_plot.plot(papp_list, Effinfty_values_list, color="black",),
plt.show()
def dependency_on_testing_timeliness_homogeneous_model_example():
"""
Example of several computations of the limit Eff_∞ in homogeneous scenarios (i.e. with no app usage)
in which the time interval Δ^{A → T} varies from 0 to 10 days.
"""
n_iterations = 8
# gs = [asymptomatic, symptomatic]
p_gs, beta0_gs = make_scenario_parameters_for_asymptomatic_symptomatic_model()
DeltaAT_values_list = list(range(0, 10))
Effinfty_values_list = []
for DeltaAT in DeltaAT_values_list:
scenario = make_homogeneous_scenario(
p_gs=p_gs,
beta0_gs=beta0_gs,
t_0=0,
ss=[0, 0.5],
sc=0.7,
xi=0.9,
p_DeltaAT=DeltaMeasure(position=DeltaAT),
)
step_data_list = compute_time_evolution(
scenario=scenario,
real_range=RealRange(0, tau_max, integration_step),
n_iterations=n_iterations,
verbose=False,
)
Rinfty = step_data_list[-1].R
Effinfty = effectiveness_from_R(Rinfty)
Effinfty_values_list.append(Effinfty)
fig = plt.figure(figsize=(10, 15))
Rinfty_plot = fig.add_subplot(111)
Rinfty_plot.set_xlabel("Δ^{A → T} (days)")
Rinfty_plot.set_ylabel("Eff_∞")
Rinfty_plot.grid(True)
Rinfty_plot.set_xlim(0, DeltaAT_values_list[-1])
Rinfty_plot.set_ylim(0, 0.6)
Rinfty_plot.plot(DeltaAT_values_list, Effinfty_values_list, color="black",),
plt.show()
def time_evolution_gradual_app_adoption_example():
"""
Example in which the share of people using the app linearly increases, until reaching 60% in 30 days.
"""
# gs = [asymptomatic, symptomatic]
n_iterations = 16
p_gs, beta0_gs = make_scenario_parameters_for_asymptomatic_symptomatic_model(
)
def papp(t: float) -> float:
papp_infty = 0.6
t_saturation = 30
if 0 <= t < t_saturation:
return papp_infty * t / t_saturation
elif t >= t_saturation:
return papp_infty
scenario = Scenario(
p_gs=p_gs,
beta0_gs=beta0_gs,
t_0=0,
ssapp=[0, 0.8],
ssnoapp=[0, 0.2],
scapp=0.8,
scnoapp=0.2,
xi=0.9,
papp=papp,
p_DeltaATapp=DeltaMeasure(position=2),
p_DeltaATnoapp=DeltaMeasure(position=4),
)
step_data_list = compute_time_evolution(
scenario=scenario,
real_range=RealRange(0, tau_max, integration_step),
n_iterations=n_iterations,
verbose=True,
)
plot_time_evolution(step_data_list=step_data_list)
def time_evolution_homogeneous_model_optimistic_scenario_example():
"""
Example in which there is no app usage, and the sensitivities s^S and s^C are quite high
"""
# gs = [asymptomatic, symptomatic]
n_iterations = 8
p_gs, beta0_gs = make_scenario_parameters_for_asymptomatic_symptomatic_model(
)
ss = [0, 0.5]
sc = 0.7
xi = 0.9
DeltaAT = 2
scenario = Scenario(
p_gs=p_gs,
beta0_gs=beta0_gs,
t_0=0,
ssapp=[0, 0],
ssnoapp=ss,
scapp=0,
scnoapp=sc,
xi=xi,
papp=lambda tau: 0,
p_DeltaATapp=DeltaMeasure(position=0),
p_DeltaATnoapp=DeltaMeasure(position=DeltaAT),
)
step_data_list = compute_time_evolution(
scenario=scenario,
real_range=RealRange(0, tau_max, integration_step),
n_iterations=n_iterations,
verbose=True,
)
plot_time_evolution(step_data_list=step_data_list, plot_components=False)
def test_only_symptoms_control(self):
tau_max = 30
integration_step = 0.1
# gs = [asymptomatic, symptomatic]:
p_gs, beta0_gs = make_scenario_parameters_for_asymptomatic_symptomatic_model(
)
scenario = Scenario(
p_gs=p_gs,
beta0_gs=beta0_gs,
t_0=0,
ssapp=[0, 0.7],
ssnoapp=[0, 0.5],
scapp=0,
scnoapp=0,
xi=1,
papp=lambda tau: 0,
p_DeltaATapp=DeltaMeasure(position=1),
p_DeltaATnoapp=DeltaMeasure(position=2),
)
step_data_list = compute_time_evolution(
scenario=scenario,
real_range=RealRange(0, tau_max, integration_step),
n_iterations=4,
verbose=False,
)
precision = 3
first_step_data = step_data_list[0]
last_step_data = step_data_list[-1]
assert check_equality_with_precision(x=first_step_data.R,
y=last_step_data.R,
decimal=precision)
def dependency_on_efficiencies_example():
"""
Example of several computations of the limit Eff_∞ with app usage, where the parameters s^{s,app} and s^{c,app}
vary.
"""
n_iterations = 8
# gs = [asymptomatic, symptomatic]
p_gs, beta0_gs = make_scenario_parameters_for_asymptomatic_symptomatic_model()
ssapp_list = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]
scapp_list = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]
Effinfty_values_list = []
for scapp in scapp_list:
Effinfty_values_list_for_scapp = []
for ssapp in ssapp_list:
scenario = Scenario(
p_gs=p_gs,
beta0_gs=beta0_gs,
t_0=0,
ssapp=[0, ssapp],
ssnoapp=[0, 0.2],
scapp=scapp,
scnoapp=0.2,
xi=0.9,
papp=lambda t: 0.6,
p_DeltaATapp=DeltaMeasure(position=2),
p_DeltaATnoapp=DeltaMeasure(position=4),
)
step_data_list = compute_time_evolution(
scenario=scenario,
real_range=RealRange(0, tau_max, integration_step),
n_iterations=n_iterations,
verbose=False,
)
Rinfty = step_data_list[-1].R
Effinfty = effectiveness_from_R(Rinfty)
print(
f"s^{{s,app}} = {ssapp}, s^{{c,app}} = {scapp}, Eff_∞ = {round(Effinfty, 2)}"
)
Effinfty_values_list_for_scapp.append(Effinfty)
Effinfty_values_list.append(Effinfty_values_list_for_scapp)
ssapp_values_array, scapp_values_array = np.meshgrid(ssapp_list, scapp_list)
fig = plt.figure(figsize=(10, 15))
ax = fig.gca(projection="3d")
ax.plot_surface(
ssapp_values_array, scapp_values_array, np.array(Effinfty_values_list),
)
ax.set_xlabel("s^{s,app}")
ax.set_ylabel("s^{c,app}")
ax.set_zlabel("Eff_∞")
plt.show()
def dependency_on_infectiousness_width_homogeneous_model_example():
"""
Example of several computations of the limit Eff_∞ in homogeneous scenarios (i.e. with no app usage)
in which the default distribution ρ^0 of the generation time is rescaled by different factors.
"""
infectiousness_rescale_factors = [0.6, 0.8, 1, 1.2, 1.4, 1.6, 1.8]
expected_default_generation_times_list = []
Effinfty_values_list = []
for f in infectiousness_rescale_factors:
def rescaled_rho0(tau):
return (1 / f) * rho0(tau / f)
assert round(integrate(rescaled_rho0, 0, tau_max), 5) == 1
EtauC0 = integrate(
lambda tau: tau * rescaled_rho0(tau), 0, tau_max
) # Expected default generation time
expected_default_generation_times_list.append(EtauC0)
# gs = [asymptomatic, symptomatic]
p_gs, beta0_gs = make_scenario_parameters_for_asymptomatic_symptomatic_model(
rho0=rescaled_rho0
)
n_iterations = 6
scenario = make_homogeneous_scenario(
p_gs=p_gs,
beta0_gs=beta0_gs,
t_0=0,
ss=[0, 0.5],
sc=0.7,
xi=0.9,
p_DeltaAT=DeltaMeasure(position=2),
)
step_data_list = compute_time_evolution(
scenario=scenario,
real_range=RealRange(0, tau_max, integration_step),
n_iterations=n_iterations,
verbose=False,
)
Rinfty = step_data_list[-1].R
Effinfty = effectiveness_from_R(Rinfty)
Effinfty_values_list.append(Effinfty)
plt.ylim(0, 0.8)
plt.grid(True)
plt.plot(
expected_default_generation_times_list, Effinfty_values_list, color="black",
),
plt.xlabel("E(τ^{0,C})")
plt.ylabel("Eff_∞")
plt.title(
"Effectiveness under rescaling of the default generation time distribution"
)
plt.show()