diff --git a/resources/ResourceFile_HIV.xlsx b/resources/ResourceFile_HIV.xlsx index b2db25c898..00f7b684db 100644 --- a/resources/ResourceFile_HIV.xlsx +++ b/resources/ResourceFile_HIV.xlsx @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:f57142efaf515d74f8290238ce1abad7b99871f9195623112892b3bb535bf634 -size 161721 +oid sha256:b34a88635b02ee8a465462c8eb67a485d721c9159a5bba1df8e63609b803ebe9 +size 161679 diff --git a/resources/ResourceFile_TB.xlsx b/resources/ResourceFile_TB.xlsx index 3dfc69cd81..2b612ad6ec 100644 --- a/resources/ResourceFile_TB.xlsx +++ b/resources/ResourceFile_TB.xlsx @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:120d687122772909c267db41c933664ccc6247c8aef59d49532547c0c3791121 -size 55634 +oid sha256:93d7bf76c8bece548e08e3f0cb6e9e28a09ca2b5760a408399bf9641f7ed2001 +size 56523 diff --git a/resources/malaria/ResourceFile_malaria.xlsx b/resources/malaria/ResourceFile_malaria.xlsx index a6487e80ae..7537f3ace9 100644 --- a/resources/malaria/ResourceFile_malaria.xlsx +++ b/resources/malaria/ResourceFile_malaria.xlsx @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:e8157368754dae9ce692fbd10fecf1e598f37fb258292085c93e1c881dd47aa9 -size 69590 +oid sha256:7f256d5007b36e2428ae844747bd766bb6086540c5135408d606dd821e185d9f +size 69578 diff --git a/src/scripts/comparison_of_horizontal_and_vertical_programs/analysis_maxHTM_scenario.py b/src/scripts/comparison_of_horizontal_and_vertical_programs/analysis_maxHTM_scenario.py new file mode 100644 index 0000000000..0cfcd05315 --- /dev/null +++ b/src/scripts/comparison_of_horizontal_and_vertical_programs/analysis_maxHTM_scenario.py @@ -0,0 +1,229 @@ +""" +This scenario file sets up the scenarios for simulating the effects of scaling up programs + +The scenarios are: +*0 baseline mode 1 +*1 scale-up HIV program +*2 scale-up TB program +*3 scale-up malaria program +*4 scale-up HIV and Tb and malaria programs + +scale-up occurs on the default scale-up start date (01/01/2025: in parameters list of resourcefiles) + +For all scenarios, keep all default health system settings + +check the batch configuration gets generated without error: +tlo scenario-run --draw-only src/scripts/comparison_of_horizontal_and_vertical_programs/analysis_maxHTM_scenario.py + +Run on the batch system using: +tlo batch-submit src/scripts/comparison_of_horizontal_and_vertical_programs/analysis_maxHTM_scenario.py + +or locally using: +tlo scenario-run src/scripts/comparison_of_horizontal_and_vertical_programs/analysis_maxHTM_scenario.py + +or execute a single run: +tlo scenario-run src/scripts/comparison_of_horizontal_and_vertical_programs/analysis_maxHTM_scenario.py --draw 1 0 + +""" + +import datetime +from pathlib import Path + +from tlo import Date, logging +from tlo.methods import ( + demography, + enhanced_lifestyle, + epi, + healthburden, + healthseekingbehaviour, + healthsystem, + hiv, + malaria, + simplified_births, + symptommanager, + tb, +) +from tlo.scenario import BaseScenario + +resourcefilepath = Path("./resources") +datestamp = datetime.date.today().strftime("__%Y_%m_%d") + +outputspath = Path("./outputs") +scaleup_start_year = 2012 +end_date = Date(2015, 1, 1) + + +class EffectOfProgrammes(BaseScenario): + def __init__(self): + super().__init__() + self.seed = 0 + self.start_date = Date(2010, 1, 1) + self.end_date = end_date + self.pop_size = 1_000 + self.number_of_draws = 5 + self.runs_per_draw = 1 + + def log_configuration(self): + return { + 'filename': 'scaleup_tests', + 'directory': Path('./outputs'), # <- (specified only for local running) + 'custom_levels': { + '*': logging.WARNING, + 'tlo.methods.hiv': logging.INFO, + 'tlo.methods.tb': logging.INFO, + 'tlo.methods.malaria': logging.INFO, + 'tlo.methods.demography': logging.INFO, + } + } + + def modules(self): + return [ + demography.Demography(resourcefilepath=self.resources), + simplified_births.SimplifiedBirths(resourcefilepath=self.resources), + enhanced_lifestyle.Lifestyle(resourcefilepath=self.resources), + healthsystem.HealthSystem(resourcefilepath=self.resources), + symptommanager.SymptomManager(resourcefilepath=self.resources), + healthseekingbehaviour.HealthSeekingBehaviour(resourcefilepath=self.resources), + healthburden.HealthBurden(resourcefilepath=self.resources), + epi.Epi(resourcefilepath=self.resources), + hiv.Hiv(resourcefilepath=self.resources), + tb.Tb(resourcefilepath=self.resources), + malaria.Malaria(resourcefilepath=self.resources), + ] + + def draw_parameters(self, draw_number, rng): + + return { + 'Hiv': { + 'type_of_scaleup': ['none', 'max', 'none', 'none', 'max'][draw_number], + 'scaleup_start_year': scaleup_start_year, + }, + 'Tb': { + 'type_of_scaleup': ['none', 'none', 'max', 'none', 'max'][draw_number], + 'scaleup_start_year': scaleup_start_year, + }, + 'Malaria': { + 'type_of_scaleup': ['none', 'none', 'none', 'max', 'max'][draw_number], + 'scaleup_start_year': scaleup_start_year, + }, + } + + +if __name__ == '__main__': + from tlo.cli import scenario_run + + scenario_run([__file__]) + + + +# %% Produce some figures and summary info + +# import pandas as pd +# import matplotlib.pyplot as plt + +# # Find results_folder associated with a given batch_file (and get most recent [-1]) +# results_folder = get_scenario_outputs("scaleup_tests-", outputspath)[-1] +# +# # get basic information about the results +# info = get_scenario_info(results_folder) +# +# # 1) Extract the parameters that have varied over the set of simulations +# params = extract_params(results_folder) +# +# +# # DEATHS +# +# +# def get_num_deaths_by_cause_label(_df): +# """Return total number of Deaths by label within the TARGET_PERIOD +# values are summed for all ages +# df returned: rows=COD, columns=draw +# """ +# return _df \ +# .loc[pd.to_datetime(_df.date).between(*TARGET_PERIOD)] \ +# .groupby(_df['label']) \ +# .size() +# +# +# TARGET_PERIOD = (Date(scaleup_start_year, 1, 1), end_date) +# +# # produce df of total deaths over scale-up period +# num_deaths_by_cause_label = extract_results( +# results_folder, +# module='tlo.methods.demography', +# key='death', +# custom_generate_series=get_num_deaths_by_cause_label, +# do_scaling=True +# ) +# +# +# def summarise_deaths_for_one_cause(results_folder, label): +# """ returns mean deaths for each year of the simulation +# values are aggregated across the runs of each draw +# for the specified cause +# """ +# +# results_deaths = extract_results( +# results_folder, +# module="tlo.methods.demography", +# key="death", +# custom_generate_series=( +# lambda df: df.assign(year=df["date"].dt.year).groupby( +# ["year", "label"])["person_id"].count() +# ), +# do_scaling=True, +# ) +# # removes multi-index +# results_deaths = results_deaths.reset_index() +# +# # select only cause specified +# tmp = results_deaths.loc[ +# (results_deaths.label == label) +# ] +# +# # group deaths by year +# tmp = pd.DataFrame(tmp.groupby(["year"]).sum()) +# +# # get mean for each draw +# mean_deaths = pd.concat({'mean': tmp.iloc[:, 1:].groupby(level=0, axis=1).mean()}, axis=1).swaplevel(axis=1) +# +# return mean_deaths +# +# +# aids_deaths = summarise_deaths_for_one_cause(results_folder, 'AIDS') +# tb_deaths = summarise_deaths_for_one_cause(results_folder, 'TB (non-AIDS)') +# malaria_deaths = summarise_deaths_for_one_cause(results_folder, 'Malaria') +# +# +# draw_labels = ['No scale-up', 'HIV scale-up', 'TB scale-up', 'Malaria scale-up', 'HTM scale-up'] +# colours = ['blue', 'green', 'red', 'purple', 'orange'] +# +# # Create subplots +# fig, axs = plt.subplots(3, 1, figsize=(10, 10)) +# # Plot for df1 +# for i, col in enumerate(aids_deaths.columns): +# axs[0].plot(aids_deaths.index, aids_deaths[col], label=draw_labels[i], +# color=colours[i]) +# axs[0].set_title('HIV/AIDS') +# axs[0].legend(loc='center left', bbox_to_anchor=(1, 0.5)) # Legend to the right of the plot +# axs[0].axvline(x=scaleup_start_year, color='gray', linestyle='--') +# +# # Plot for df2 +# for i, col in enumerate(tb_deaths.columns): +# axs[1].plot(tb_deaths.index, tb_deaths[col], color=colours[i]) +# axs[1].set_title('TB') +# axs[1].axvline(x=scaleup_start_year, color='gray', linestyle='--') +# +# # Plot for df3 +# for i, col in enumerate(malaria_deaths.columns): +# axs[2].plot(malaria_deaths.index, malaria_deaths[col], color=colours[i]) +# axs[2].set_title('Malaria') +# axs[2].axvline(x=scaleup_start_year, color='gray', linestyle='--') +# +# for ax in axs: +# ax.set_xlabel('Years') +# ax.set_ylabel('Number deaths') +# +# plt.tight_layout(rect=[0, 0, 0.85, 1]) # Adjust layout to make space for legend +# plt.show() +# diff --git a/src/scripts/comparison_of_horizontal_and_vertical_programs/scenario_definitions.py b/src/scripts/comparison_of_horizontal_and_vertical_programs/scenario_definitions.py index 8cea0f5f5a..6465b57f49 100644 --- a/src/scripts/comparison_of_horizontal_and_vertical_programs/scenario_definitions.py +++ b/src/scripts/comparison_of_horizontal_and_vertical_programs/scenario_definitions.py @@ -12,17 +12,17 @@ def YEAR_OF_CHANGE_FOR_HSS(self) -> int: return 2019 # <-- baseline year of Human Resources for Health is 2018, and this is consistent with calibration # during 2015-2019 period. + @property def YEAR_OF_CHANGE_FOR_HTM(self) -> int: """Year in which HIV, TB, Malaria scale-up changes are made.""" - return 2019 + return 2019 # todo <-- what is the natural year of scale-up? Should this be the same as the when the HSS + # changes happen? - def baseline(self) -> Dict: + def _baseline(self) -> Dict: """Return the Dict with values for the parameter changes that define the baseline scenario. """ return mix_scenarios( - get_parameters_for_status_quo(), # <-- Parameters that have been the calibration targets - - # Set up the HealthSystem to transition from Mode 1 -> Mode 2, with rescaling when there are HSS changes + get_parameters_for_status_quo(), { "HealthSystem": { "mode_appt_constraints": 1, # <-- Mode 1 prior to change to preserve calibration @@ -31,6 +31,12 @@ def baseline(self) -> Dict: # <-- Transition into Mode2 with the effective capabilities in HRH 'revealed' in Mode 1 "year_mode_switch": self.YEAR_OF_CHANGE_FOR_HSS, + # Baseline scenario is with absence of HCW + 'year_HR_scaling_by_level_and_officer_type': self.YEAR_OF_CHANGE_FOR_HSS, + 'HR_scaling_by_level_and_officer_type_mode': 'with_absence', + # todo <-- Do we want the first part of the run be with_abscence too...? (Although that will mean + # that there is actually greater capacity if we do the rescaling) + # Normalize the behaviour of Mode 2 "policy_name": "Naive", "tclose_overwrite": 1, @@ -39,90 +45,24 @@ def baseline(self) -> Dict: }, ) - def double_capacity_at_primary_care(self) -> Dict: - return { - 'HealthSystem': { - 'year_HR_scaling_by_level_and_officer_type': self.YEAR_OF_CHANGE_FOR_HSS, - 'HR_scaling_by_level_and_officer_type_mode': 'x2_fac0&1', - } - } - - def hrh_at_pop_grwoth(self) -> Dict: - return { - 'HealthSystem': { - 'yearly_HR_scaling_mode': 'scaling_by_population_growth', - # This is in-line with population growth _after 2018_ (baseline year for HRH) - } - } - - def hrh_at_gdp_growth(self) -> Dict: - return { - 'HealthSystem': { - 'yearly_HR_scaling_mode': 'GDP_growth', - # This is GDP growth after 2018 (baseline year for HRH) - } - } - - def hrh_above_gdp_growth(self) -> Dict: - return { - 'HealthSystem': { - 'yearly_HR_scaling_mode': 'GDP_growth_fHE_case5', - # This is above-GDP growth after 2018 (baseline year for HRH) - } - } - - def perfect_clinical_practices(self) -> Dict: + def _hss_package(self) -> Dict: + """The parameters for the Health System Strengthening Package""" return { 'ImprovedHealthSystemAndCareSeekingScenarioSwitcher': { 'max_healthsystem_function': [False, True], # <-- switch from False to True mid-way - 'year_of_switch': self.YEAR_OF_CHANGE_FOR_HSS, - } - } - - def perfect_healthcare_seeking(self) -> Dict: - return { - 'ImprovedHealthSystemAndCareSeekingScenarioSwitcher': { 'max_healthcare_seeking': [False, True], # <-- switch from False to True mid-way - 'year_of_switch': self.YEAR_OF_CHANGE_FOR_HSS, - } - } - - def vital_items_available(self) -> Dict: - return { - 'HealthSystem': { - 'year_cons_availability_switch': self.YEAR_OF_CHANGE_FOR_HSS, - 'cons_availability_postSwitch': 'all_vital_available', - } - } - - def medicines_available(self) -> Dict: - return { - 'HealthSystem': { - 'year_cons_availability_switch': self.YEAR_OF_CHANGE_FOR_HSS, - 'cons_availability_postSwitch': 'all_medicines_available', - } - } - - def all_consumables_available(self) -> Dict: - return { + 'year_of_switch': self.YEAR_OF_CHANGE_FOR_HSS + }, 'HealthSystem': { 'year_cons_availability_switch': self.YEAR_OF_CHANGE_FOR_HSS, 'cons_availability_postSwitch': 'all', + 'yearly_HR_scaling_mode': 'GDP_growth_fHE_case5', + 'year_HR_scaling_by_level_and_officer_type': self.YEAR_OF_CHANGE_FOR_HSS, + 'HR_scaling_by_level_and_officer_type_mode': 'no_absence_&_x2_fac0+1', } } - def hss_package(self) -> Dict: - """The parameters for the Health System Strengthening Package""" - return mix_scenarios( - self.double_capacity_at_primary_care(), # } - self.hrh_above_gdp_growth(), # } <-- confirmed that these two do build on one another under - # mode 2 rescaling: see `test_scaling_up_HRH_using_yearly_scaling_and_scaling_by_level_together`. - self.perfect_clinical_practices(), - self.perfect_healthcare_seeking(), - self.all_consumables_available(), - ) - - def hiv_scaleup(self) -> Dict: + def _hiv_scaleup(self) -> Dict: """The parameters for the scale-up of the HIV program""" return { "Hiv": { @@ -131,7 +71,7 @@ def hiv_scaleup(self) -> Dict: } } - def tb_scaleup(self) -> Dict: + def _tb_scaleup(self) -> Dict: """The parameters for the scale-up of the TB program""" return { "Tb": { @@ -140,7 +80,7 @@ def tb_scaleup(self) -> Dict: } } - def malaria_scaleup(self) -> Dict: + def _malaria_scaleup(self) -> Dict: """The parameters for the scale-up of the Malaria program""" return { 'Malaria': { diff --git a/src/tlo/methods/hiv.py b/src/tlo/methods/hiv.py index d744c9d254..d6455cc861 100644 --- a/src/tlo/methods/hiv.py +++ b/src/tlo/methods/hiv.py @@ -398,16 +398,16 @@ def __init__(self, name=None, resourcefilepath=None, run_with_checks=False): " high-bound-exclusive]", ), # ------------------ scale-up parameters for scenario analysis ------------------ # - "do_scaleup": Parameter( - Types.BOOL, - "argument to determine whether scale-up of program will be implemented" + "type_of_scaleup": Parameter( + Types.STRING, "argument to determine type scale-up of program which will be implemented, " + "can be 'none', 'target' or 'max'", ), "scaleup_start_year": Parameter( Types.INT, "the year when the scale-up starts (it will occur on 1st January of that year)" ), "scaleup_parameters": Parameter( - Types.DICT, + Types.DATA_FRAME, "the parameters and values changed in scenario analysis" ), } @@ -448,7 +448,7 @@ def read_parameters(self, data_folder): p["treatment_cascade"] = workbook["spectrum_treatment_cascade"] # load parameters for scale-up projections - p["scaleup_parameters"] = workbook["scaleup_parameters"].set_index('parameter')['scaleup_value'].to_dict() + p['scaleup_parameters'] = workbook["scaleup_parameters"] # DALY weights # get the DALY weight that this module will use from the weight database (these codes are just random!) @@ -914,7 +914,7 @@ def initialise_simulation(self, sim): sim.schedule_event(HivLoggingEvent(self), sim.date + DateOffset(years=1)) # Optional: Schedule the scale-up of programs - if self.parameters["do_scaleup"]: + if self.parameters["type_of_scaleup"] != 'none': scaleup_start_date = Date(self.parameters["scaleup_start_year"], 1, 1) assert scaleup_start_date >= self.sim.start_date, f"Date {scaleup_start_date} is before simulation starts." sim.schedule_event(HivScaleUpEvent(self), scaleup_start_date) @@ -1102,8 +1102,14 @@ def initialise_simulation(self, sim): ) def update_parameters_for_program_scaleup(self): + """ options for program scale-up are 'target' or 'max' """ p = self.parameters - scaled_params = p["scaleup_parameters"] + scaled_params_workbook = p["scaleup_parameters"] + + if p['type_of_scaleup'] == 'target': + scaled_params = scaled_params_workbook.set_index('parameter')['target_value'].to_dict() + else: + scaled_params = scaled_params_workbook.set_index('parameter')['max_value'].to_dict() # scale-up HIV program # reduce risk of HIV - applies to whole adult population diff --git a/src/tlo/methods/malaria.py b/src/tlo/methods/malaria.py index a5e9738a99..b1fdfb09dd 100644 --- a/src/tlo/methods/malaria.py +++ b/src/tlo/methods/malaria.py @@ -189,17 +189,16 @@ def __init__(self, name=None, resourcefilepath=None): Types.REAL, 'probability that treatment will clear malaria symptoms' ), - # ------------------ scale-up parameters for scenario analysis ------------------ # - "do_scaleup": Parameter( - Types.BOOL, - "argument to determine whether scale-up of program will be implemented" + "type_of_scaleup": Parameter( + Types.STRING, "argument to determine type scale-up of program which will be implemented, " + "can be 'none', 'target' or 'max'", ), "scaleup_start_year": Parameter( Types.INT, "the year when the scale-up starts (it will occur on 1st January of that year)" ), "scaleup_parameters": Parameter( - Types.DICT, + Types.DATA_FRAME, "the parameters and values changed in scenario analysis" ) } @@ -261,7 +260,7 @@ def read_parameters(self, data_folder): p['sev_inc'] = pd.read_csv(self.resourcefilepath / 'malaria' / 'ResourceFile_malaria_SevInc_expanded.csv') # load parameters for scale-up projections - p["scaleup_parameters"] = workbook["scaleup_parameters"].set_index('parameter')['scaleup_value'].to_dict() + p['scaleup_parameters'] = workbook["scaleup_parameters"] # check itn projected values are <=0.7 and rounded to 1dp for matching to incidence tables p['itn'] = round(p['itn'], 1) @@ -602,7 +601,7 @@ def initialise_simulation(self, sim): sim.schedule_event(MalariaPrevDistrictLoggingEvent(self), sim.date + DateOffset(months=1)) # Optional: Schedule the scale-up of programs - if self.parameters["do_scaleup"]: + if self.parameters["type_of_scaleup"] != 'none': scaleup_start_date = Date(self.parameters["scaleup_start_year"], 1, 1) assert scaleup_start_date >= self.sim.start_date, f"Date {scaleup_start_date} is before simulation starts." sim.schedule_event(MalariaScaleUpEvent(self), scaleup_start_date) @@ -659,8 +658,14 @@ def initialise_simulation(self, sim): ) def update_parameters_for_program_scaleup(self): + """ options for program scale-up are 'target' or 'max' """ p = self.parameters - scaled_params = p["scaleup_parameters"] + scaled_params_workbook = p["scaleup_parameters"] + + if p['type_of_scaleup'] == 'target': + scaled_params = scaled_params_workbook.set_index('parameter')['target_value'].to_dict() + else: + scaled_params = scaled_params_workbook.set_index('parameter')['max_value'].to_dict() # scale-up malaria program # increase testing @@ -1164,7 +1169,7 @@ def apply(self, person_id, squeeze_factor): facility_level=self.ACCEPTED_FACILITY_LEVEL, treatment_id=self.TREATMENT_ID, ) - + logger.info(key='rdt_log', data=person_details_for_test) # if positive, refer for a confirmatory test at level 1a diff --git a/src/tlo/methods/tb.py b/src/tlo/methods/tb.py index 3392d90b62..623ee2e483 100644 --- a/src/tlo/methods/tb.py +++ b/src/tlo/methods/tb.py @@ -377,16 +377,16 @@ def __init__(self, name=None, resourcefilepath=None, run_with_checks=False): "length of inpatient stay for end-of-life TB patients", ), # ------------------ scale-up parameters for scenario analysis ------------------ # - "do_scaleup": Parameter( - Types.BOOL, - "argument to determine whether scale-up of program will be implemented" + "type_of_scaleup": Parameter( + Types.STRING, "argument to determine type scale-up of program which will be implemented, " + "can be 'none', 'target' or 'max'", ), "scaleup_start_year": Parameter( Types.INT, "the year when the scale-up starts (it will occur on 1st January of that year)" ), "scaleup_parameters": Parameter( - Types.DICT, + Types.DATA_FRAME, "the parameters and values changed in scenario analysis" ) } @@ -427,7 +427,7 @@ def read_parameters(self, data_folder): ) # load parameters for scale-up projections - p["scaleup_parameters"] = workbook["scaleup_parameters"].set_index('parameter')['scaleup_value'].to_dict() + p['scaleup_parameters'] = workbook["scaleup_parameters"] # 2) Get the DALY weights if "HealthBurden" in self.sim.modules.keys(): @@ -871,7 +871,7 @@ def initialise_simulation(self, sim): # 2) log at the end of the year # Optional: Schedule the scale-up of programs - if self.parameters["do_scaleup"]: + if self.parameters["type_of_scaleup"] != 'none': scaleup_start_date = Date(self.parameters["scaleup_start_year"], 1, 1) assert scaleup_start_date >= self.sim.start_date, f"Date {scaleup_start_date} is before simulation starts." sim.schedule_event(TbScaleUpEvent(self), scaleup_start_date) @@ -889,8 +889,14 @@ def initialise_simulation(self, sim): ) def update_parameters_for_program_scaleup(self): + """ options for program scale-up are 'target' or 'max' """ p = self.parameters - scaled_params = p["scaleup_parameters"] + scaled_params_workbook = p["scaleup_parameters"] + + if p['type_of_scaleup'] == 'target': + scaled_params = scaled_params_workbook.set_index('parameter')['target_value'].to_dict() + else: + scaled_params = scaled_params_workbook.set_index('parameter')['max_value'].to_dict() # scale-up TB program # use NTP treatment rates diff --git a/tests/test_htm_scaleup.py b/tests/test_htm_scaleup.py index dbb2638c88..fcb538f19c 100644 --- a/tests/test_htm_scaleup.py +++ b/tests/test_htm_scaleup.py @@ -84,7 +84,7 @@ def test_hiv_scale_up(seed): check_initial_params(sim) # update parameters to instruct there to be a scale-up - sim.modules["Hiv"].parameters["do_scaleup"] = True + sim.modules["Hiv"].parameters["type_of_scaleup"] = 'target' sim.modules["Hiv"].parameters["scaleup_start_year"] = scaleup_start_year # Make the population @@ -95,13 +95,13 @@ def test_hiv_scale_up(seed): assert sim.modules["Hiv"].parameters["beta"] < original_params.loc[ original_params.parameter_name == "beta", "value"].values[0] assert sim.modules["Hiv"].parameters["prob_prep_for_fsw_after_hiv_test"] == new_params.loc[ - new_params.parameter == "prob_prep_for_fsw_after_hiv_test", "scaleup_value"].values[0] + new_params.parameter == "prob_prep_for_fsw_after_hiv_test", "target_value"].values[0] assert sim.modules["Hiv"].parameters["prob_prep_for_agyw"] == new_params.loc[ - new_params.parameter == "prob_prep_for_agyw", "scaleup_value"].values[0] + new_params.parameter == "prob_prep_for_agyw", "target_value"].values[0] assert sim.modules["Hiv"].parameters["probability_of_being_retained_on_prep_every_3_months"] == new_params.loc[ - new_params.parameter == "probability_of_being_retained_on_prep_every_3_months", "scaleup_value"].values[0] + new_params.parameter == "probability_of_being_retained_on_prep_every_3_months", "target_value"].values[0] assert sim.modules["Hiv"].parameters["prob_circ_after_hiv_test"] == new_params.loc[ - new_params.parameter == "prob_circ_after_hiv_test", "scaleup_value"].values[0] + new_params.parameter == "prob_circ_after_hiv_test", "target_value"].values[0] # check malaria parameters unchanged mal_original_params = pd.read_excel(resourcefilepath / 'malaria' / 'ResourceFile_malaria.xlsx', @@ -154,11 +154,11 @@ def test_htm_scale_up(seed): check_initial_params(sim) # update parameters - sim.modules["Hiv"].parameters["do_scaleup"] = True + sim.modules["Hiv"].parameters["type_of_scaleup"] = 'target' sim.modules["Hiv"].parameters["scaleup_start_year"] = scaleup_start_year - sim.modules["Tb"].parameters["do_scaleup"] = True + sim.modules["Tb"].parameters["type_of_scaleup"] = 'target' sim.modules["Tb"].parameters["scaleup_start_year"] = scaleup_start_year - sim.modules["Malaria"].parameters["do_scaleup"] = True + sim.modules["Malaria"].parameters["type_of_scaleup"] = 'target' sim.modules["Malaria"].parameters["scaleup_start_year"] = scaleup_start_year # Make the population @@ -169,42 +169,42 @@ def test_htm_scale_up(seed): assert sim.modules["Hiv"].parameters["beta"] < original_hiv_params.loc[ original_hiv_params.parameter_name == "beta", "value"].values[0] assert sim.modules["Hiv"].parameters["prob_prep_for_fsw_after_hiv_test"] == new_hiv_params.loc[ - new_hiv_params.parameter == "prob_prep_for_fsw_after_hiv_test", "scaleup_value"].values[0] + new_hiv_params.parameter == "prob_prep_for_fsw_after_hiv_test", "target_value"].values[0] assert sim.modules["Hiv"].parameters["prob_prep_for_agyw"] == new_hiv_params.loc[ - new_hiv_params.parameter == "prob_prep_for_agyw", "scaleup_value"].values[0] + new_hiv_params.parameter == "prob_prep_for_agyw", "target_value"].values[0] assert sim.modules["Hiv"].parameters["probability_of_being_retained_on_prep_every_3_months"] == new_hiv_params.loc[ - new_hiv_params.parameter == "probability_of_being_retained_on_prep_every_3_months", "scaleup_value"].values[0] + new_hiv_params.parameter == "probability_of_being_retained_on_prep_every_3_months", "target_value"].values[0] assert sim.modules["Hiv"].parameters["prob_circ_after_hiv_test"] == new_hiv_params.loc[ - new_hiv_params.parameter == "prob_circ_after_hiv_test", "scaleup_value"].values[0] + new_hiv_params.parameter == "prob_circ_after_hiv_test", "target_value"].values[0] # check malaria parameters changed new_mal_params = pd.read_excel(resourcefilepath / 'malaria' / 'ResourceFile_malaria.xlsx', sheet_name="scaleup_parameters") assert sim.modules["Malaria"].parameters["prob_malaria_case_tests"] == new_mal_params.loc[ - new_mal_params.parameter == "prob_malaria_case_tests", "scaleup_value"].values[0] + new_mal_params.parameter == "prob_malaria_case_tests", "target_value"].values[0] assert sim.modules["Malaria"].parameters["rdt_testing_rates"]["Rate_rdt_testing"].eq(new_mal_params.loc[ - new_mal_params.parameter == "rdt_testing_rates", "scaleup_value"].values[0]).all() + new_mal_params.parameter == "rdt_testing_rates", "target_value"].values[0]).all() # some irs coverage levels should now = 1.0 assert sim.modules["Malaria"].itn_irs['irs_rate'].any() == 1.0 # itn rates for 2019 onwards assert sim.modules["Malaria"].parameters["itn"] == new_mal_params.loc[ - new_mal_params.parameter == "itn", "scaleup_value"].values[0] + new_mal_params.parameter == "itn", "target_value"].values[0] # check tb parameters changed new_tb_params = pd.read_excel(resourcefilepath / 'ResourceFile_TB.xlsx', sheet_name="scaleup_parameters") assert sim.modules["Tb"].parameters["rate_testing_active_tb"]["treatment_coverage"].eq(new_tb_params.loc[ - new_tb_params.parameter == "tb_treatment_coverage", "scaleup_value"].values[0]).all() + new_tb_params.parameter == "tb_treatment_coverage", "target_value"].values[0]).all() assert sim.modules["Tb"].parameters["prob_tx_success_ds"] == new_tb_params.loc[ - new_tb_params.parameter == "tb_prob_tx_success_ds", "scaleup_value"].values[0] + new_tb_params.parameter == "tb_prob_tx_success_ds", "target_value"].values[0] assert sim.modules["Tb"].parameters["prob_tx_success_mdr"] == new_tb_params.loc[ - new_tb_params.parameter == "tb_prob_tx_success_mdr", "scaleup_value"].values[0] + new_tb_params.parameter == "tb_prob_tx_success_mdr", "target_value"].values[0] assert sim.modules["Tb"].parameters["prob_tx_success_0_4"] == new_tb_params.loc[ - new_tb_params.parameter == "tb_prob_tx_success_0_4", "scaleup_value"].values[0] + new_tb_params.parameter == "tb_prob_tx_success_0_4", "target_value"].values[0] assert sim.modules["Tb"].parameters["prob_tx_success_5_14"] == new_tb_params.loc[ - new_tb_params.parameter == "tb_prob_tx_success_5_14", "scaleup_value"].values[0] + new_tb_params.parameter == "tb_prob_tx_success_5_14", "target_value"].values[0] assert sim.modules["Tb"].parameters["first_line_test"] == new_tb_params.loc[ - new_tb_params.parameter == "first_line_test", "scaleup_value"].values[0] + new_tb_params.parameter == "first_line_test", "target_value"].values[0]