def test__assign_demography_with_initial_age_zero(config):
pop_data = dt.assign_demographic_proportions(
make_uniform_pop_data(age_bin_midpoint=True))
pop_data = pop_data[pop_data.year_start == 1990]
simulants = make_base_simulants()
initial_age = 0
r = {
k: get_randomness()
for k in ['general_purpose', 'bin_selection', 'age_smoothing']
}
step_size = utilities.to_time_delta(config.time.step_size)
simulants = bp._assign_demography_with_initial_age(
simulants, pop_data, initial_age, step_size, r,
lambda *args, **kwargs: None)
assert len(simulants) == len(simulants.age.unique())
assert simulants.age.min() > initial_age
assert simulants.age.max() < initial_age + utilities.to_years(step_size)
assert math.isclose(len(simulants[simulants.sex == 'Male']) /
len(simulants),
0.5,
abs_tol=0.01)
for location in simulants.location.unique():
assert math.isclose(len(simulants[simulants.location == location]) /
len(simulants),
1 / len(simulants.location.unique()),
abs_tol=0.01)
def test_generate_population_initial_age(age_bounds_mock, initial_age_mock):
creation_time = pd.Timestamp(1990, 7, 2)
step_size = pd.Timedelta(days=1)
age_params = {'age_start': 0, 'age_end': 0}
pop_data = dt.assign_demographic_proportions(
make_uniform_pop_data(age_bin_midpoint=True))
r = {
k: get_randomness()
for k in ['general_purpose', 'bin_selection', 'age_smoothing']
}
sims = make_base_simulants()
simulant_ids = sims.index
bp.generate_population(simulant_ids, creation_time, step_size, age_params,
pop_data, r, lambda *args, **kwargs: None)
initial_age_mock.assert_called_once()
mock_args = initial_age_mock.call_args[0]
assert mock_args[0].equals(sims)
assert mock_args[1].equals(pop_data)
assert mock_args[2] == float(age_params['age_start'])
assert mock_args[3] == step_size
assert mock_args[4] == r
age_bounds_mock.assert_not_called()
def test__assign_demography_with_age_bounds_error():
pop_data = dt.assign_demographic_proportions(
make_uniform_pop_data(age_bin_midpoint=True))
simulants = make_base_simulants()
age_start, age_end = 110, 120
r = {
k: get_randomness()
for k in ['general_purpose', 'bin_selection', 'age_smoothing']
}
with pytest.raises(ValueError):
bp._assign_demography_with_age_bounds(simulants, pop_data, age_start,
age_end, r,
lambda *args, **kwargs: None)
def test__assign_demography_with_initial_age_error():
pop_data = dt.assign_demographic_proportions(
make_uniform_pop_data(age_bin_midpoint=True))
pop_data = pop_data[pop_data.year_start == 1990]
simulants = make_base_simulants()
initial_age = 200
r = {
k: get_randomness()
for k in ['general_purpose', 'bin_selection', 'age_smoothing']
}
step_size = pd.Timedelta(days=1)
with pytest.raises(ValueError):
bp._assign_demography_with_initial_age(simulants, pop_data,
initial_age, step_size, r,
lambda *args, **kwargs: None)
def test_smooth_ages():
pop_data = dt.assign_demographic_proportions(
make_uniform_pop_data(age_bin_midpoint=True))
pop_data = pop_data[pop_data.year_start == 1990]
simulants = pd.DataFrame({
'age': [22.5] * 10000 + [52.5] * 10000,
'sex': ['Male', 'Female'] * 10000,
'location': [1, 2] * 10000
})
randomness = get_randomness()
smoothed_simulants = dt.smooth_ages(simulants, pop_data, randomness)
assert math.isclose(len(smoothed_simulants.age.unique()),
len(smoothed_simulants.index),
abs_tol=1)
# Tolerance is 3*std_dev of the sample mean
assert math.isclose(smoothed_simulants.age.mean(),
37.5,
abs_tol=3 * math.sqrt(13.149778198**2 / 2000))
def test__assign_demography_with_age_bounds():
pop_data = dt.assign_demographic_proportions(
make_uniform_pop_data(age_bin_midpoint=True))
pop_data = pop_data[pop_data.year_start == 1990]
simulants = make_base_simulants()
age_start, age_end = 0, 180
r = {
k: get_randomness(k)
for k in [
'general_purpose', 'bin_selection', 'age_smoothing',
'age_smoothing_age_bounds'
]
}
simulants = bp._assign_demography_with_age_bounds(
simulants, pop_data, age_start, age_end, r,
lambda *args, **kwargs: None)
assert math.isclose(len(simulants[simulants.sex == 'Male']) /
len(simulants),
0.5,
abs_tol=0.01)
for location in simulants.location.unique():
assert math.isclose(len(simulants[simulants.location == location]) /
len(simulants),
1 / len(simulants.location.unique()),
abs_tol=0.01)
ages = np.sort(simulants.age.values)
age_deltas = ages[1:] - ages[:-1]
age_bin_width = 5 # See `make_uniform_pop_data`
num_bins = len(pop_data.age.unique())
n = len(simulants)
assert math.isclose(age_deltas.mean(),
age_bin_width * num_bins / n,
rel_tol=1e-3)
assert age_deltas.max(
) < 100 * age_bin_width * num_bins / n # Make sure there are no big age gaps.