Dynamic rescaling of HR resources (#1269)

Author: marghe-molaro

resources/healthsystem/ResourceFile_HealthSystem_parameters.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:187302cf1744ee6a9538665c5dff5650f58e4d00c8d74844ff8b569b6b38f9d1
-size 335
+oid sha256:e36cbd225191f893f2de5f0f34adc251046af5ec58daaf7c86b09a6c83c1e31d
+size 379

src/tlo/methods/healthsystem.py

@@ -554,6 +554,16 @@ class HealthSystem(Module):
                           "and custom (user can freely set these factors as parameters in the analysis).",
         ),
 
+        'dynamic_HR_scaling_factor': Parameter(
+            Types.REAL, "Factor by which HR capabilities are scaled at regular intervals of 1 year (in addition to the"
+                        " [optional] scaling with population size (controlled by `scale_HR_by_popsize`"
+        ),
+
+        'scale_HR_by_popsize': Parameter(
+            Types.BOOL, "Decide whether to scale HR capabilities by population size every year. Can be used as well as"
+                        " the dynamic_HR_scaling_factor"
+        ),
+
         'tclose_overwrite': Parameter(
             Types.INT, "Decide whether to overwrite tclose variables assigned by disease modules"),
 
@@ -904,6 +914,11 @@ def initialise_simulation(self, sim):
         sim.schedule_event(HealthSystemChangeMode(self),
                            Date(self.parameters["year_mode_switch"], 1, 1))
 
+        # Schedule recurring event which will rescale daily capabilities at regular intervals.
+        # The first event scheduled will only be used to update self.last_year_pop_size parameter,
+        # actual scaling will only take effect from 2011 onwards
+        sim.schedule_event(DynamicRescalingHRCapabilities(self), Date(sim.date) + pd.DateOffset(years=1))
+
     def on_birth(self, mother_id, child_id):
         self.bed_days.on_birth(self.sim.population.props, mother_id, child_id)
 
@@ -2842,6 +2857,33 @@ def apply(self, population):
             self.module.bed_days.availability = self._parameters['beds_availability']
 
 
+class DynamicRescalingHRCapabilities(RegularEvent, PopulationScopeEventMixin):
+    """ This event exists to scale the daily capabilities assumed at fixed time intervals"""
+    def __init__(self, module):
+        super().__init__(module, frequency=DateOffset(years=1))
+        self.last_year_pop_size = self.current_pop_size  # store population size at initiation (when this class is
+        #                                                  created)
+
+    @property
+    def current_pop_size(self) -> float:
+        """Returns current population size"""
+        df = self.sim.population.props
+        return df.is_alive.sum()
+
+    def apply(self, population):
+
+        this_year_pop_size = self.current_pop_size
+
+        # Rescale by fixed amount
+        self.module._daily_capabilities *= self.module.parameters['dynamic_HR_scaling_factor']
+
+        # Rescale daily capabilities by population size, if this option is included
+        if self.module.parameters['scale_HR_by_popsize']:
+            self.module._daily_capabilities *= this_year_pop_size/self.last_year_pop_size
+
+        self.last_year_pop_size = this_year_pop_size   # Save for next year
+
+
 class HealthSystemChangeMode(RegularEvent, PopulationScopeEventMixin):
     """ This event exists to change the priority policy adopted by the
     HealthSystem at a given year.    """

tests/test_healthsystem.py

@@ -2276,4 +2276,75 @@ def get_capabilities_today(const_HR_scaling_mode: str) -> pd.Series:
     )
 
 
+def test_dynamic_HR_scaling(seed, tmpdir):
+    """Check that we can scale the minutes of time available for healthcare workers on a yearly basis based on either
+    a fixed scaling factor or population grown, or both."""
 
+    def get_initial_capabilities() -> pd.Series:
+        sim = Simulation(start_date=start_date, seed=seed)
+        sim.register(
+            demography.Demography(resourcefilepath=resourcefilepath),
+            healthsystem.HealthSystem(resourcefilepath=resourcefilepath)
+        )
+        sim.make_initial_population(n=100)
+        sim.simulate(end_date=start_date + pd.DateOffset(days=0))
+
+        return sim.modules['HealthSystem'].capabilities_today
+
+    def get_capabilities_after_two_years(dynamic_HR_scaling_factor: float, scale_HR_by_pop_size: bool) -> tuple:
+        sim = Simulation(start_date=start_date, seed=seed)
+        sim.register(
+            demography.Demography(resourcefilepath=resourcefilepath),
+            healthsystem.HealthSystem(resourcefilepath=resourcefilepath),
+            simplified_births.SimplifiedBirths(resourcefilepath=resourcefilepath),
+
+        )
+        sim.modules['HealthSystem'].parameters['dynamic_HR_scaling_factor'] = dynamic_HR_scaling_factor
+        sim.modules['HealthSystem'].parameters['scale_HR_by_popsize'] = scale_HR_by_pop_size
+        sim.make_initial_population(n=100)
+
+        # Ensure simulation lasts long enough so that current capabilities reflect that used in the third year of
+        # simulation (i.e. after two annual updates)
+        sim.simulate(end_date=start_date + pd.DateOffset(years=2, days=1))
+
+        popsize = sim.modules['Demography'].popsize_by_year
+
+        final_popsize_increase = popsize[2012]/popsize[2010]
+
+        return sim.modules['HealthSystem'].capabilities_today, final_popsize_increase
+
+    dynamic_HR_scaling_factor = 1.05
+
+    # Get initial capabilities and remove all officers with no minutes available
+    initial_caps = get_initial_capabilities()
+    initial_caps = initial_caps[initial_caps != 0]
+
+    # Check that dynamic expansion over two years leads to expansion = dynamic_HR_scaling_factor^2
+    caps, final_popsize_increase = get_capabilities_after_two_years(
+        dynamic_HR_scaling_factor=dynamic_HR_scaling_factor,
+        scale_HR_by_pop_size=False
+    )
+    caps = caps[caps != 0]
+    ratio_in_sim = caps/initial_caps
+    expected_value = dynamic_HR_scaling_factor*dynamic_HR_scaling_factor
+    assert np.allclose(ratio_in_sim, expected_value)
+
+    # Check that expansion over two years with scaling prop to pop expansion works as expected
+    caps, final_popsize_increase = get_capabilities_after_two_years(
+        dynamic_HR_scaling_factor=1.0,
+        scale_HR_by_pop_size=True
+    )
+    caps = caps[caps != 0]
+    ratio_in_sim = caps/initial_caps
+    expected_value = final_popsize_increase
+    assert np.allclose(ratio_in_sim, expected_value)
+
+    # Check that expansion over two years with both fixed scaling and pop expansion scaling works as expected
+    caps, final_popsize_increase = get_capabilities_after_two_years(
+        dynamic_HR_scaling_factor=dynamic_HR_scaling_factor,
+        scale_HR_by_pop_size=True
+    )
+    caps = caps[caps != 0]
+    ratio_in_sim = caps/initial_caps
+    expected_value = final_popsize_increase*dynamic_HR_scaling_factor*dynamic_HR_scaling_factor
+    assert np.allclose(ratio_in_sim, expected_value)