def test__housemates_of_asymptomatic_are_free(self, setup_policy_world,
selector):
world, pupil, student, worker, sim = setup_policy_world
super_area = world.super_areas[0]
quarantine = Quarantine(
start_time="2020-1-1",
end_time="2020-1-30",
n_days=7,
n_days_household=14,
)
policies = Policies([quarantine])
sim.activity_manager.policies = policies
infect_person(worker, selector, "asymptomatic")
sim.update_health_status(0.0, 0.0)
activities = ["primary_activity", "residence"]
sim.clear_world()
time_during_policy = datetime(2020, 1, 2)
# after symptoms onset
individual_policies = IndividualPolicies.get_active_policies(
policies, date=time_during_policy)
assert "primary_activity" in individual_policies.apply(
person=pupil, activities=activities, days_from_start=8.0)
assert "primary_activity" in individual_policies.apply(
person=pupil, activities=activities, days_from_start=25.0)
worker.health_information = None
sim.clear_world()
def test__quarantine_zero_complacency(self, setup_policy_world, selector):
world, pupil, student, worker, sim = setup_policy_world
super_area = world.super_areas[0]
quarantine = Quarantine(
start_time="2020-1-1",
end_time="2020-1-30",
n_days=7,
n_days_household=14,
household_compliance=0.0,
)
policies = Policies([quarantine])
sim.activity_manager.policies = policies
infect_person(worker, selector, "mild")
sim.update_health_status(0.0, 0.0)
activities = ["primary_activity", "residence"]
sim.clear_world()
time_during_policy = datetime(2020, 1, 2)
individual_policies = IndividualPolicies.get_active_policies(
policies, date=time_during_policy)
# before symptoms onset
assert "primary_activity" in individual_policies.apply(
person=pupil, activities=activities, days_from_start=4.0)
# after symptoms onset
assert "primary_activity" in individual_policies.apply(
person=pupil, activities=activities, days_from_start=8.0)
# more thatn two weeks after symptoms onset
assert "primary_activity" in individual_policies.apply(
person=pupil, activities=activities, days_from_start=25)
worker.health_information = None
sim.clear_world()
def test__full_run(dummy_world, selector):
world = dummy_world
# restore health status of people
for person in world.people:
person.health_information = None
person.susceptibility = 1.0
person.dead = False
leisure_instance = leisure.generate_leisure_for_world(
world=world,
list_of_leisure_groups=[
"pubs",
"cinemas",
"groceries",
"household_visits",
"care_home_visits",
],
)
leisure_instance.distribute_social_venues_to_households(world.households)
interaction = Interaction.from_file()
policies = Policies.from_file()
sim = Simulator.from_file(
world=world,
interaction=interaction,
infection_selector=selector,
config_filename=test_config,
leisure=leisure_instance,
policies=policies,
save_path=None,
)
seed = InfectionSeed(sim.world.super_areas, selector)
seed.unleash_virus(1)
sim.run()
def test__housemates_stay_for_two_weeks(self, setup_policy_world,
selector):
world, pupil, student, worker, sim = setup_policy_world
super_area = world.super_areas[0]
quarantine = Quarantine(
start_time="2020-1-1",
end_time="2020-1-30",
n_days=7,
n_days_household=14,
)
policies = Policies([quarantine])
sim.activity_manager.policies = policies
infect_person(worker, selector, "mild")
sim.update_health_status(0.0, 0.0)
activities = ["primary_activity", "residence"]
sim.clear_world()
time_during_policy = datetime(2020, 1, 2)
# before symptoms onset
individual_policies = IndividualPolicies.get_active_policies(
policies, date=time_during_policy)
assert "primary_activity" not in individual_policies.apply(
person=pupil, activities=activities, days_from_start=8.0)
# after symptoms onset
sim.activity_manager.move_people_to_active_subgroups(
activities, time_during_policy, 8.0)
assert pupil in pupil.residence.people
# more thatn two weeks after symptoms onset
assert "primary_activity" in individual_policies.apply(
person=pupil, activities=activities, days_from_start=25)
worker.health_information = None
sim.clear_world()
sim.activity_manager.move_people_to_active_subgroups(
activities, time_during_policy, 25)
assert pupil in pupil.primary_activity.people
sim.clear_world()
def make_dummy_activity_manager(world):
timer = Timer(
total_days=10,
weekday_step_duration=[8, 8, 8],
weekend_step_duration=[8, 8, 8],
weekday_activities=[
["primary_activity", "residence"],
["primary_activity", "residence"],
],
weekend_activities=[
["primary_activity", "residence"],
["primary_activity", "residence"],
],
)
activity_manager = CampActivityManager(
world=world,
policies=Policies.from_file(),
timer=timer,
all_activities=["primary_activity", "residence"],
activity_to_super_groups={
"primary_activity": ["learning_centers"],
"residence": ["households"],
},
)
return activity_manager
def test__infection_is_isolated(selector):
geography = Geography.from_file({"area": ["E00002559"]})
world = generate_world_from_geography(geography, include_households=True)
interaction = Interaction.from_file()
infection_seed = InfectionSeed(world.super_areas, selector)
n_cases = 5
infection_seed.unleash_virus(
n_cases) # play around with the initial number of cases
policies = Policies([])
simulator = Simulator.from_file(
world=world,
interaction=interaction,
infection_selector=selector,
config_filename=pathlib.Path(__file__).parent.absolute() /
"interaction_test_config.yaml",
leisure=None,
policies=policies,
save_path=None,
)
infected_people = [person for person in world.people if person.infected]
assert len(infected_people) == 5
infected_households = []
for household in world.households:
infected = False
for person in household.people:
if person.infected:
infected = True
break
if infected:
infected_households.append(household)
assert len(infected_households) <= 5
simulator.run()
for person in world.people:
if not (person.residence.group in infected_households):
assert not person.infected and person.susceptible
def test__hospitalise_the_sick(setup_policy_world, selector):
world, pupil, student, worker, sim = setup_policy_world
hospitalisation = Hospitalisation()
policies = Policies([hospitalisation])
sim.activity_manager.policies = policies
selector.infect_person_at_time(worker, 0.0)
worker.health_information.infection.symptoms.tag = SymptomTag.hospitalised
assert worker.health_information.should_be_in_hospital
sim.update_health_status(0.0, 0.0)
assert worker.medical_facility is not None
sim.activity_manager.move_people_to_active_subgroups(
["medical_facility", "residence"])
assert worker in worker.medical_facility.people
sim.clear_world()
def test__kid_at_home_is_supervised(setup_policy_world, selector):
world, pupil, student, worker, sim = setup_policy_world
policies = Policies([SevereSymptomsStayHome()])
sim.activity_manager.policies = policies
assert pupil.primary_activity is not None
infect_person(pupil, selector, "severe")
assert pupil.health_information.tag == SymptomTag.severe
sim.activity_manager.move_people_to_active_subgroups(
["primary_activity", "residence"])
assert pupil in pupil.residence.people
guardians_at_home = [
person for person in pupil.residence.group.people if person.age >= 18
]
assert len(guardians_at_home) != 0
sim.clear_world()
def test__checkpoints_are_saved(selector):
june.simulator.logger.disabled = True
sim = run_simulator(selector)
fresh_world = generate_world_from_hdf5("./checkpoint_world.hdf5")
interaction = Interaction.from_file()
policies = Policies([])
sim_recovered = Simulator.from_checkpoint(
world=fresh_world,
checkpoint_path="tests/checkpoint_2020-03-25.pkl",
interaction=interaction,
infection_selector=selector,
config_filename=test_config,
leisure=None,
policies=policies,
save_path="tests",
)
# check timer is correct
assert sim_recovered.timer.initial_date == sim.timer.initial_date
assert sim_recovered.timer.final_date == sim.timer.final_date
assert sim_recovered.timer.now == sim.timer.now
assert sim_recovered.timer.date.date() == datetime.datetime(2020, 3, 26).date()
assert sim_recovered.timer.shift == sim.timer.shift
assert sim_recovered.timer.delta_time == sim.timer.delta_time
for person1, person2 in zip(sim.world.people, sim_recovered.world.people):
assert person1.id == person2.id
if person1.health_information is not None:
assert person2.health_information is not None
h1 = person1.health_information
h2 = person2.health_information
for slot in h1.__slots__:
if slot == "infection":
inf1 = h1.infection
inf2 = h2.infection
assert inf1.start_time == inf1.start_time
assert inf1.last_time_updated == inf1.last_time_updated
assert inf1.infection_probability == inf2.infection_probability
assert inf1.transmission.probability == inf2.transmission.probability
assert inf1.symptoms.tag == inf2.symptoms.tag
assert inf1.symptoms.max_severity == inf2.symptoms.max_severity
continue
p1_attr = getattr(person1.health_information, slot)
p2_attr = getattr(person2.health_information, slot)
assert p1_attr == p2_attr
assert person1.susceptible == person2.susceptible
assert person1.infected == person2.infected
assert person1.recovered == person2.recovered
assert person1.susceptibility == person2.susceptibility
assert person1.dead == person2.dead
def setup_sim(dummy_world, selector):
world = dummy_world
leisure_instance = leisure.generate_leisure_for_world(
world=world, list_of_leisure_groups=["pubs", "cinemas", "groceries"])
leisure_instance.distribute_social_venues_to_households(world.households)
interaction = Interaction.from_file()
policies = Policies.from_file()
sim = Simulator.from_file(
world=world,
infection_selector=selector,
interaction=interaction,
config_filename=test_config,
leisure=leisure_instance,
policies=policies,
)
sim.activity_manager.leisure.generate_leisure_probabilities_for_timestep(
3, False)
return sim
def test__close_universities(self, setup_policy_world):
world, pupil, student, worker, sim = setup_policy_world
super_area = world.super_areas[0]
university_closure = CloseUniversities(
start_time="2020-1-1",
end_time="2020-10-1",
)
policies = Policies([university_closure])
sim.activity_manager.policies = policies
sim.clear_world()
activities = ["primary_activity", "residence"]
time_before_policy = datetime(2019, 2, 1)
sim.activity_manager.move_people_to_active_subgroups(
activities, time_before_policy)
assert student in student.primary_activity.people
assert pupil in pupil.primary_activity.people
sim.clear_world()
time_during_policy = datetime(2020, 2, 1)
individual_policies = IndividualPolicies.get_active_policies(
policies=policies, date=time_during_policy)
assert individual_policies.apply(person=student,
activities=activities,
days_from_start=0) == [
"residence",
]
sim.activity_manager.move_people_to_active_subgroups(
activities, time_during_policy)
assert student in student.residence.people
sim.clear_world()
time_after_policy = datetime(2030, 2, 2)
individual_policies = IndividualPolicies.get_active_policies(
policies=policies, date=time_after_policy)
assert individual_policies.apply(person=student,
activities=activities,
days_from_start=0) == [
"primary_activity", "residence"
]
sim.activity_manager.move_people_to_active_subgroups(
activities, time_after_policy)
assert pupil in pupil.primary_activity.people
assert student in student.primary_activity.people
sim.clear_world()
def test__old_people_shield_with_compliance(self, setup_policy_world):
world, pupil, student, worker, _ = setup_policy_world
super_area = world.super_areas[0]
shielding = Shielding(start_time="2020-1-1",
end_time="2020-10-1",
min_age=30,
compliance=0.6)
policies = Policies([shielding])
activities = ["primary_activity", "residence"]
time_during_policy = datetime(2020, 2, 1)
individual_policies = IndividualPolicies.get_active_policies(
policies, date=time_during_policy)
compliant_days = 0
for i in range(100):
if "primary_activity" not in individual_policies.apply(
person=worker, activities=activities, days_from_start=0):
compliant_days += 1
assert compliant_days / 100 == pytest.approx(shielding.compliance,
abs=0.1)
def test__old_people_shield(self, setup_policy_world):
world, pupil, student, worker, sim = setup_policy_world
super_area = world.super_areas[0]
shielding = Shielding(start_time="2020-1-1",
end_time="2020-10-1",
min_age=30)
policies = Policies([shielding])
sim.activity_manager.policies = policies
activities = ["primary_activity", "residence"]
sim.clear_world()
time_during_policy = datetime(2020, 2, 1)
individual_policies = IndividualPolicies.get_active_policies(
policies, date=time_during_policy)
assert "primary_activity" not in individual_policies.apply(
person=worker, activities=activities, days_from_start=0)
sim.activity_manager.move_people_to_active_subgroups(
activities, time_during_policy)
assert worker in worker.residence.people
assert pupil in pupil.primary_activity.people
sim.clear_world()
def test__policy_adults(self, setup_policy_world, selector):
world, pupil, student, worker, sim = setup_policy_world
permanent_policy = SevereSymptomsStayHome()
policies = Policies([permanent_policy])
sim.activity_manager.policies = policies
sim.clear_world()
sim.activity_manager.move_people_to_active_subgroups(
["primary_activity", "residence"], )
date = datetime(2019, 2, 1)
assert worker in worker.primary_activity.people
assert pupil in pupil.primary_activity.people
sim.clear_world()
infect_person(worker, selector, "severe")
sim.update_health_status(0.0, 0.0)
sim.activity_manager.move_people_to_active_subgroups(
["primary_activity", "residence"], )
assert worker in worker.residence.people
assert pupil in pupil.primary_activity.people
worker.health_information = None
sim.clear_world()
def __init__(self, logger, real_data_path, summary_dir, parameter_index):
self.logger = logger
self.summary_dir = summary_dir
self.plot_save_dir = summary_dir / 'plots'
if os.path.exists(self.plot_save_dir) is False:
os.mkdir(self.plot_save_dir)
self.parameter_index = parameter_index
self.policies = Policies.from_file()
self.total_pop_cols = [
'current_infected', 'current_recovered', 'current_dead',
'current_susceptible'
]
self.real_data_path = real_data_path
self.real_data = self.check_real_data()
self.load_real_data(self.real_data)
self.regional_run_summary = self.create_regional_summaries()
self.daily_age_summary, self.age_labels = self.create_age_summaries(
sitrep_bins=False)
self.daily_age_summary_sitrep, self.age_labels_sitrep = self.create_age_summaries(
sitrep_bins=True)
def make_policies(self):
policies = []
for policy, policy_data in self.policies_baseline.items():
camel_case_key = "".join(x.capitalize() or "_"
for x in policy.split("_"))
if "start_time" not in policy_data:
for policy_i, policy_data_i in policy_data.items():
if ("start_time" not in policy_data_i.keys()
or "end_time" not in policy_data_i.keys()):
raise ValueError("policy config file not valid.")
if policy in self.policies_to_modify:
if str(policy_i) in self.policies_to_modify[policy]:
policy_data_modified = deepcopy(policy_data_i)
tomodify = self.policies_to_modify[policy][str(
policy_i)]
for parameter, parameter_value in tomodify.items():
if (policy == "social_distancing"
and parameter == "beta_factors"
and type(parameter_value) == float):
self._set_beta_factors(
policy_data_modified, parameter_value)
continue
policy_data_modified[
parameter] = parameter_value
else:
policy_data_modified = policy_data_i
else:
policy_data_modified = policy_data_i
policies.append(
str_to_class(camel_case_key)(**policy_data_modified))
else:
if policy in self.policies_to_modify:
policy_data_modified = deepcopy(policy_data)
tomodify = self.policies_to_modify[policy]
for parameter, parameter_value in tomodify.items():
policy_data_modified[parameter] = parameter_value
else:
policy_data_modified = policy_data
policies.append(
str_to_class(camel_case_key)(**policy_data_modified))
return Policies(policies=policies)
def test__move_people_from_icu_to_hospital(setup_policy_world, selector):
world, pupil, student, worker, sim = setup_policy_world
selector.infect_person_at_time(worker, 0.0)
hospitalisation = Hospitalisation()
policies = Policies([hospitalisation])
sim.activity_manager.policies = policies
worker.health_information.infection.symptoms.tag = SymptomTag.intensive_care
assert worker.health_information.should_be_in_hospital
sim.update_health_status(0.0, 0.0)
assert worker in worker.medical_facility.people
assert (worker in worker.medical_facility.group[
worker.medical_facility.group.SubgroupType.icu_patients])
sim.clear_world()
worker.health_information.infection.symptoms.tag = SymptomTag.hospitalised
sim.update_health_status(0.0, 0.0)
hospital = worker.medical_facility.group
sim.activity_manager.move_people_to_active_subgroups(
["medical_facility", "residence"])
assert worker in hospital[hospital.SubgroupType.patients]
assert worker not in hospital[hospital.SubgroupType.icu_patients]
sim.clear_world()
def test__close_leisure_venues(self, setup_policy_world):
world, pupil, student, worker, sim = setup_policy_world
close_venues = CloseLeisureVenue(
start_time="2020-3-1",
end_time="2020-3-30",
venues_to_close=["pub"],
)
policies = Policies([close_venues])
leisure_instance = leisure.generate_leisure_for_config(
world=world, config_filename=test_config)
leisure_instance.distribute_social_venues_to_households(
world.households)
sim.activity_manager.leisure = leisure_instance
sim.activity_manager.policies = policies
sim.activity_manager.leisure.leisure_distributors[
"pubs"].weekend_boost = 5000
sim.clear_world()
time_before_policy = datetime(2019, 2, 1)
activities = ["leisure", "residence"]
sim.activity_manager.leisure.generate_leisure_probabilities_for_timestep(
10000, False)
sim.activity_manager.move_people_to_active_subgroups(
activities, time_before_policy, 0.0)
assert worker in worker.leisure.people
sim.clear_world()
time_during_policy = datetime(2020, 3, 14)
leisure_policies = LeisurePolicies.get_active_policies(
policies=policies, date=time_during_policy)
leisure_policies.apply(date=time_during_policy,
leisure=leisure_instance)
assert list(leisure_instance.closed_venues) == ["pub"]
sim.activity_manager.leisure.generate_leisure_probabilities_for_timestep(
10000, False)
sim.activity_manager.move_people_to_active_subgroups(
activities, time_during_policy, 0.0)
assert (worker in worker.leisure.people and worker.leisure.group.spec
== "cinema") or worker in worker.residence.people
sim.clear_world()
def test__close_companies_full_closure(self, setup_policy_world):
world, pupil, student, worker, sim = setup_policy_world
super_area = world.super_areas[0]
company_closure = CloseCompanies(
start_time="2020-1-1",
end_time="2020-10-1",
full_closure=True,
)
policies = Policies([company_closure])
sim.activity_manager.policies = policies
worker.lockdown_status = "key_worker"
activities = ["commute", "primary_activity", "residence"]
sim.clear_world()
time_during_policy = datetime(2020, 2, 1)
individual_policies = IndividualPolicies.get_active_policies(
policies, date=time_during_policy)
assert individual_policies.apply(person=worker,
activities=activities,
days_from_start=0) == ["residence"]
sim.activity_manager.move_people_to_active_subgroups(
activities, time_during_policy)
assert worker in worker.residence.people
sim.clear_world()
def run_simulator(selector):
world = create_world()
world.to_hdf5("./checkpoint_world.hdf5")
# restore health status of people
for person in world.people:
person.health_information = None
person.susceptibility = 1.0
person.dead = False
interaction = Interaction.from_file()
policies = Policies([])
sim = Simulator.from_file(
world=world,
interaction=interaction,
infection_selector=selector,
config_filename=test_config,
leisure=None,
policies=policies,
save_path="tests",
)
seed = InfectionSeed(sim.world.super_areas, selector)
seed.unleash_virus(20)
sim.run()
return sim
def create_sim(world, interaction, selector):
leisure_instance = leisure.generate_leisure_for_config(
world=world, config_filename=test_config)
leisure_instance.distribute_social_venues_to_households(world.households)
policies = Policies([
Quarantine(n_days=5),
Quarantine(n_days=10),
CloseLeisureVenue(start_time="2020-3-1",
end_time="2020-3-30",
venues_to_close=['pub', 'cinema'])
])
infection_seed = InfectionSeed(super_areas=world.super_areas,
selector=selector)
n_cases = 2
infection_seed.unleash_virus(n_cases)
sim = Simulator.from_file(world=world,
interaction=interaction,
infection_selector=selector,
config_filename=test_config,
leisure=leisure_instance,
policies=policies)
return sim
def test__close_schools(self, setup_policy_world):
world, pupil, student, worker, sim = setup_policy_world
super_area = world.super_areas[0]
school_closure = CloseSchools(
start_time="2020-1-1",
end_time="2020-10-1",
years_to_close=[6],
)
policies = Policies([school_closure])
sim.activity_manager.policies = policies
# non key worker
worker.lockdown_status = "furlough"
sim.clear_world()
activities = ["primary_activity", "residence"]
time_before_policy = datetime(2019, 2, 1)
sim.activity_manager.move_people_to_active_subgroups(
activities, time_before_policy)
assert worker in worker.primary_activity.people
assert pupil in pupil.primary_activity.people
sim.clear_world()
time_during_policy = datetime(2020, 2, 1)
individual_policies = IndividualPolicies.get_active_policies(
policies, date=time_during_policy)
assert individual_policies.apply(person=pupil,
activities=activities,
days_from_start=0) == [
"residence",
]
sim.activity_manager.move_people_to_active_subgroups(
activities, time_during_policy)
assert pupil in pupil.residence.people
assert worker in worker.primary_activity.people
sim.clear_world()
time_after_policy = datetime(2030, 2, 2)
individual_policies = IndividualPolicies.get_active_policies(
policies, date=time_after_policy)
assert individual_policies.apply(person=pupil,
activities=activities,
days_from_start=0) == [
"primary_activity",
"residence",
]
sim.activity_manager.move_people_to_active_subgroups(
activities, time_after_policy)
assert pupil in pupil.primary_activity.people
assert worker in worker.primary_activity.people
sim.clear_world()
# key worker
worker.lockdown_status = "key_worker"
student.lockdown_status = "key_worker"
sim.clear_world()
activities = ["primary_activity", "residence"]
time_before_policy = datetime(2019, 2, 1)
sim.activity_manager.move_people_to_active_subgroups(
activities, time_before_policy)
assert worker in worker.primary_activity.people
assert pupil in pupil.primary_activity.people
sim.clear_world()
time_during_policy = datetime(2020, 2, 1)
individual_policies = IndividualPolicies.get_active_policies(
policies=policies, date=time_during_policy)
assert individual_policies.apply(person=pupil,
activities=activities,
days_from_start=0) == [
"primary_activity",
"residence",
]
sim.activity_manager.move_people_to_active_subgroups(
activities, time_during_policy)
assert pupil in pupil.primary_activity.people
assert worker in worker.primary_activity.people
sim.clear_world()
time_after_policy = datetime(2030, 2, 2)
individual_policies = IndividualPolicies.get_active_policies(
policies=policies, date=time_after_policy)
assert individual_policies.apply(person=pupil,
activities=activities,
days_from_start=0) == [
"primary_activity",
"residence",
]
sim.activity_manager.move_people_to_active_subgroups(
activities, time_after_policy)
assert pupil in pupil.primary_activity.people
assert worker in worker.primary_activity.people
sim.clear_world()
def test__social_distancing(self, setup_policy_world):
world, pupil, student, worker, sim = setup_policy_world
world.cemeteries = Cemeteries()
start_date = datetime(2020, 3, 10)
end_date = datetime(2020, 3, 12)
beta_factors = {
"box": 0.5,
"pub": 0.5,
"grocery": 0.5,
"cinema": 0.5,
"commute_unit": 0.5,
"commute_city_unit": 0.5,
"hospital": 0.5,
"care_home": 0.5,
"company": 0.5,
"school": 0.5,
"household": 1.0,
"university": 0.5,
}
social_distance = SocialDistancing(start_time="2020-03-10",
end_time="2020-03-12",
beta_factors=beta_factors)
beta_factors2 = {"cinema": 4}
start_date2 = datetime(2020, 3, 12)
end_date2 = datetime(2020, 3, 15)
social_distance2 = SocialDistancing(start_time="2020-03-12",
end_time="2020-03-15",
beta_factors=beta_factors2)
policies = Policies([social_distance, social_distance2])
leisure_instance = leisure.generate_leisure_for_config(
world=world, config_filename=test_config)
leisure_instance.distribute_social_venues_to_households(
world.households)
sim.activity_manager.policies = policies
sim.activity_manager.leisure = leisure_instance
sim.timer.reset()
initial_betas = copy.deepcopy(sim.interaction.beta)
sim.clear_world()
while sim.timer.date <= sim.timer.final_date:
sim.do_timestep()
if sim.timer.date >= start_date and sim.timer.date < end_date:
for group in sim.interaction.beta:
if group != "household":
assert sim.interaction.beta[
group] == initial_betas[group] * 0.5
else:
assert sim.interaction.beta[group] == initial_betas[
group]
next(sim.timer)
continue
if sim.timer.date >= start_date2 and sim.timer.date < end_date2:
for group in sim.interaction.beta:
if group != "cinema":
assert sim.interaction.beta == 4.0
else:
assert sim.interaction.beta[group] == initial_betas[
group]
next(sim.timer)
continue
assert sim.interaction.beta == initial_betas
next(sim.timer)
def test__close_companies_frequency_of_randoms(self, setup_policy_world):
world, pupil, student, worker, sim = setup_policy_world
super_area = world.super_areas[0]
company_closure = CloseCompanies(
start_time="2020-1-1",
end_time="2020-10-1",
random_work_probability=0.2
# go for 8 hours per week (one week has 168 hours)
)
policies = Policies([company_closure])
sim.activity_manager.policies = policies
sim.clear_world()
activities = ["commute", "primary_activity", "residence"]
time_before_policy = datetime(2019, 2, 1)
worker.lockdown_status = "random"
sim.activity_manager.move_people_to_active_subgroups(
activities, time_before_policy)
assert worker in worker.primary_activity.people
assert pupil in pupil.primary_activity.people
sim.clear_world()
time_during_policy = datetime(2020, 2, 1)
individual_policies = IndividualPolicies.get_active_policies(
policies, date=time_during_policy)
# Move the person 1_0000 times for five days
n_days_in_week = []
for i in range(500):
n_days = 0
for j in range(5):
if "primary_activity" in individual_policies.apply(
person=worker, activities=activities,
days_from_start=0):
n_days += 1.0
n_days_in_week.append(n_days)
assert np.isclose(np.mean(n_days_in_week), 1.1, atol=0.1)
n_days_in_week = []
for i in range(500):
n_days = 0
for j in range(10):
if "primary_activity" in individual_policies.apply(
person=worker, activities=activities,
days_from_start=0):
n_days += 0.5
n_days_in_week.append(n_days)
assert np.mean(n_days_in_week) == pytest.approx(1.0, rel=0.1)
sim.clear_world()
time_after_policy = datetime(2030, 2, 2)
individual_policies = IndividualPolicies.get_active_policies(
policies, date=time_after_policy)
assert individual_policies.apply(person=worker,
activities=activities,
days_from_start=0) == [
"commute",
"primary_activity",
"residence",
]
sim.activity_manager.move_people_to_active_subgroups(
activities, time_after_policy)
assert pupil in pupil.primary_activity.people
assert worker in worker.primary_activity.people
sim.clear_world()
def generate_simulator():
record = Record(record_path=save_path,
record_static_data=True,
mpi_rank=mpi_rank)
if mpi_rank == 0:
with h5py.File(world_file, "r") as f:
super_area_names = f["geography"]["super_area_name"][:]
super_area_ids = f["geography"]["super_area_id"][:]
super_area_names = [name.decode() for name in super_area_names]
super_area_name_to_id = {
key: value
for key, value in zip(super_area_names, super_area_ids)
}
# make dictionary super_area_id -> domain
domain_splitter = DomainSplitter(number_of_domains=mpi_size,
world_path=world_file)
super_areas_per_domain = domain_splitter.generate_domain_split(
niter=20)
super_area_names_to_domain_dict = {}
super_area_ids_to_domain_dict = {}
for domain, super_areas in super_areas_per_domain.items():
for super_area in super_areas:
super_area_names_to_domain_dict[super_area] = domain
super_area_ids_to_domain_dict[int(
super_area_name_to_id[super_area])] = domain
with open("super_area_ids_to_domain.json", "w") as f:
json.dump(super_area_ids_to_domain_dict, f)
with open("super_area_names_to_domain.json", "w") as f:
json.dump(super_area_names_to_domain_dict, f)
mpi_comm.Barrier()
if mpi_rank > 0:
with open("super_area_ids_to_domain.json", "r") as f:
super_area_ids_to_domain_dict = json.load(f,
object_hook=keys_to_int)
domain = Domain.from_hdf5(
domain_id=mpi_rank,
super_areas_to_domain_dict=super_area_ids_to_domain_dict,
hdf5_file_path=world_file,
)
record.static_data(world=domain)
# regenerate lesiure
leisure = generate_leisure_for_config(domain, config_path)
#
# health index and infection selecctor
health_index_generator = HealthIndexGenerator.from_file()
infection_selector = InfectionSelector(
health_index_generator=health_index_generator)
oc = Observed2Cases.from_file(
health_index_generator=health_index_generator, smoothing=True)
daily_cases_per_region = oc.get_regional_latent_cases()
daily_cases_per_super_area = oc.convert_regional_cases_to_super_area(
daily_cases_per_region, dates=["2020-02-28", "2020-03-02"])
infection_seed = InfectionSeed(
world=domain,
infection_selector=infection_selector,
daily_super_area_cases=daily_cases_per_super_area,
seed_strength=100,
)
# interaction
interaction = Interaction.from_file(
config_filename="./config_interaction.yaml", population=domain.people)
# policies
policies = Policies.from_file()
# events
events = Events.from_file()
# create simulator
travel = Travel()
simulator = Simulator.from_file(
world=domain,
policies=policies,
events=events,
interaction=interaction,
leisure=leisure,
travel=travel,
infection_selector=infection_selector,
infection_seed=infection_seed,
config_filename=config_path,
record=record,
)
print("simulator ready to go")
return simulator
def base(self):
return Policies.from_file(test_config)
interaction.alpha_physical
interaction.alpha_physical /= 2
interaction.alpha_physical
# # Seed the disease
# There are two options implemented in the seed at the moment, either you specify the number of cases and these are then homogeneously distributed by population to the different areas, or you use UK data on cases per region. For now use the first case.
seed = InfectionSeed(
world.super_areas,
selector,
)
n_cases = 50
seed.unleash_virus(n_cases) # play around with the initial number of cases
# # Set policies
policies = Policies.from_file()
# # Run the simulation
# Since the timer configuration is a bit cumbersome, it is read from the config file at ``configs/config_example.yml
CONFIG_PATH = "configs/config_example.yaml"
leisure = generate_leisure_for_config(world=world, config_filename=CONFIG_PATH)
simulator = Simulator.from_file(world,
interaction,
selector,
config_filename=CONFIG_PATH,
leisure=leisure,
policies=policies)
# Run the simulator
simulator.run()
def test__hospitalisation_takes_preference(selector):
isolation = Isolation(
testing_mean_time=3, testing_std_time=1, n_quarantine_days=7, compliance=0.5
)
hospitalisation = Hospitalisation()
policies = Policies([isolation, hospitalisation])
def test__reduce_household_visits(self, setup_policy_world):
world, pupil, student, worker, sim = setup_policy_world
super_area = world.super_areas[0]
leisure_instance = leisure.generate_leisure_for_config(
world=world, config_filename=test_config)
reduce_leisure_probabilities = ChangeLeisureProbability(
start_time="2020-03-02",
end_time="2020-03-05",
leisure_activities_probabilities={
"pubs": {
"men": {
"0-50": 0.2,
"50-100": 0.0
},
"women": {
"0-100": 0.2
},
},
},
)
policies = Policies([reduce_leisure_probabilities])
sim.activity_manager.policies = policies
sim.activity_manager.leisure = leisure_instance
sim.clear_world()
leisure_policies = LeisurePolicies.get_active_policies(
policies=policies, date=sim.timer.date)
leisure_policies.apply(date=sim.timer.date,
leisure=sim.activity_manager.leisure)
sim.activity_manager.leisure.generate_leisure_probabilities_for_timestep(
0.1, False)
original_male_pub_probabilities = sim.activity_manager.leisure.leisure_distributors[
"pubs"].male_probabilities
original_female_pub_probabilities = sim.activity_manager.leisure.leisure_distributors[
"pubs"].female_probabilities
assert str(sim.timer.date.date()) == "2020-03-01"
household = Household()
household.area = super_area.areas[0]
leisure_instance.distribute_social_venues_to_households([household])
person1 = Person.from_attributes(age=60, sex="m")
person1.area = super_area.areas[0]
household.add(person1)
person2 = Person.from_attributes(age=80, sex="f")
person2.area = super_area.areas[0]
sim.activity_manager.leisure.distribute_social_venues_to_households(
[household])
household.add(person2)
pubs1_visits_before = 0
pubs2_visits_before = 0
for _ in range(5000):
subgroup = sim.activity_manager.leisure.get_subgroup_for_person_and_housemates(
person1)
if subgroup is not None and subgroup.group.spec == "pub":
pubs1_visits_before += 1
person1.subgroups.leisure = None
subgroup = sim.activity_manager.leisure.get_subgroup_for_person_and_housemates(
person2)
if subgroup is not None and subgroup.group.spec == "pub":
pubs2_visits_before += 1
person2.subgroups.leisure = None
assert pubs1_visits_before > 0
assert pubs2_visits_before > 0
# next day leisure policies are
while str(sim.timer.date.date()) != "2020-03-02":
next(sim.timer)
leisure_policies = LeisurePolicies.get_active_policies(
policies=policies, date=sim.timer.date)
leisure_policies.apply(date=sim.timer.date,
leisure=sim.activity_manager.leisure)
sim.activity_manager.leisure.generate_leisure_probabilities_for_timestep(
0.1, False)
assert (sim.activity_manager.leisure.leisure_distributors["pubs"].
male_probabilities[60] == 0.0)
assert (sim.activity_manager.leisure.leisure_distributors["pubs"].
female_probabilities[60] == 0.2)
pubs1_visits_after = 0
pubs2_visits_after = 0
for _ in range(5000):
subgroup = sim.activity_manager.leisure.get_subgroup_for_person_and_housemates(
person1)
if subgroup is not None and subgroup.group.spec == "pub":
pubs1_visits_after += 1
person1.subgroups.leisure = None
subgroup = sim.activity_manager.leisure.get_subgroup_for_person_and_housemates(
person2)
if subgroup is not None and subgroup.group.spec == "pub":
pubs2_visits_after += 1
person2.subgroups.leisure = None
assert pubs1_visits_after == 0
assert 0 < pubs2_visits_after < pubs2_visits_before
# end of policy
while str(sim.timer.date.date()) != "2020-03-05":
next(sim.timer)
leisure_policies = LeisurePolicies.get_active_policies(
policies=policies, date=sim.timer.date)
leisure_policies.apply(date=sim.timer.date,
leisure=sim.activity_manager.leisure)
sim.activity_manager.leisure.generate_leisure_probabilities_for_timestep(
0.1, False)
pubs1_visits_restored = 0
pubs2_visits_restored = 0
for _ in range(5000):
subgroup = sim.activity_manager.leisure.get_subgroup_for_person_and_housemates(
person1)
if subgroup is not None and subgroup.group.spec == "pub":
pubs1_visits_restored += 1
person1.subgroups.leisure = None
subgroup = sim.activity_manager.leisure.get_subgroup_for_person_and_housemates(
person2)
if subgroup is not None and subgroup.group.spec == "pub":
pubs2_visits_restored += 1
person2.subgroups.leisure = None
assert np.isclose(pubs1_visits_restored, pubs1_visits_before, rtol=0.2)
assert np.isclose(pubs2_visits_restored, pubs2_visits_before, rtol=0.2)
assert (sim.activity_manager.leisure.leisure_distributors["pubs"].
male_probabilities == original_male_pub_probabilities)
assert (sim.activity_manager.leisure.leisure_distributors["pubs"].
female_probabilities == original_female_pub_probabilities)
def make_policies():
policies = Policies([Hospitalisation()])
return MedicalCarePolicies.get_active_policies(policies=policies,
date=datetime(2020, 3, 1))
