Remove hazard event selection from calibrate.Input

Author: peanutfun

climada/test/test_util_calibrate.py

@@ -26,6 +26,7 @@ def setUp(self) -> None:
         self.hazard.event_name = ["event"] * len(self.hazard.event_id)
         self.exposure = exposure()
         self.events = [10, 1]
+        self.hazard = self.hazard.select(event_id=self.events)
         self.data = pd.DataFrame(
             data={"a": [3, 1], "b": [0.2, 0.01]}, index=self.events
         )

climada/util/calibrate/base.py

@@ -49,11 +49,10 @@ class Input:
     impact_calc_kwds : Mapping (str, Any), optional
         Keyword arguments to :py:meth:`climada.engine.impact_calc.ImpactCalc.impact`.
         Defaults to ``{"assign_centroids": False}`` (by default, centroids are assigned
-        here via the ``align`` parameter, to avoid assigning them each time the impact is
-        calculated).
-    align : bool, optional
-        Match event IDs from ``hazard`` and ``data``, and assign the centroids from
-        ``hazard`` to ``exposure``. Defaults to ``True``.
+        here via the ``assign_centroids`` parameter, to avoid assigning them each time
+        the impact is calculated).
+    assign_centroids : bool, optional
+        If ``True`` (default), assign the hazard centroids to the exposure.
     """
 
     hazard: Hazard
@@ -66,18 +65,11 @@ class Input:
     impact_calc_kwds: Mapping[str, Any] = field(
         default_factory=lambda: {"assign_centroids": False}
     )
-    align: InitVar[bool] = True
+    assign_centroids: InitVar[bool] = True
 
-    def __post_init__(self, align):
+    def __post_init__(self, assign_centroids):
         """Prepare input data"""
-        if align:
-            event_diff = np.setdiff1d(self.data.index, self.hazard.event_id)
-            if event_diff.size > 0:
-                raise RuntimeError(
-                    "Event IDs in 'data' do not match event IDs in 'hazard': \n"
-                    f"{event_diff}"
-                )
-            self.hazard = self.hazard.select(event_id=self.data.index.tolist())
+        if assign_centroids:
             self.exposure.assign_centroids(self.hazard)
 
 

climada/util/calibrate/test/test_calibrate.py

@@ -57,36 +57,33 @@ def setUp(self):
         self.cost_func = lambda impact, data: 1.0
         self.impact_func_gen = lambda **kwargs: ImpactFuncSet()
 
-    @patch("climada.util.calibrate.impact_func.np.setdiff1d")
-    def test_post_init_calls(self, setdiff1d_mock):
+    def test_post_init_calls(self):
         """Test if post_init calls stuff correctly using mocks"""
         # Create mocks
-        hazard_mock_1 = create_autospec(Hazard())
-        event_id = [10]
-        hazard_mock_1.event_id = event_id
-        hazard_mock_2 = create_autospec(Hazard())
         exposure_mock = create_autospec(Exposures())
-        setdiff1d_mock.return_value = np.array([])
 
-        # Make first hazard mock return another instance
-        hazard_mock_1.select.return_value = hazard_mock_2
-
-        # Create input
+        # Default
         input = Input(
-            hazard=hazard_mock_1,
+            hazard=self.hazard,
             exposure=exposure_mock,
             data=self.data,
             cost_func=self.cost_func,
             impact_func_gen=self.impact_func_gen,
         )
+        exposure_mock.assign_centroids.assert_called_once_with(self.hazard)
+        exposure_mock.reset_mock()
 
-        # Query checks
-        npt.assert_array_equal(setdiff1d_mock.call_args.args[0], self.data_events)
-        npt.assert_array_equal(setdiff1d_mock.call_args.args[1], event_id)
-        hazard_mock_1.select.assert_called_once_with(event_id=self.data_events)
-        self.assertNotEqual(input.hazard, hazard_mock_1)
-        self.assertEqual(input.hazard, hazard_mock_2)
-        exposure_mock.assign_centroids.assert_called_once_with(hazard_mock_2)
+        # Default
+        input = Input(
+            hazard=self.hazard,
+            exposure=exposure_mock,
+            data=self.data,
+            cost_func=self.cost_func,
+            impact_func_gen=self.impact_func_gen,
+            assign_centroids=False
+        )
+        exposure_mock.assign_centroids.assert_not_called()
+        
 
     def test_post_init(self):
         """Test if post_init results in a sensible hazard and exposure"""
@@ -100,37 +97,9 @@ def test_post_init(self):
         )
 
         # Check hazard and exposure
-        npt.assert_array_equal(input.hazard.event_id, self.data.index)
         self.assertIn("centr_", input.exposure.gdf)
         npt.assert_array_equal(input.exposure.gdf["centr_"], [0, 1, -1])
 
-    def test_non_matching_events(self):
-        """Test if non-matching events result in errors"""
-        data = pd.DataFrame(data={"a": [1, 2, 3]}, index=[9, 3, 12])
-        input_kwargs = {
-            "hazard": self.hazard,
-            "exposure": self.exposure,
-            "data": data,
-            "cost_func": self.cost_func,
-            "impact_func_gen": self.impact_func_gen,
-            "align": False,
-        }
-
-        # No error without alignment
-        Input(**input_kwargs)
-
-        # Error with alignment
-        input_kwargs.update(align=True)
-        with self.assertRaises(RuntimeError) as cm:
-            Input(**input_kwargs)
-
-        self.assertIn(
-            "Event IDs in 'data' do not match event IDs in 'hazard'", str(cm.exception)
-        )
-        self.assertIn("9", str(cm.exception))
-        self.assertIn("12", str(cm.exception))
-        self.assertNotIn("3", str(cm.exception))
-
 
 class TestOptimizer(unittest.TestCase):
     """Base class for testing optimizers. Creates an input mock"""
@@ -144,7 +113,7 @@ def setUp(self):
                 data=create_autospec(pd.DataFrame, instance=True),
                 cost_func=MagicMock(),
                 impact_func_gen=MagicMock(),
-                align=False,
+                assign_centroids=False,
             )
         )