Allow for multiple options in the GlobalTaskShifting resource file. This will be required for comparing scenarios

Author: marghe-molaro

resources/healthsystem/ResourceFile_HealthSystem_parameters.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cd5b508bfbb7b430cc05f116fd92df79e4663aff9d480e4ebd94dfa73530677e
-size 420
+oid sha256:df273f1a413b6d6c2cc81f392aa62e00fea78f67631d2bc802a78e3474a7356d
+size 426

src/tlo/methods/healthsystem.py

@@ -564,9 +564,14 @@ class HealthSystem(Module):
                         " the dynamic_HR_scaling_factor"
         ),
 
-        'include_task_shifting': Parameter(
-            Types.BOOL, "Decide whether to allow for task-shifting in mode 2"
-        ),
+        'global_task_shifting_mode': Parameter(
+            Types.STRING, "Name of global task-shifting mode adopted"),
+        
+        'global_task_shifting': Parameter(
+            Types.DICT, "Global task-shifting policy adopted by the health care system. It includes a list of the officers"
+                        " eligible for task shifting. For each of those officers, it specifies which officers"
+                        " can take over the officer's tasks, and a factor explaining how the originally scheduled time "
+                        " should be scaled if performed by a different officer."),
 
         'tclose_overwrite': Parameter(
             Types.INT, "Decide whether to overwrite tclose variables assigned by disease modules"),
@@ -603,7 +608,7 @@ def __init__(
         beds_availability: Optional[str] = None,
         randomise_queue: bool = True,
         ignore_priority: bool = False,
-        include_task_shifting: bool = False,
+        global_task_shifting_mode: Optional[str] = None,
         policy_name: Optional[str] = None,
         capabilities_coefficient: Optional[float] = None,
         use_funded_or_actual_staffing: Optional[str] = None,
@@ -665,14 +670,6 @@ def __init__(
         assert not (ignore_priority and policy_name is not None), (
             'Cannot adopt a priority policy if the priority will be then ignored'
         )
-        
-        # Global task-shifting options. The key in the dictionary refers to the officer
-        # eligible for task shifting, while the values refer to the officers that can take
-        # over the officer's tasks. The numbers refer to the factor by which appt time will
-        # have to be scaled if task is performed by alternative officer.
-        self.global_task_shifting = {
-            'Pharmacy': (['Nursing_and_Midwifery', 'Clinical'], [1.5,1]),
-        }
 
         self.disable = disable
         self.disable_and_reject_all = disable_and_reject_all
@@ -689,8 +686,6 @@ def __init__(
 
         self.ignore_priority = ignore_priority
 
-        self.include_task_shifting = include_task_shifting
-
         # This default value will be overwritten if assumed policy is not None
         self.lowest_priority_considered = 2
 
@@ -701,6 +696,8 @@ def __init__(
                                        'VerticalProgrammes', 'ClinicallyVulnerable', 'EHP_III',
                                        'LCOA_EHP']
         self.arg_policy_name = policy_name
+        
+        self.arg_global_task_shifting_mode = global_task_shifting_mode
 
         self.tclose_overwrite = None
         self.tclose_days_offset_overwrite = None
@@ -833,6 +830,11 @@ def read_parameters(self, data_folder):
         self.parameters['priority_rank'] = pd.read_excel(path_to_resourcefiles_for_healthsystem / 'priority_policies' /
                                                          'ResourceFile_PriorityRanking_ALLPOLICIES.xlsx',
                                                          sheet_name=None)
+                                                         
+        self.parameters['global_task_shifting'] = pd.read_excel(path_to_resourcefiles_for_healthsystem / 'human_resources'/
+                                                         'task_shifting'/'ResourceFile_GlobalTaskShifting.xlsx',
+                                                         sheet_name=None)
+
 
         self.parameters['const_HR_scaling_table']: Dict = pd.read_excel(
             path_to_resourcefiles_for_healthsystem /
@@ -887,6 +889,9 @@ def pre_initialise_population(self):
 
         # Set up framework for considering a priority policy
         self.setup_priority_policy()
+        
+        # Set up framework for considering a global task-shifting policy
+        self.setup_global_task_shifting(self.parameters['global_task_shifting_mode'])
 
 
     def initialise_population(self, population):
@@ -988,6 +993,37 @@ def setup_priority_policy(self):
             self.list_fasttrack.append(('hv_diagnosed', 'FT_if_Hivdiagnosed'))
         if 'Tb' in self.sim.modules:
             self.list_fasttrack.append(('tb_diagnosed', 'FT_if_tbdiagnosed'))
+            
+    def setup_global_task_shifting(self,mode):
+    
+        # Select the global task shifting mode to be considered
+        self.global_task_shifting_mode = self.get_global_task_shifting_mode_initial()
+    
+        # Load relevant sheet from resource file
+        df = self.parameters['global_task_shifting'][self.global_task_shifting_mode]
+
+        self.global_task_shifting = {}
+
+        # Iterate through the rows of the DataFrame and populate the dictionary
+        for index, row in df.iterrows():
+            officer = row['Officer']
+            alternative_officers = row['Alternative_officer'].split(',')
+            time_factor_str = str(row['Time_factor'])
+
+            # Split the string into a list of floats
+            time_factors = [float(factor) for factor in time_factor_str.split(',')]
+
+            # Create the entry in the dictionary
+            self.global_task_shifting[officer] = (alternative_officers, time_factors)
+
+        if len(self.global_task_shifting) == 0:
+            self.include_task_shifting = False
+        else:
+            self.include_task_shifting = True
+
+        # Print the resulting dictionary
+        print("self.global_task_shifting =", self.global_task_shifting)
+    
 
     def process_human_resources_files(self, use_funded_or_actual_staffing: str):
         """Create the data-structures needed from the information read into the parameters."""
@@ -1324,6 +1360,14 @@ def get_priority_policy_initial(self) -> str:
         return self.parameters['policy_name'] \
             if self.arg_policy_name is None \
             else self.arg_policy_name
+            
+    def get_global_task_shifting_mode_initial(self) -> str:
+        """Returns `priority_policy`. (Should be equal to what is specified by the parameter, but
+        overwrite with what was provided in argument if an argument was specified -- provided for backward
+        compatibility/debugging.)"""
+        return self.parameters['global_task_shifting_mode'] \
+            if self.arg_global_task_shifting_mode is None \
+            else self.arg_global_task_shifting_mode
 
     def load_priority_policy(self, policy):
 
@@ -2922,7 +2966,6 @@ class HealthSystemChangeParameters(Event, PopulationScopeEventMixin):
     """Event that causes certain internal parameters of the HealthSystem to be changed; specifically:
         * `mode_appt_constraints`
         * `ignore_priority`
-        * `include_task_shifting`
         * `capabilities_coefficient`
         * `cons_availability`
         * `beds_availability`
@@ -2939,9 +2982,6 @@ def apply(self, population):
 
         if 'ignore_priority' in self._parameters:
             self.module.ignore_priority = self._parameters['ignore_priority']
-            
-        if 'include_task_shifting' in self._parameters:
-            self.module.include_task_shifting = self._parameters['include_task_shifting']
 
         if 'capabilities_coefficient' in self._parameters:
             self.module.capabilities_coefficient = self._parameters['capabilities_coefficient']

tests/test_healthsystem.py

@@ -1258,15 +1258,13 @@ def test_HealthSystemChangeParameters(seed, tmpdir):
     initial_parameters = {
         'mode_appt_constraints': 0,
         'ignore_priority': False,
-        'include_task_shifting': False,
         'capabilities_coefficient': 0.5,
         'cons_availability': 'all',
         'beds_availability': 'default',
     }
     new_parameters = {
         'mode_appt_constraints': 2,
         'ignore_priority': True,
-        'include_task_shifting': True,
         'capabilities_coefficient': 1.0,
         'cons_availability': 'none',
         'beds_availability': 'none',
@@ -1282,7 +1280,6 @@ def apply(self, population):
             _params = dict()
             _params['mode_appt_constraints'] = hs.mode_appt_constraints
             _params['ignore_priority'] = hs.ignore_priority
-            _params['include_task_shifting'] = hs.include_task_shifting
             _params['capabilities_coefficient'] = hs.capabilities_coefficient
             _params['cons_availability'] = hs.consumables.cons_availability
             _params['beds_availability'] = hs.bed_days.availability
@@ -2003,7 +2000,7 @@ def simulate(task_shifting_option, Ntarget):
                      healthsystem.HealthSystem(resourcefilepath=resourcefilepath,
                                                capabilities_coefficient=1.0,
                                                mode_appt_constraints=2,
-                                               include_task_shifting=task_shifting_option,
+                                               global_task_shifting_mode=task_shifting_option,
                                                ignore_priority=False,
                                                randomise_queue=True,
                                                policy_name="",
@@ -2055,14 +2052,16 @@ def simulate(task_shifting_option, Ntarget):
         nursing_task_time = hsi1.expected_time_requests['FacilityID_' + str(facID) + '_Officer_Nursing_and_Midwifery']
         clinical_task_time = hsi1.expected_time_requests['FacilityID_' + str(facID) + '_Officer_Clinical']
 
-         # Check that first choice of task-shifting officer for Pharmacy is Nursing_and_Midwifery, and get their factor
-        assert 'Nursing_and_Midwifery' == sim.modules['HealthSystem'].global_task_shifting.get('Pharmacy')[0][0]
-        nursing_task_shift_factor = sim.modules['HealthSystem'].global_task_shifting.get('Pharmacy')[1][0]
+        if task_shifting_option == 'default':
+            nursing_task_shift_factor = 0
+        else:
+            assert 'Nursing_and_Midwifery' == sim.modules['HealthSystem'].global_task_shifting.get('Pharmacy')[0][0]
+            nursing_task_shift_factor = sim.modules['HealthSystem'].global_task_shifting.get('Pharmacy')[1][0]
 
         # Always set Pharmacy capabilities to zero. Set Clinical and Nursing capabilities such that Ntarget appointments
         # can be delivered by relying on task-shifting from Nursing only. Setting Clinical time to Ntarget x clinical_task_time
         # checks that when task-shifting first option (nurses) where always preferentially chosen over second.
-    # one (clinicians)
+        # one (clinicians)
         sim.modules['HealthSystem']._daily_capabilities['FacilityID_' + str(facID) + '_Officer_Pharmacy'] = 0.0
         sim.modules['HealthSystem']._daily_capabilities['FacilityID_' + str(facID) + '_Officer_Clinical'] = Ntarget*(clinical_task_time)
         sim.modules['HealthSystem']._daily_capabilities['FacilityID_' + str(facID) + '_Officer_Nursing_and_Midwifery'] = Ntarget*(nursing_task_time + nursing_task_shift_factor*pharmacy_task_time)
@@ -2080,14 +2079,14 @@ def simulate(task_shifting_option, Ntarget):
     # appointments can be performed iff using task-shifting
     Ntarget = 50
 
-    # Allow for task-shifting to take place, and check that all Ntarget events could run, even if Pharmacy
+    # Allow for task-shifting to take place (by adopting the naive mode), and check that all Ntarget events could run, even if Pharmacy
     # capabilities were set to zero,
-    hs_output = simulate(task_shifting_option=True, Ntarget=Ntarget)
+    hs_output = simulate(task_shifting_option='naive', Ntarget=Ntarget)
     assert hs_output['did_run'].sum() == Ntarget
 
-    # Do not allow for task-shifting to take place, and check that as a result no events could run, since
-    # Pharmacy capabilities were set to zero.
-    hs_output = simulate(task_shifting_option=False, Ntarget=Ntarget)
+    # Do not allow for task-shifting to take place (by adopting the default mode), and check that as a
+    # result no events could run, since Pharmacy capabilities were set to zero.
+    hs_output = simulate(task_shifting_option='default', Ntarget=Ntarget)
     assert hs_output['did_run'].sum() == 0