Simplify code and tests

Author: peanutfun

climada/engine/impact_forecast.py

@@ -228,16 +228,9 @@ def min(self):
         ImpactForecast
             An ImpactForecast object with the min impact matrix and at_event.
         """
-        red_imp_mat = sparse.csr_matrix(self.imp_mat.min(axis=0))
+        red_imp_mat = self.imp_mat.min(axis=0).tocsr()
         red_at_event = np.array([red_imp_mat.sum()])
-        reduced_attrs = self._reduce_attrs("min")
         return ImpactForecast(
-            lead_time=reduced_attrs["lead_time"],
-            member=reduced_attrs["member"],
-            event_id=reduced_attrs["event_id"],
-            event_name=reduced_attrs["event_name"],
-            date=reduced_attrs["date"],
-            frequency=reduced_attrs["frequency"],
             frequency_unit=self.frequency_unit,
             coord_exp=self.coord_exp,
             crs=self.crs,
@@ -248,6 +241,7 @@ def min(self):
             unit=self.unit,
             imp_mat=red_imp_mat,
             haz_type=self.haz_type,
+            **self._reduce_attrs("min"),
         )
 
     def max(self):
@@ -264,16 +258,9 @@ def max(self):
         ImpactForecast
             An ImpactForecast object with the max impact matrix and at_event.
         """
-        red_imp_mat = sparse.csr_matrix(self.imp_mat.max(axis=0))
+        red_imp_mat = self.imp_mat.max(axis=0).tocsr()
         red_at_event = np.array([red_imp_mat.sum()])
-        reduced_attrs = self._reduce_attrs("max")
         return ImpactForecast(
-            lead_time=reduced_attrs["lead_time"],
-            member=reduced_attrs["member"],
-            event_id=reduced_attrs["event_id"],
-            event_name=reduced_attrs["event_name"],
-            date=reduced_attrs["date"],
-            frequency=reduced_attrs["frequency"],
             frequency_unit=self.frequency_unit,
             coord_exp=self.coord_exp,
             crs=self.crs,
@@ -284,6 +271,7 @@ def max(self):
             unit=self.unit,
             imp_mat=red_imp_mat,
             haz_type=self.haz_type,
+            **self._reduce_attrs("max"),
         )
 
     def mean(self):
@@ -301,14 +289,7 @@ def mean(self):
         """
         red_imp_mat = sparse.csr_matrix(self.imp_mat.mean(axis=0))
         red_at_event = np.array([red_imp_mat.sum()])
-        reduced_attrs = self._reduce_attrs("mean")
         return ImpactForecast(
-            lead_time=reduced_attrs["lead_time"],
-            member=reduced_attrs["member"],
-            event_id=reduced_attrs["event_id"],
-            event_name=reduced_attrs["event_name"],
-            date=reduced_attrs["date"],
-            frequency=reduced_attrs["frequency"],
             frequency_unit=self.frequency_unit,
             coord_exp=self.coord_exp,
             crs=self.crs,
@@ -319,4 +300,5 @@ def mean(self):
             unit=self.unit,
             imp_mat=red_imp_mat,
             haz_type=self.haz_type,
+            **self._reduce_attrs("mean"),
         )

climada/engine/test/test_impact_forecast.py

@@ -167,41 +167,38 @@ def test_impact_forecast_blocked_methods(impact_forecast):
         impact_forecast.calc_freq_curve(np.array([10, 50, 100]))
 
 
-def test_impact_forecast_mean_min_max(impact_forecast):
+@pytest.fixture
+def impact_forecast_stats(impact_kwargs, lead_time, member):
+    max_index = 4
+    for key, val in impact_kwargs.items():
+        if isinstance(val, (np.ndarray, list)):
+            impact_kwargs[key] = val[:max_index]
+        elif isinstance(val, csr_matrix):
+            impact_kwargs[key] = val[:max_index, :]
+    impact_kwargs["imp_mat"] = csr_matrix([[1, 0], [0, 1], [3, 2], [2, 3]])
+    impact_kwargs["at_event"] = np.array([1, 1, 5, 5])
+    return ImpactForecast(
+        lead_time=lead_time[:max_index], member=member[:max_index], **impact_kwargs
+    )
+
+
+@pytest.mark.parametrize("attr", ["min", "mean", "max"])
+def test_impact_forecast_min_mean_max(impact_forecast_stats, attr):
     """Check mean, min, and max methods for ImpactForecast"""
-    imp_fcst_mean = impact_forecast.mean()
-    imp_fcst_min = impact_forecast.min()
-    imp_fcst_max = impact_forecast.max()
+    imp_fc_reduced = getattr(impact_forecast_stats, attr)()
 
     # assert imp_mat
     npt.assert_array_equal(
-        imp_fcst_mean.imp_mat.todense(), impact_forecast.imp_mat.todense().mean(axis=0)
+        imp_fc_reduced.imp_mat.todense(),
+        getattr(impact_forecast_stats.imp_mat.todense(), attr)(axis=0),
     )
-    npt.assert_array_equal(imp_fcst_min.imp_mat.todense(), np.array([[0, 0]]))
-    npt.assert_array_equal(imp_fcst_max.imp_mat.todense(), np.array([[31, 31]]))
-    # assert at_event
-    npt.assert_array_equal(
-        imp_fcst_mean.at_event, impact_forecast.at_event.mean()
-    )  # 134/6
-    npt.assert_array_equal(imp_fcst_min.at_event, impact_forecast.at_event.min())
-    npt.assert_array_equal(imp_fcst_max.at_event, impact_forecast.at_event.max())
+    at_event_expected = {"min": [0], "mean": [3], "max": [6]}
+    npt.assert_array_equal(imp_fc_reduced.at_event, at_event_expected[attr])
 
     # check that attributes where reduced correctly
-    assert np.isnat(imp_fcst_mean.lead_time[0])
-    assert np.isnat(imp_fcst_min.lead_time[0])
-    assert np.isnat(imp_fcst_max.lead_time[0])
-    assert imp_fcst_mean.member[0] == -1
-    assert imp_fcst_min.member[0] == -1
-    assert imp_fcst_max.member[0] == -1
-    assert imp_fcst_mean.event_name[0] == "mean"
-    assert imp_fcst_min.event_name[0] == "min"
-    assert imp_fcst_max.event_name[0] == "max"
-    assert imp_fcst_mean.event_id[0] == 0
-    assert imp_fcst_min.event_id[0] == 0
-    assert imp_fcst_max.event_id[0] == 0
-    assert imp_fcst_mean.frequency == 1
-    assert imp_fcst_min.frequency == 1
-    assert imp_fcst_max.frequency == 1
-    assert imp_fcst_mean.date == 0
-    assert imp_fcst_min.date == 0
-    assert imp_fcst_max.date == 0
+    npt.assert_array_equal(np.isnat(imp_fc_reduced.lead_time), [True])
+    npt.assert_array_equal(imp_fc_reduced.member, [-1])
+    npt.assert_array_equal(imp_fc_reduced.event_name, [attr])
+    npt.assert_array_equal(imp_fc_reduced.event_id, [0])
+    npt.assert_array_equal(imp_fc_reduced.frequency, [1])
+    npt.assert_array_equal(imp_fc_reduced.date, [0])

climada/hazard/forecast.py

@@ -149,24 +149,17 @@ def min(self):
         HazardForecast
             A HazardForecast object with the min intensity and fraction.
         """
-        red_intensity = sparse.csr_matrix(self.intensity.min(axis=0))
-        red_fraction = sparse.csr_matrix(self.fraction.min(axis=0))
-        reduced_attrs = self._reduce_attrs("min")
+        red_intensity = self.intensity.min(axis=0).tocsr()
+        red_fraction = self.fraction.min(axis=0).tocsr()
         return HazardForecast(
-            lead_time=reduced_attrs["lead_time"],
-            member=reduced_attrs["member"],
             haz_type=self.haz_type,
             pool=self.pool,
             units=self.units,
             centroids=self.centroids,
-            event_id=reduced_attrs["event_id"],
-            frequency=reduced_attrs["frequency"],
             frequency_unit=self.frequency_unit,
-            event_name=reduced_attrs["event_name"],
-            date=reduced_attrs["date"],
-            orig=reduced_attrs["orig"],
             intensity=red_intensity,
             fraction=red_fraction,
+            **self._reduce_attrs("min"),
         )
 
     def max(self):
@@ -183,24 +176,17 @@ def max(self):
         HazardForecast
             A HazardForecast object with the min intensity and fraction.
         """
-        red_intensity = sparse.csr_matrix(self.intensity.max(axis=0))
-        red_fraction = sparse.csr_matrix(self.fraction.max(axis=0))
-        reduced_attrs = self._reduce_attrs("max")
+        red_intensity = self.intensity.max(axis=0).tocsr()
+        red_fraction = self.fraction.max(axis=0).tocsr()
         return HazardForecast(
-            lead_time=reduced_attrs["lead_time"],
-            member=reduced_attrs["member"],
             haz_type=self.haz_type,
             pool=self.pool,
             units=self.units,
             centroids=self.centroids,
-            event_id=reduced_attrs["event_id"],
-            frequency=reduced_attrs["frequency"],
             frequency_unit=self.frequency_unit,
-            event_name=reduced_attrs["event_name"],
-            date=reduced_attrs["date"],
-            orig=reduced_attrs["orig"],
             intensity=red_intensity,
             fraction=red_fraction,
+            **self._reduce_attrs("max"),
         )
 
     def mean(self):
@@ -218,20 +204,13 @@ def mean(self):
         """
         red_intensity = sparse.csr_matrix(self.intensity.mean(axis=0))
         red_fraction = sparse.csr_matrix(self.fraction.mean(axis=0))
-        reduced_attrs = self._reduce_attrs("mean")
         return HazardForecast(
-            lead_time=reduced_attrs["lead_time"],
-            member=reduced_attrs["member"],
             haz_type=self.haz_type,
             pool=self.pool,
             units=self.units,
             centroids=self.centroids,
-            event_id=reduced_attrs["event_id"],
-            frequency=reduced_attrs["frequency"],
             frequency_unit=self.frequency_unit,
-            event_name=reduced_attrs["event_name"],
-            date=reduced_attrs["date"],
-            orig=reduced_attrs["orig"],
             intensity=red_intensity,
             fraction=red_fraction,
+            **self._reduce_attrs("mean"),
         )

climada/hazard/test/test_forecast.py

@@ -166,52 +166,26 @@ def test_write_read_hazard_forecast(haz_fc, tmp_path):
             npt.assert_array_equal(haz_fc.__dict__[key], haz_fc_read.__dict__[key])
 
 
-def test_hazard_forecast_mean_min_max(haz_fc):
+@pytest.mark.parametrize("attr", ["min", "mean", "max"])
+def test_hazard_forecast_mean_min_max(haz_fc, attr):
     """Check mean, min, and max methods for ImpactForecast"""
-    haz_fcst_mean = haz_fc.mean()
-    haz_fcst_min = haz_fc.min()
-    haz_fcst_max = haz_fc.max()
+    haz_fcst_reduced = getattr(haz_fc, attr)()
 
-    # assert intensity
+    # Assert sparse matrices
     npt.assert_array_equal(
-        haz_fcst_mean.intensity.todense(), haz_fc.intensity.todense().mean(axis=0)
+        haz_fcst_reduced.intensity.todense(),
+        getattr(haz_fc.intensity.todense(), attr)(axis=0),
     )
     npt.assert_array_equal(
-        haz_fcst_min.intensity.todense(), haz_fc.intensity.todense().min(axis=0)
-    )
-    npt.assert_array_equal(
-        haz_fcst_max.intensity.todense(), haz_fc.intensity.todense().max(axis=0)
-    )
-    # assert fraction
-    npt.assert_array_equal(
-        haz_fcst_mean.fraction.todense(), haz_fc.fraction.todense().mean(axis=0)
-    )
-    npt.assert_array_equal(
-        haz_fcst_min.fraction.todense(), haz_fc.fraction.todense().min(axis=0)
-    )
-    npt.assert_array_equal(
-        haz_fcst_max.fraction.todense(), haz_fc.fraction.todense().max(axis=0)
+        haz_fcst_reduced.fraction.todense(),
+        getattr(haz_fc.fraction.todense(), attr)(axis=0),
     )
 
-    # check that attributes where reduced correctly
-    assert np.isnat(haz_fcst_mean.lead_time[0])
-    assert np.isnat(haz_fcst_min.lead_time[0])
-    assert np.isnat(haz_fcst_max.lead_time[0])
-    assert haz_fcst_mean.member[0] == -1
-    assert haz_fcst_min.member[0] == -1
-    assert haz_fcst_max.member[0] == -1
-    assert haz_fcst_mean.event_name[0] == "mean"
-    assert haz_fcst_min.event_name[0] == "min"
-    assert haz_fcst_max.event_name[0] == "max"
-    assert haz_fcst_mean.event_id[0] == 0
-    assert haz_fcst_min.event_id[0] == 0
-    assert haz_fcst_max.event_id[0] == 0
-    assert haz_fcst_mean.frequency == 1
-    assert haz_fcst_min.frequency == 1
-    assert haz_fcst_max.frequency == 1
-    assert haz_fcst_mean.date == 0
-    assert haz_fcst_min.date == 0
-    assert haz_fcst_max.date == 0
-    assert np.all(haz_fcst_mean.orig)
-    assert np.all(haz_fcst_min.orig)
-    assert np.all(haz_fcst_max.orig)
+    # Check that attributes where reduced correctly
+    npt.assert_array_equal(np.isnat(haz_fcst_reduced.lead_time), [True])
+    npt.assert_array_equal(haz_fcst_reduced.member, [-1])
+    npt.assert_array_equal(haz_fcst_reduced.event_name, [attr])
+    npt.assert_array_equal(haz_fcst_reduced.event_id, [0])
+    npt.assert_array_equal(haz_fcst_reduced.frequency, [1])
+    npt.assert_array_equal(haz_fcst_reduced.date, [0])
+    npt.assert_array_equal(haz_fcst_reduced.orig, [True])