Equipment: Integration into modules

src/scripts/data_file_processing/healthsystem/equipment/equipment_availability_estimation.py

@@ -322,6 +322,12 @@
                                                   .drop_duplicates() \
                                                   .pipe(lambda x: x.set_index(x['Item_code'].astype(int)))['Category'] \
                                                   .to_dict()
+# Manually declare the price category for equipment items added manually
+# 402: Endoscope: 'Cost >= $1000'
+equipment_price_category_mapper[402] = 'Cost >= $1000'
+# 403: Electrocardiogram: 'Cost >= $1000'
+equipment_price_category_mapper[403] = 'Cost >= $1000'
+
 equipment_price_category = final_equipment_availability_export_full.index.get_level_values('Item_Code') \
                                                                          .map(equipment_price_category_mapper)
 final_equipment_availability_export_full = final_equipment_availability_export_full.groupby(

src/tlo/methods/alri.py

@@ -2551,6 +2551,8 @@ def _get_disease_classification_for_treatment_decision(self,
                  'chest_indrawing_pneumonia',       (symptoms-based assessment)
                  'cough_or_cold'                    (symptoms-based assessment)
          }."""
+        if use_oximeter:
+            self.add_equipment({'Pulse oximeter'})
 
         child_is_younger_than_2_months = age_exact_years < (2.0 / 12.0)
 
@@ -2606,6 +2608,15 @@ def _try_treatment(antibiotic_indicated: Tuple[str], oxygen_indicated: bool) ->
             oxygen_available = self._get_cons('Oxygen_Therapy')
             oxygen_provided = (oxygen_available and oxygen_indicated)
 
+            # If individual is provided with oxygen, add used equipment
+            if oxygen_provided:
+                self.add_equipment({'Oxygen cylinder, with regulator', 'Nasal Prongs'})
+
+            # If individual is provided with intravenous antibiotics, add used equipment
+            if antibiotic_provided in ('1st_line_IV_antibiotics',
+                                       'Benzylpenicillin_gentamicin_therapy_for_severe_pneumonia'):
+                self.add_equipment({'Infusion pump', 'Drip stand'})
+
             all_things_needed_available = antibiotic_available and (
                 (oxygen_available and oxygen_indicated) or (not oxygen_indicated)
             )
@@ -2687,16 +2698,20 @@ def _provide_bronchodilator_if_wheeze(self, facility_level, symptoms):
             if facility_level == '1a':
                 _ = self._get_cons('Inhaled_Brochodilator')
             else:
+                # n.b. this is never called, see issue 1172
                 _ = self._get_cons('Brochodilator_and_Steroids')
 
     def do_on_follow_up_following_treatment_failure(self):
         """Things to do for a patient who is having this HSI following a failure of an earlier treatment.
         A further drug will be used but this will have no effect on the chance of the person dying."""
 
         if self._has_staph_aureus():
-            _ = self._get_cons('2nd_line_Antibiotic_therapy_for_severe_staph_pneumonia')
+            cons_avail = self._get_cons('2nd_line_Antibiotic_therapy_for_severe_staph_pneumonia')
         else:
-            _ = self._get_cons('Ceftriaxone_therapy_for_severe_pneumonia')
+            cons_avail = self._get_cons('Ceftriaxone_therapy_for_severe_pneumonia')
+
+        if cons_avail:
+            self.add_equipment({'Infusion pump', 'Drip stand'})
 
     def apply(self, person_id, squeeze_factor):
         """Assess and attempt to treat the person."""

src/tlo/methods/bladder_cancer.py

@@ -725,14 +725,14 @@ def apply(self, person_id, squeeze_factor):
             return hs.get_blank_appt_footprint()
 
         # Check consumables are available
-        # TODO: replace with cystoscope
-        cons_avail = self.get_consumables(item_codes=self.module.item_codes_bladder_can['screening_biopsy_core'],
-                                          optional_item_codes=
-                                          self.module.item_codes_bladder_can['screening_biopsy_optional'])
+        cons_avail = self.get_consumables(item_codes=self.module.item_codes_bladder_can['screening_cystoscopy_core'],
+                                          optional_item_codes=self.module.item_codes_bladder_can[
+                                              'screening_biopsy_endoscopy_cystoscopy_optional'])
 
         if cons_avail:
             # Use a biopsy to diagnose whether the person has bladder Cancer
-            # If consumables are available, run the dx_test representing the biopsy
+            # If consumables are available update the use of equipment and run the dx_test representing the biopsy
+            self.add_equipment({'Cystoscope', 'Ordinary Microscope', 'Ultrasound scanning machine'})
 
             # Use a cystoscope to diagnose whether the person has bladder Cancer:
             dx_result = hs.dx_manager.run_dx_test(
@@ -798,14 +798,14 @@ def apply(self, person_id, squeeze_factor):
             return hs.get_blank_appt_footprint()
 
         # Check consumables are available
-        # TODO: replace with cystoscope
-        cons_avail = self.get_consumables(item_codes=self.module.item_codes_bladder_can['screening_biopsy_core'],
+        cons_avail = self.get_consumables(item_codes=self.module.item_codes_bladder_can['screening_cystoscopy_core'],
                                           optional_item_codes=self.module.item_codes_bladder_can[
-                                              'screening_biopsy_optional'])
+                                              'screening_biopsy_endoscopy_cystoscopy_optional'])
 
         if cons_avail:
             # Use a biopsy to diagnose whether the person has bladder Cancer
-            # If consumables are available, run the dx_test representing the biopsy
+            # If consumables are available log the use of equipment and run the dx_test representing the biopsy
+            self.add_equipment({'Cystoscope', 'Ordinary Microscope', 'Ultrasound scanning machine'})
 
             # Use a cystoscope to diagnose whether the person has bladder Cancer:
             dx_result = hs.dx_manager.run_dx_test(
@@ -894,7 +894,8 @@ def apply(self, person_id, squeeze_factor):
                                           self.module.item_codes_bladder_can['treatment_surgery_optional'])
 
         if cons_avail:
-            # If consumables are available and the treatment will go ahead
+            # If consumables are available and the treatment will go ahead - update the equipment
+            self.add_equipment(self.healthcare_system.equipment.from_pkg_names('Major Surgery'))
 
             # Record date and stage of starting treatment
             df.at[person_id, "bc_date_treatment"] = self.sim.date
@@ -998,7 +999,8 @@ def apply(self, person_id, squeeze_factor):
             item_codes=self.module.item_codes_bladder_can['palliation'])
 
         if cons_available:
-            # If consumables are available and the treatment will go ahead
+            # If consumables are available and the treatment will go ahead - update the equipment
+            self.add_equipment({'Infusion pump', 'Drip stand'})
 
             # Record the start of palliative care if this is first appointment
             if pd.isnull(df.at[person_id, "bc_date_palliative_care"]):

src/tlo/methods/breast_cancer.py

@@ -696,11 +696,13 @@ def apply(self, person_id, squeeze_factor):
         # Check consumables to undertake biopsy are available
         cons_avail = self.get_consumables(item_codes=self.module.item_codes_breast_can['screening_biopsy_core'],
                                           optional_item_codes=
-                                          self.module.item_codes_breast_can['screening_biopsy_optional'])
+                                          self.module.item_codes_breast_can[
+                                              'screening_biopsy_endoscopy_cystoscopy_optional'])
 
         if cons_avail:
             # Use a biopsy to diagnose whether the person has breast Cancer
-            # If consumables are available, run the dx_test representing the biopsy
+            # If consumables are available, add the used equipment and run the dx_test representing the biopsy
+            self.add_equipment({'Ultrasound scanning machine', 'Ordinary Microscope'})
 
             dx_result = hs.dx_manager.run_dx_test(
                 dx_tests_to_run='biopsy_for_breast_cancer_given_breast_lump_discernible',
@@ -764,8 +766,6 @@ def apply(self, person_id, squeeze_factor):
         df = self.sim.population.props
         hs = self.sim.modules["HealthSystem"]
 
-        # todo: request consumables needed for this
-
         if not df.at[person_id, 'is_alive']:
             return hs.get_blank_appt_footprint()
 
@@ -798,7 +798,9 @@ def apply(self, person_id, squeeze_factor):
         )
 
         if cons_available:
-            # If consumables, treatment will go ahead
+            # If consumables are available and the treatment will go ahead - add the used equipment
+            self.add_equipment(self.healthcare_system.equipment.from_pkg_names('Major Surgery'))
+
             # Log the use of adjuvant chemotherapy
             self.get_consumables(
                 item_codes=self.module.item_codes_breast_can['treatment_chemotherapy'],
@@ -906,7 +908,8 @@ def apply(self, person_id, squeeze_factor):
             item_codes=self.module.item_codes_breast_can['palliation'])
 
         if cons_available:
-            # If consumables are available and the treatment will go ahead
+            # If consumables are available and the treatment will go ahead - add the used equipment
+            self.add_equipment({'Infusion pump', 'Drip stand'})
 
             # Record the start of palliative care if this is first appointment
             if pd.isnull(df.at[person_id, "brc_date_palliative_care"]):

src/tlo/methods/cancer_consumables.py

@@ -15,16 +15,16 @@ def get_consumable_item_codes_cancers(self) -> Dict[str, int]:
     cons_dict = dict()
 
     # Add items that are needed for all cancer modules
-    cons_dict['screening_biopsy_core'] = \
-        {get_item_code("Biopsy needle"): 1}
-
-    cons_dict['screening_biopsy_optional'] = \
+    cons_dict['screening_biopsy_endoscopy_cystoscopy_optional'] = \
         {get_item_code("Specimen container"): 1,
          get_item_code("Lidocaine HCl (in dextrose 7.5%), ampoule 2 ml"): 1,
          get_item_code("Gauze, absorbent 90cm x 40m_each_CMST"): 30,
          get_item_code("Disposables gloves, powder free, 100 pieces per box"): 1,
          get_item_code("Syringe, needle + swab"): 1}
 
+    cons_dict['screening_biopsy_core'] = \
+        {get_item_code("Biopsy needle"): 1}
+
     cons_dict['treatment_surgery_core'] = \
         {get_item_code("Halothane (fluothane)_250ml_CMST"): 100,
          get_item_code("Scalpel blade size 22 (individually wrapped)_100_CMST"): 1}
@@ -69,23 +69,9 @@ def get_consumable_item_codes_cancers(self) -> Dict[str, int]:
         cons_dict['screening_cystoscopy_core'] = \
             {get_item_code("Cystoscope"): 1}
 
-        cons_dict['screening_cystoscope_optional'] = \
-            {get_item_code("Specimen container"): 1,
-             get_item_code("Lidocaine HCl (in dextrose 7.5%), ampoule 2 ml"): 1,
-             get_item_code("Gauze, absorbent 90cm x 40m_each_CMST"): 30,
-             get_item_code("Disposables gloves, powder free, 100 pieces per box"): 1,
-             get_item_code("Syringe, needle + swab"): 1}
-
     elif 'OesophagealCancer' == self.name:
 
-        cons_dict['screening_endoscope_core'] = \
+        cons_dict['screening_endoscopy_core'] = \
             {get_item_code("Endoscope"): 1}
 
-        cons_dict['screening_endoscope_optional'] = \
-            {get_item_code("Specimen container"): 1,
-             get_item_code("Gauze, absorbent 90cm x 40m_each_CMST"): 30,
-             get_item_code("Lidocaine HCl (in dextrose 7.5%), ampoule 2 ml"): 1,
-             get_item_code("Disposables gloves, powder free, 100 pieces per box"): 1,
-             get_item_code("Syringe, needle + swab"): 1}
-
     return cons_dict

src/tlo/methods/cardio_metabolic_disorders.py

@@ -1435,6 +1435,7 @@ def apply(self, person_id, squeeze_factor):
             return hs.get_blank_appt_footprint()
 
         # Run a test to diagnose whether the person has condition:
+        self.add_equipment({'Blood pressure machine'})
         dx_result = hs.dx_manager.run_dx_test(
             dx_tests_to_run='assess_hypertension',
             hsi_event=self
@@ -1487,6 +1488,9 @@ def do_for_each_condition(self, _c) -> bool:
         if df.at[person_id, f'nc_{_c}_ever_diagnosed']:
             return
 
+        if _c == 'chronic_ischemic_heart_disease':
+            self.add_equipment({'Electrocardiogram', 'Stethoscope'})
+
         # Run a test to diagnose whether the person has condition:
         dx_result = hs.dx_manager.run_dx_test(
             dx_tests_to_run=f'assess_{_c}',
@@ -1519,6 +1523,11 @@ def apply(self, person_id, squeeze_factor):
             return hs.get_blank_appt_footprint()
 
         # Do test and trigger treatment (if necessary) for each condition:
+        if set(self.conditions_to_investigate).intersection(
+            ['diabetes', 'chronic_kidney_disease', 'chronic_ischemic_hd']
+        ):
+            self.add_equipment({'Analyser, Haematology', 'Analyser, Combined Chemistry and Electrolytes'})
+
         hsi_scheduled = [self.do_for_each_condition(_c) for _c in self.conditions_to_investigate]
 
         # If no follow-up treatment scheduled but the person has at least 2 risk factors, start weight loss treatment
@@ -1542,6 +1551,7 @@ def apply(self, person_id, squeeze_factor):
             and (self.module.rng.rand() < self.module.parameters['hypertension_hsi']['pr_assessed_other_symptoms'])
         ):
             # Run a test to diagnose whether the person has condition:
+            self.add_equipment({'Blood pressure machine'})
             dx_result = hs.dx_manager.run_dx_test(
                 dx_tests_to_run='assess_hypertension',
                 hsi_event=self
@@ -1589,6 +1599,8 @@ def apply(self, person_id, squeeze_factor):
 
         # Don't advise those with CKD to lose weight, but do so for all other conditions if BMI is higher than normal
         if self.condition != 'chronic_kidney_disease' and (df.at[person_id, 'li_bmi'] > 2):
+            self.add_equipment({'Weighing scale'})
+
             self.sim.population.props.at[person_id, 'nc_ever_weight_loss_treatment'] = True
             # Schedule a post-weight loss event for individual to potentially lose weight in next 6-12 months:
             self.sim.schedule_event(CardioMetabolicDisordersWeightLossEvent(m, person_id),
@@ -1749,6 +1761,12 @@ def do_for_each_event_to_be_investigated(self, _ev):
         df = self.sim.population.props
 
         # Run a test to diagnose whether the person has condition:
+        if _ev == 'ever_stroke':
+            self.add_equipment({'Computed Tomography (CT machine)', 'CT scanner accessories'})
+
+        if _ev == 'ever_heart_attack':
+            self.add_equipment({'Electrocardiogram'})
+
         dx_result = self.sim.modules['HealthSystem'].dx_manager.run_dx_test(
             dx_tests_to_run=f'assess_{_ev}',
             hsi_event=self
@@ -1808,6 +1826,7 @@ def apply(self, person_id, squeeze_factor):
             data=('This is HSI_CardioMetabolicDisorders_SeeksEmergencyCareAndGetsTreatment: '
                   f'The squeeze-factor is {squeeze_factor}.'),
         )
+        self.add_equipment(self.healthcare_system.equipment.from_pkg_names('ICU'))
 
         for _ev in self.events_to_investigate:
             self.do_for_each_event_to_be_investigated(_ev)