fix merge conflicts

Author: Evelyn-M

climada/engine/impact.py

@@ -2208,9 +2208,12 @@ def stack_attribute(attr_name: str) -> np.ndarray:
         imp_mat = sparse.vstack(imp_mats)
 
         # Concatenate other attributes
-        kwargs = {
-            attr: stack_attribute(attr) for attr in ("date", "frequency", "at_event")
-        }
+        concat_attrs = {
+            name.lstrip("_")  # Private attributes with getter/setter
+            for name, value in first_imp.__dict__.items()
+            if isinstance(value, np.ndarray)
+        }.difference(("event_id", "coord_exp", "eai_exp", "aai_agg"))
+        kwargs = {attr: stack_attribute(attr) for attr in concat_attrs}
 
         # Get remaining attributes from first impact object in list
         return cls(

climada/engine/impact_forecast.py

@@ -22,6 +22,7 @@
 import logging
 
 import numpy as np
+import scipy.sparse as sparse
 
 from ..util import log_level
 from ..util.checker import size
@@ -185,6 +186,123 @@ def _check_sizes(self):
         size(exp_len=num_entries, var=self.member, var_name="Forecast.member")
         size(exp_len=num_entries, var=self.lead_time, var_name="Forecast.lead_time")
 
+    def _reduce_attrs(self, event_name: str):
+        """
+        Reduce the attributes of an ImpactForecast to a single value.
+
+        Attributes are modified as follows:
+        - lead_time: set to NaT
+        - member: set to -1
+        - event_id: set to 0
+        - event_name: set to the name of the reduction method (default)
+        - date: set to 0
+        - frequency: set to 1
+
+        Parameters
+        ----------
+        event_name : str
+            The event name given to the reduced data.
+        """
+        reduced_attrs = {
+            "lead_time": np.array([np.timedelta64("NaT")]),
+            "member": np.array([-1]),
+            "event_id": np.array([0]),
+            "event_name": np.array([event_name]),
+            "date": np.array([0]),
+            "frequency": np.array([1]),
+        }
+
+        return reduced_attrs
+
+    def min(self):
+        """
+        Reduce the impact matrix and at_event of an ImpactForecast to the minimum
+        value.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        ImpactForecast
+            An ImpactForecast object with the min impact matrix and at_event.
+        """
+        red_imp_mat = self.imp_mat.min(axis=0).tocsr()
+        red_at_event = np.array([red_imp_mat.sum()])
+        return ImpactForecast(
+            frequency_unit=self.frequency_unit,
+            coord_exp=self.coord_exp,
+            crs=self.crs,
+            eai_exp=self.eai_exp,
+            at_event=red_at_event,
+            tot_value=self.tot_value,
+            aai_agg=self.aai_agg,
+            unit=self.unit,
+            imp_mat=red_imp_mat,
+            haz_type=self.haz_type,
+            **self._reduce_attrs("min"),
+        )
+
+    def max(self):
+        """
+        Reduce the impact matrix and at_event of an ImpactForecast to the maximum
+        value.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        ImpactForecast
+            An ImpactForecast object with the max impact matrix and at_event.
+        """
+        red_imp_mat = self.imp_mat.max(axis=0).tocsr()
+        red_at_event = np.array([red_imp_mat.sum()])
+        return ImpactForecast(
+            frequency_unit=self.frequency_unit,
+            coord_exp=self.coord_exp,
+            crs=self.crs,
+            eai_exp=self.eai_exp,
+            at_event=red_at_event,
+            tot_value=self.tot_value,
+            aai_agg=self.aai_agg,
+            unit=self.unit,
+            imp_mat=red_imp_mat,
+            haz_type=self.haz_type,
+            **self._reduce_attrs("max"),
+        )
+
+    def mean(self):
+        """
+        Reduce the impact matrix and at_event of an ImpactForecast to the mean value.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        ImpactForecast
+            An ImpactForecast object with the mean impact matrix and at_event.
+        """
+        red_imp_mat = sparse.csr_matrix(self.imp_mat.mean(axis=0))
+        red_at_event = np.array([red_imp_mat.sum()])
+        return ImpactForecast(
+            frequency_unit=self.frequency_unit,
+            coord_exp=self.coord_exp,
+            crs=self.crs,
+            eai_exp=self.eai_exp,
+            at_event=red_at_event,
+            tot_value=self.tot_value,
+            aai_agg=self.aai_agg,
+            unit=self.unit,
+            imp_mat=red_imp_mat,
+            haz_type=self.haz_type,
+            **self._reduce_attrs("mean"),
+        )
+
     def select(
         self,
         event_ids=None,
@@ -205,10 +323,6 @@ def select(
         lead_time : Sequence of numpy.timedelta64
             Lead times to select
 
-        Returns
-        -------
-        ImpactForecast
-
         See Also
         --------
         :py:meth:`~climada.engine.impact.Impact.select`

climada/engine/test/test_impact_forecast.py

@@ -222,17 +222,27 @@ def test_no_select(self, impact_forecast, impact_kwargs):
         assert imp_fc_select.imp_mat.shape == (0, num_centroids)
 
 
-@pytest.mark.skip("Concat from base class does not work")
-def test_impact_forecast_concat(impact_forecast, member):
+def test_impact_forecast_concat(impact_forecast, member, lead_time):
     """Check if Impact.concat works on the derived class"""
     impact_fc = ImpactForecast.concat(
         [impact_forecast, impact_forecast], reset_event_ids=True
     )
     npt.assert_array_equal(impact_fc.member, np.concatenate([member, member]))
+    npt.assert_array_equal(impact_fc.lead_time, np.concatenate([lead_time, lead_time]))
+    npt.assert_array_equal(
+        impact_fc.event_id, np.arange(impact_fc.imp_mat.shape[0]) + 1
+    )
+    npt.assert_array_equal(impact_fc.event_name, impact_forecast.event_name * 2)
+    npt.assert_array_equal(
+        impact_fc.imp_mat.toarray(),
+        np.vstack(
+            (impact_forecast.imp_mat.toarray(), impact_forecast.imp_mat.toarray())
+        ),
+    )
 
 
 def test_impact_forecast_blocked_methods(impact_forecast):
-    """Check if blocked methods raise NotImplementedError"""
+    """Check if ImpactForecast.exceedance_freq_curve raises NotImplementedError"""
     with pytest.raises(NotImplementedError):
         impact_forecast.local_exceedance_impact(np.array([10, 50, 100]))
 
@@ -241,3 +251,40 @@ def test_impact_forecast_blocked_methods(impact_forecast):
 
     with pytest.raises(NotImplementedError):
         impact_forecast.calc_freq_curve(np.array([10, 50, 100]))
+
+
+@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_fc_reduced = getattr(impact_forecast_stats, attr)()
+
+    # assert imp_mat
+    npt.assert_array_equal(
+        imp_fc_reduced.imp_mat.todense(),
+        getattr(impact_forecast_stats.imp_mat.todense(), attr)(axis=0),
+    )
+    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
+    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

@@ -24,6 +24,7 @@
 from typing import Any, Dict, List, Optional
 
 import numpy as np
+import scipy.sparse as sparse
 import xarray as xr
 
 from climada.hazard.xarray import HazardXarrayReader
@@ -174,6 +175,125 @@ def _check_sizes(self):
         size(exp_len=num_entries, var=self.member, var_name="Forecast.member")
         size(exp_len=num_entries, var=self.lead_time, var_name="Forecast.lead_time")
 
+    def _reduce_attrs(self, event_name: str):
+        """
+        Reduce the attributes of a HazardForecast to a single value.
+
+        Attributes are modified as follows:
+        - lead_time: set to NaT
+        - member: set to -1
+        - event_id: set to 0
+        - event_name: set to the name of the reduction method (default)
+        - date: set to 0
+        - frequency: set to 1
+
+        Parameters
+        ----------
+        event_name : str
+            The event_name given to the reduced data.
+        """
+        reduced_attrs = {
+            "lead_time": np.array([np.timedelta64("NaT")]),
+            "member": np.array([-1]),
+            "event_id": np.array([0]),
+            "event_name": np.array([event_name]),
+            "date": np.array([0]),
+            "frequency": np.array([1]),
+            "orig": np.array([True]),
+        }
+
+        return reduced_attrs
+
+    def min(self):
+        """
+        Reduce the intensity and fraction of a HazardForecast to the minimum
+        value.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        HazardForecast
+            A HazardForecast object with the min intensity and fraction.
+        """
+        red_intensity = self.intensity.min(axis=0).tocsr()
+        red_fraction = self.fraction.min(axis=0).tocsr()
+        return HazardForecast(
+            haz_type=self.haz_type,
+            pool=self.pool,
+            units=self.units,
+            centroids=self.centroids,
+            frequency_unit=self.frequency_unit,
+            intensity=red_intensity,
+            fraction=red_fraction,
+            **self._reduce_attrs("min"),
+        )
+
+    def max(self):
+        """
+        Reduce the intensity and fraction of a HazardForecast to the maximum
+        value.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        HazardForecast
+            A HazardForecast object with the min intensity and fraction.
+        """
+        red_intensity = self.intensity.max(axis=0).tocsr()
+        red_fraction = self.fraction.max(axis=0).tocsr()
+        return HazardForecast(
+            haz_type=self.haz_type,
+            pool=self.pool,
+            units=self.units,
+            centroids=self.centroids,
+            frequency_unit=self.frequency_unit,
+            intensity=red_intensity,
+            fraction=red_fraction,
+            **self._reduce_attrs("max"),
+        )
+
+    def mean(self):
+        """
+        Reduce the intensity and fraction of a HazardForecast to the mean value.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        HazardForecast
+            A HazardForecast object with the min intensity and fraction.
+        """
+        red_intensity = sparse.csr_matrix(self.intensity.mean(axis=0))
+        red_fraction = sparse.csr_matrix(self.fraction.mean(axis=0))
+        return HazardForecast(
+            haz_type=self.haz_type,
+            pool=self.pool,
+            units=self.units,
+            centroids=self.centroids,
+            frequency_unit=self.frequency_unit,
+            intensity=red_intensity,
+            fraction=red_fraction,
+            **self._reduce_attrs("mean"),
+        )
+
+    @classmethod
+    def concat(cls, haz_list: list):
+        """Concatenate multiple HazardForecast instances and return a new object"""
+        if len(haz_list) == 0:
+            return cls()
+        hazard = Hazard.concat(haz_list)
+        lead_time = np.concatenate(tuple(haz.lead_time for haz in haz_list))
+        member = np.concatenate(tuple(haz.member for haz in haz_list))
+        return cls.from_hazard(hazard, lead_time=lead_time, member=member)
+
     def select(
         self,
         member=None,
@@ -197,10 +317,6 @@ def select(
         lead_time : Sequence of numpy.timedelta64
             Lead times to select
 
-        Returns
-        -------
-        HazardForecast
-
         See Also
         --------
         :py:meth:`~climada.hazard.base.Hazard.select`