Remove mode 0 option from HealthSystem (#1690)

* Remove mode 0 option from HealthSystem

* Remove mode = 0 from depression and epilepsy tests

* Style fix

* Remove mention of mode 0 from malaria and CMD tests

---------

Co-authored-by: Tim Hallett <[email protected]>

Author: marghe-molaro

src/tlo/methods/healthsystem.py

@@ -325,11 +325,11 @@ class HealthSystem(Module):
 
         # Mode Appt Constraints
         'mode_appt_constraints': Parameter(
-            Types.INT, 'Integer code in `{0, 1, 2}` determining mode of constraints with regards to officer numbers '
-                       'and time - 0: no constraints, all HSI events run with no squeeze factor, 1: elastic constraints'
-                       ', all HSI events run with squeeze factor, 2: hard constraints, only HSI events with no squeeze '
-                       'factor run. N.B. This parameter is over-ridden if an argument is provided'
-                       ' to the module initialiser.',
+            Types.INT, 'Integer code in `{1, 2}` determining mode of constraints with regards to officer numbers '
+                       'and time - 1: elastic constraints, all HSI events run with squeeze factor, provided '
+                       'officers required to deliver the HSI have capabilities > 0'
+                       '2: hard constraints, only HSI events with no squeeze factor run. N.B. This parameter'
+                       'is over-ridden if an argument is provided to the module initialiser.',
         ),
         'mode_appt_constraints_postSwitch': Parameter(
             Types.INT, 'Mode considered after a mode switch in year_mode_switch.'),
@@ -368,10 +368,10 @@ def __init__(
         """
         :param name: Name to use for module, defaults to module class name if ``None``.
         :param service_availability: A list of treatment IDs to allow.
-        :param mode_appt_constraints: Integer code in ``{0, 1, 2}`` determining mode of
-            constraints with regards to officer numbers and time - 0: no constraints,
-            all HSI events run with no squeeze factor, 1: elastic constraints, all HSI
-            events run with squeeze factor, 2: hard constraints, only HSI events with
+        :param mode_appt_constraints: Integer code in ``{1, 2}`` determining mode of
+            constraints with regards to officer numbers and time - 1: elastic constraints, all HSI
+            events run with squeeze factor provided officers required have nonzero capabilities,
+            2: hard constraints, only HSI events with
             no squeeze factor run.
         :param cons_availability: If 'default' then use the availability specified in the ResourceFile; if 'none', then
         let no consumable be ever be available; if 'all', then all consumables are always available. When using 'all'
@@ -422,7 +422,7 @@ def __init__(
 
         self.mode_appt_constraints = None  # Will be the final determination of the `mode_appt_constraints'
         if mode_appt_constraints is not None:
-            assert mode_appt_constraints in {0, 1, 2}
+            assert mode_appt_constraints in {1, 2}
         self.arg_mode_appt_constraints = mode_appt_constraints
 
         self.rng_for_hsi_queue = None  # Will be a dedicated RNG for the purpose of randomising the queue
@@ -2020,12 +2020,12 @@ def on_end_of_year(self) -> None:
             self._write_hsi_event_counts_to_log_and_reset()
             self._write_never_ran_hsi_event_counts_to_log_and_reset()
 
-    def run_individual_level_events_in_mode_0_or_1(self,
+    def run_individual_level_events_in_mode_1(self,
                                                    _list_of_individual_hsi_event_tuples:
                                                    List[HSIEventQueueItem]) -> List:
         """Run a list of individual level events. Returns: list of events that did not run (maybe an empty list)."""
         _to_be_held_over = list()
-        assert self.mode_appt_constraints in (0, 1)
+        assert self.mode_appt_constraints == 1
 
         if _list_of_individual_hsi_event_tuples:
             # Examine total call on health officers time from the HSI events in the list:
@@ -2044,18 +2044,12 @@ def run_individual_level_events_in_mode_0_or_1(self,
                 self.running_total_footprint.update(footprint)
 
             # Estimate Squeeze-Factors for today
-            if self.mode_appt_constraints == 0:
-                # For Mode 0 (no Constraints), the squeeze factors are all zero.
-                squeeze_factor_per_hsi_event = np.zeros(
-                    len(footprints_of_all_individual_level_hsi_event))
-            else:
-                # For Other Modes, the squeeze factors must be computed
-                squeeze_factor_per_hsi_event = self.get_squeeze_factors(
-                    footprints_per_event=footprints_of_all_individual_level_hsi_event,
-                    total_footprint=self.running_total_footprint,
-                    current_capabilities=self.capabilities_today,
-                    compute_squeeze_factor_to_district_level=self.compute_squeeze_factor_to_district_level,
-                )
+            squeeze_factor_per_hsi_event = self.get_squeeze_factors(
+                footprints_per_event=footprints_of_all_individual_level_hsi_event,
+                total_footprint=self.running_total_footprint,
+                current_capabilities=self.capabilities_today,
+                compute_squeeze_factor_to_district_level=self.compute_squeeze_factor_to_district_level,
+            )
 
             for ev_num, event in enumerate(_list_of_individual_hsi_event_tuples):
                 _priority = event.priority
@@ -2065,7 +2059,6 @@ def run_individual_level_events_in_mode_0_or_1(self,
                 # store appt_footprint before running
                 _appt_footprint_before_running = event.EXPECTED_APPT_FOOTPRINT
 
-                # Mode 0: All HSI Event run, with no squeeze
                 # Mode 1: All HSI Events run with squeeze provided latter is not inf
                 ok_to_run = True
 
@@ -2106,15 +2099,13 @@ def run_individual_level_events_in_mode_0_or_1(self,
                         self.running_total_footprint -= original_call
                         self.running_total_footprint += updated_call
 
-                        # Don't recompute for mode=0
-                        if self.mode_appt_constraints != 0:
-                            squeeze_factor_per_hsi_event = self.get_squeeze_factors(
-                                footprints_per_event=footprints_of_all_individual_level_hsi_event,
-                                total_footprint=self.running_total_footprint,
-                                current_capabilities=self.capabilities_today,
-                                compute_squeeze_factor_to_district_level=self.
-                                compute_squeeze_factor_to_district_level,
-                            )
+                        squeeze_factor_per_hsi_event = self.get_squeeze_factors(
+                            footprints_per_event=footprints_of_all_individual_level_hsi_event,
+                            total_footprint=self.running_total_footprint,
+                            current_capabilities=self.capabilities_today,
+                            compute_squeeze_factor_to_district_level=self.
+                            compute_squeeze_factor_to_district_level,
+                        )
 
                     else:
                         # no actual footprint is returned so take the expected initial declaration as the actual,
@@ -2277,7 +2268,7 @@ def _get_events_due_today(self) -> List:
 
         return due_today
 
-    def process_events_mode_0_and_1(self, hold_over: List[HSIEventQueueItem]) -> None:
+    def process_events_mode_1(self, hold_over: List[HSIEventQueueItem]) -> None:
         while True:
             # Get the events that are due today:
             list_of_individual_hsi_event_tuples_due_today = self._get_events_due_today()
@@ -2296,7 +2287,7 @@ def process_events_mode_0_and_1(self, hold_over: List[HSIEventQueueItem]) -> Non
                     list_of_individual_hsi_event_tuples_due_today_that_have_essential_equipment.append(item)
 
             # Try to run the list of individual-level events that have their essential equipment
-            _to_be_held_over = self.module.run_individual_level_events_in_mode_0_or_1(
+            _to_be_held_over = self.module.run_individual_level_events_in_mode_1(
                 list_of_individual_hsi_event_tuples_due_today_that_have_essential_equipment,
             )
             hold_over.extend(_to_be_held_over)
@@ -2494,9 +2485,9 @@ def process_events_mode_2(self, hold_over: List[HSIEventQueueItem]) -> None:
         # were exhausted, so here we traverse the queue again to ensure that if any events expired were
         # left unchecked they are properly removed from the queue, and did_not_run() is invoked for all
         # postponed events. (This should still be more efficient than querying the queue as done in
-        # mode_appt_constraints = 0 and 1 while ensuring mid-day effects are avoided.)
+        # mode_appt_constraints = 1 while ensuring mid-day effects are avoided.)
         # We also schedule a call_never_run for any HSI below the lowest_priority_considered,
-        # in case any of them where left in the queue due to a transition from mode 0/1 to mode 2
+        # in case any of them where left in the queue due to a transition from mode 1 to mode 2
         while len(self.module.HSI_EVENT_QUEUE) > 0:
 
             next_event_tuple = hp.heappop(self.module.HSI_EVENT_QUEUE)
@@ -2527,7 +2518,7 @@ def process_events_mode_2(self, hold_over: List[HSIEventQueueItem]) -> None:
             elif self.sim.date < next_event_tuple.topen:
                 # The event is not yet due (before topen). Do not stop querying the queue here if we have
                 # reached the lowest_priority_considered, as we want to make sure HSIs with lower priority
-                # (which may have been scheduled during a prior mode 0/1 period) are flushed from the queue.
+                # (which may have been scheduled during a prior mode 1 period) are flushed from the queue.
                 hp.heappush(list_of_events_not_due_today, next_event_tuple)
 
             else:
@@ -2603,11 +2594,11 @@ def apply(self, population):
         # Create hold-over list. This will hold events that cannot occur today before they are added back to the queue.
         hold_over = list()
 
-        if self.module.mode_appt_constraints in (0, 1):
+        if self.module.mode_appt_constraints == 1:
             # Run all events due today, repeating the check for due events until none are due
             # (this allows for HSI that are added to the queue in the course of other HSI
             # for this today to be run this day).
-            self.process_events_mode_0_and_1(hold_over)
+            self.process_events_mode_1(hold_over)
 
         elif self.module.mode_appt_constraints == 2:
             self.process_events_mode_2(hold_over)

tests/test_cardiometabolicdisorders.py

@@ -331,7 +331,7 @@ def make_simulation_health_system_functional(seed, cons_availability='all'):
     # Register the appropriate modules
     sim.register(demography.Demography(),
                  enhanced_lifestyle.Lifestyle(),
-                 healthsystem.HealthSystem(disable=False, mode_appt_constraints=0,
+                 healthsystem.HealthSystem(disable=False, mode_appt_constraints=1,
                                            cons_availability=cons_availability),
                  symptommanager.SymptomManager(),
                  healthseekingbehaviour.HealthSeekingBehaviour(),

tests/test_depression.py

@@ -122,7 +122,7 @@ def test_hsi_functions(tmpdir, seed):
     sim.register(demography.Demography(),
                  simplified_births.SimplifiedBirths(),
                  enhanced_lifestyle.Lifestyle(),
-                 healthsystem.HealthSystem(mode_appt_constraints=0, cons_availability='all',
+                 healthsystem.HealthSystem(mode_appt_constraints=1, cons_availability='all',
                                            hsi_event_count_log_period="simulation"),
                  symptommanager.SymptomManager(),
                  healthseekingbehaviour.HealthSeekingBehaviour(),
@@ -179,7 +179,7 @@ def test_hsi_functions_no_medication_available(tmpdir, seed):
     sim.register(demography.Demography(),
                  simplified_births.SimplifiedBirths(),
                  enhanced_lifestyle.Lifestyle(),
-                 healthsystem.HealthSystem(mode_appt_constraints=0, cons_availability='none',
+                 healthsystem.HealthSystem(mode_appt_constraints=1, cons_availability='none',
                                            hsi_event_count_log_period="simulation"),
                  symptommanager.SymptomManager(),
                  healthseekingbehaviour.HealthSeekingBehaviour(),

tests/test_epilepsy.py

@@ -27,7 +27,7 @@ def simulation(seed):
     sim.register(
         demography.Demography(),
         enhanced_lifestyle.Lifestyle(),
-        healthsystem.HealthSystem( mode_appt_constraints=0),
+        healthsystem.HealthSystem( mode_appt_constraints=1),
         healthburden.HealthBurden(),
         healthseekingbehaviour. HealthSeekingBehaviour(),
         symptommanager.SymptomManager(),

tests/test_healthsystem.py

@@ -240,106 +240,6 @@ def test_policy_has_no_effect_on_mode1(tmpdir, seed):
                                       output[i]['tlo.methods.healthsystem']['HSI_Event'])
 
 
-@pytest.mark.slow
-def test_run_in_mode_0_with_capacity(tmpdir, seed):
-    # Events should run and there be no squeeze factors
-    # (Mode 0 -> No Constraints)
-
-    # Establish the simulation object
-    sim = Simulation(
-        start_date=start_date,
-        seed=seed,
-        log_config={
-            "filename": "log",
-            "directory": tmpdir,
-            "custom_levels": {
-                "tlo.methods.healthsystem": logging.DEBUG,
-            }
-        }, resourcefilepath=resourcefilepath
-    )
-
-    # Define the service availability
-    service_availability = ['*']
-
-    # Register the core modules
-    sim.register(demography.Demography(),
-                 simplified_births.SimplifiedBirths(),
-                 enhanced_lifestyle.Lifestyle(),
-                 healthsystem.HealthSystem(service_availability=service_availability, capabilities_coefficient=1.0,
-                                           mode_appt_constraints=0),
-                 symptommanager.SymptomManager(),
-                 healthseekingbehaviour.HealthSeekingBehaviour(),
-                 mockitis.Mockitis(),
-                 chronicsyndrome.ChronicSyndrome(),
-                 )
-
-    # Run the simulation
-    sim.make_initial_population(n=popsize)
-    sim.simulate(end_date=end_date)
-    check_dtypes(sim)
-
-    # read the results
-    output = parse_log_file(sim.log_filepath, level=logging.DEBUG)
-
-    # Do the checks for health system appts
-    assert len(output['tlo.methods.healthsystem']['HSI_Event']) > 0
-    assert output['tlo.methods.healthsystem']['HSI_Event']['did_run'].all()
-    assert (output['tlo.methods.healthsystem']['HSI_Event']['Squeeze_Factor'] == 0.0).all()
-
-    # Check that some Mockitis cured occurred (though health system)
-    assert any(sim.population.props['mi_status'] == 'P')
-
-
-@pytest.mark.slow
-def test_run_in_mode_0_no_capacity(tmpdir, seed):
-    # Every events should run (no did_not_run) and no squeeze factors
-    # (Mode 0 -> No Constraints)
-
-    # Establish the simulation object
-    sim = Simulation(
-        start_date=start_date,
-        seed=seed,
-        log_config={
-            "filename": "log",
-            "directory": tmpdir,
-            "custom_levels": {
-                "tlo.methods.healthsystem": logging.DEBUG,
-            }
-        }, resourcefilepath=resourcefilepath
-    )
-
-    # Define the service availability
-    service_availability = ['*']
-
-    # Register the core modules
-    sim.register(demography.Demography(),
-                 simplified_births.SimplifiedBirths(),
-                 healthsystem.HealthSystem(service_availability=service_availability, capabilities_coefficient=0.0,
-                                           mode_appt_constraints=0),
-                 symptommanager.SymptomManager(),
-                 healthseekingbehaviour.HealthSeekingBehaviour(),
-                 mockitis.Mockitis(),
-                 chronicsyndrome.ChronicSyndrome(),
-                 enhanced_lifestyle.Lifestyle()
-                 )
-
-    # Run the simulation
-    sim.make_initial_population(n=popsize)
-    sim.simulate(end_date=end_date)
-    check_dtypes(sim)
-
-    # read the results
-    output = parse_log_file(sim.log_filepath, level=logging.DEBUG)
-
-    # Do the checks
-    assert len(output['tlo.methods.healthsystem']['HSI_Event']) > 0
-    assert output['tlo.methods.healthsystem']['HSI_Event']['did_run'].all()
-    assert (output['tlo.methods.healthsystem']['HSI_Event']['Squeeze_Factor'] == 0.0).all()
-
-    # Check that some mockitis cured occurred (though health system)
-    assert any(sim.population.props['mi_status'] == 'P')
-
-
 @pytest.mark.slow
 def test_run_in_mode_1_with_capacity(tmpdir, seed):
     # All events should run with some zero squeeze factors
@@ -1320,8 +1220,8 @@ def test_HealthSystemChangeParameters(seed, tmpdir):
     check that this is effectual in the case of consumables."""
 
     initial_parameters = {
-        'mode_appt_constraints': 0,
-        'ignore_priority': False,
+        'mode_appt_constraints': 1,
+        'ignore_priority': True,
         'capabilities_coefficient': 0.5,
         'cons_availability': 'all',
         'beds_availability': 'default',
@@ -1330,7 +1230,7 @@ def test_HealthSystemChangeParameters(seed, tmpdir):
     }
     new_parameters = {
         'mode_appt_constraints': 2,
-        'ignore_priority': True,
+        'ignore_priority': False,
         'capabilities_coefficient': 1.0,
         'cons_availability': 'none',
         'beds_availability': 'none',
@@ -1621,7 +1521,7 @@ def initialise_simulation(self, sim):
             # Schedule an event that will schedule an HSI to run on the same day
             sim.schedule_event(Event_To_Run_On_First_Day_Of_Simulation(self, person_id=0), sim.date)
 
-    for mode in (0, 1, 2):
+    for mode in (1, 2):
 
         log_config = {
             "filename": "log",
@@ -2058,7 +1958,7 @@ def collapse_into_set_of_strings(df: pd.DataFrame) -> Set:
     # For each Mode and assumption on HR resources, test whether each type of appointment can run in each district
     # at each level for which it is defined.
     results = list()
-    for mode_appt_constraints in (0, 1, 2):
+    for mode_appt_constraints in (1, 2):
         for use_funded_or_actual_staffing in ('actual', 'funded', 'funded_plus'):
             sim = Simulation(start_date=Date(2010, 1, 1),
                              seed=seed, resourcefilepath=resourcefilepath)
@@ -2135,15 +2035,10 @@ def check_appt_works(district, level, appt_type) -> Tuple:
 
     results = pd.DataFrame(results)
 
-    # check under each mode (0, 1, 2) and each HR scenario (actual, funded, funded_plus), the hsi runs as we expect.
+    # check under each mode (1, 2) and each HR scenario (actual, funded, funded_plus), the hsi runs as we expect.
     # note that in both actual and funded scenarios, there are some required (by appt time) HCW cadres not there, i.e.,
     # those cadres with 0-minute capability.
 
-    # mode 0 - actual, funded, funded_plus -> every hsi runs, with sqz=0.0
-    # as in mode 0, we assume no constraints at all
-    assert results.loc[results['mode_appt_constraints'] == 0, 'hsi_did_run'].all()
-    assert (results.loc[results['mode_appt_constraints'] == 0, 'sqz'] == 0.0).all()
-
     # mode 1 - actual, funded, funded_plus -> every hsi that does run, has sqz in [0.0, Inf)
     res = results.loc[(results['mode_appt_constraints'] == 1) & (results['hsi_did_run'])]
     assert res['sqz'].between(0.0, float('inf'), 'left').all()
@@ -2583,7 +2478,7 @@ def initialise_simulation(self, sim):
                          resourcefilepath=resourcefilepath)
         sim.register(
             demography.Demography(),
-            healthsystem.HealthSystem(mode_appt_constraints=0),
+            healthsystem.HealthSystem(mode_appt_constraints=1),
             DummyModule(),
             # Disable sorting + checks to avoid error due to missing dependencies
             sort_modules=False,