Merge branch 'forecast-class' into hazard_forecast_test_select

Author: luseverin

climada/engine/__init__.py

@@ -22,3 +22,4 @@
 from .cost_benefit import *
 from .impact import *
 from .impact_calc import *
+from .impact_forecast import ImpactForecast

climada/engine/impact_forecast.py

@@ -18,3 +18,73 @@
 
 Define Forecast variant of Impact.
 """
+
+import logging
+
+import numpy as np
+
+from ..util import log_level
+from ..util.forecast import Forecast
+from .impact import Impact
+
+LOGGER = logging.getLogger(__name__)
+
+
+class ImpactForecast(Forecast, Impact):
+    """An impact object with forecast information"""
+
+    def __init__(
+        self,
+        *,
+        lead_time: np.ndarray | None,
+        member: np.ndarray | None,
+        **impact_kwargs,
+    ):
+        """Initialize the impact forecast.
+
+        Parameters
+        ----------
+        lead_time : np.ndarray, optional
+            The lead time associated with each event entry
+        member : np.ndarray, optional
+            The ensemble member associated with each event entry
+        impact_kwargs
+            Keyword-arguments passed to ~:py:class`climada.engine.impact.Impact`.
+        """
+        # TODO: Maybe assert array lengths?
+        super().__init__(lead_time=lead_time, member=member, **impact_kwargs)
+
+    @classmethod
+    def from_impact(
+        cls, impact: Impact, lead_time: np.ndarray | None, member: np.ndarray | None
+    ):
+        """Create an impact forecast from an impact object and forecast information.
+
+        Parameters
+        ----------
+        impact : climada.engine.impact.Impact
+            The impact object whose data to use in the forecast object
+        lead_time : np.ndarray, optional
+            The lead time associated with each event entry
+        member : np.ndarray, optional
+            The ensemble member associated with each event entry
+        """
+        with log_level("WARNING", "climada.engine.impact"):
+            return cls(
+                lead_time=lead_time,
+                member=member,
+                event_id=impact.event_id,
+                event_name=impact.event_name,
+                date=impact.date,
+                frequency=impact.frequency,
+                frequency_unit=impact.frequency_unit,
+                coord_exp=impact.coord_exp,
+                crs=impact.crs,
+                eai_exp=impact.eai_exp,
+                at_event=impact.at_event,
+                tot_value=impact.tot_value,
+                aai_agg=impact.aai_agg,
+                unit=impact.unit,
+                imp_mat=impact.imp_mat,
+                haz_type=impact.haz_type,
+            )

climada/engine/test/test_impact.py

@@ -47,26 +47,30 @@
 STR_DT = h5py.special_dtype(vlen=str)
 
 
-def dummy_impact():
-    """Return an impact object for testing"""
-    return Impact(
-        event_id=np.arange(6) + 10,
-        event_name=[0, 1, "two", "three", 30, 31],
-        date=np.arange(6),
-        coord_exp=np.array([[1, 2], [1.5, 2.5]]),
-        crs=DEF_CRS,
-        eai_exp=np.array([7.2, 7.2]),
-        at_event=np.array([0, 2, 4, 6, 60, 62]),
-        frequency=np.array([1 / 6, 1 / 6, 1, 1, 1 / 30, 1 / 30]),
-        tot_value=7,
-        aai_agg=14.4,
-        unit="USD",
-        frequency_unit="1/month",
-        imp_mat=sparse.csr_matrix(
+def impact_kwargs():
+    return {
+        "event_id": np.arange(6) + 10,
+        "event_name": [0, 1, "two", "three", 30, 31],
+        "date": np.arange(6),
+        "coord_exp": np.array([[1, 2], [1.5, 2.5]]),
+        "crs": DEF_CRS,
+        "eai_exp": np.array([7.2, 7.2]),
+        "at_event": np.array([0, 2, 4, 6, 60, 62]),
+        "frequency": np.array([1 / 6, 1 / 6, 1, 1, 1 / 30, 1 / 30]),
+        "tot_value": 7,
+        "aai_agg": 14.4,
+        "unit": "USD",
+        "frequency_unit": "1/month",
+        "imp_mat": sparse.csr_matrix(
             np.array([[0, 0], [1, 1], [2, 2], [3, 3], [30, 30], [31, 31]])
         ),
-        haz_type="TC",
-    )
+        "haz_type": "TC",
+    }
+
+
+def dummy_impact():
+    """Return an impact object for testing"""
+    return Impact(**impact_kwargs())
 
 
 def dummy_impact_yearly():

climada/engine/test/test_impact_forecast.py

@@ -18,3 +18,57 @@
 
 Tests for Impact Forecast.
 """
+
+import numpy as np
+import numpy.testing as npt
+import pandas as pd
+import pytest
+from scipy.sparse import csr_matrix
+
+from climada.engine import Impact, ImpactForecast
+
+from .test_impact import impact_kwargs as imp_kwargs
+
+
+@pytest.fixture
+def impact_kwargs():
+    return imp_kwargs()
+
+
+@pytest.fixture
+def impact(impact_kwargs):
+    return Impact(**impact_kwargs)
+
+
+def assert_impact_kwargs(impact: Impact, **kwargs):
+    for key, value in kwargs.items():
+        attr = getattr(impact, key)
+        if isinstance(value, (np.ndarray, list)):
+            npt.assert_array_equal(attr, value)
+        elif isinstance(value, csr_matrix):
+            npt.assert_array_equal(attr.todense(), value.todense())
+        else:
+            assert attr == value
+
+
+class TestImpactForecastInit:
+    lead_time = pd.date_range("2000-01-01", "2000-01-02", periods=6).to_numpy()
+    member = np.arange(6)
+
+    def test_impact_forecast_init(self, impact_kwargs):
+        forecast1 = ImpactForecast(
+            lead_time=self.lead_time,
+            member=self.member,
+            **impact_kwargs,
+        )
+        npt.assert_array_equal(forecast1.lead_time, self.lead_time)
+        npt.assert_array_equal(forecast1.member, self.member)
+        assert_impact_kwargs(forecast1, **impact_kwargs)
+
+    def test_impact_forecast_from_impact(self, impact, impact_kwargs):
+        forecast = ImpactForecast.from_impact(
+            impact, lead_time=self.lead_time, member=self.member
+        )
+        npt.assert_array_equal(forecast.lead_time, self.lead_time)
+        npt.assert_array_equal(forecast.member, self.member)
+        assert_impact_kwargs(forecast, **impact_kwargs)

climada/hazard/forecast.py

@@ -30,6 +30,7 @@
 
 
 class HazardForecast(Forecast, Hazard):
+    """A hazard object with forecast information"""
 
     def __init__(
         self,
@@ -42,13 +43,13 @@ def __init__(
 
         Parameters
         ----------
-        lead_time : np.ndarray of np.datetime64 or None, optional
+        lead_time : np.ndarray of np.timedelta64 or None, optional
             Forecast lead times. Default is empty array.
         member : np.ndarray or None, optional
             Ensemble member identifiers as integers. Default is empty array.
         **hazard_kwargs
-            keyword arguments to pass to Hazard.__init__. See Hazard.__init__
-            docstring for details.
+            keyword arguments to pass to :py:class:`~climada.hazard.base.Hazard` See
+            py:meth`~climada.hazard.base.Hazard.__init__` for details.
         """
         super().__init__(lead_time=lead_time, member=member, **hazard_kwargs)
 
@@ -59,8 +60,12 @@ def from_hazard(cls, hazard: Hazard, lead_time: np.ndarray, member: np.ndarray):
 
         Parameters
         ----------
-        hazard : Hazard
+        hazard : climada.hazard.base.Hazard
             Hazard object to convert into a HazardForecast.
+        lead_time : np.ndarray of np.timedelta64 or None, optional
+            Forecast lead times. Default is empty array.
+        member : np.ndarray or None, optional
+            Ensemble member identifiers as integers. Default is empty array.
 
         Returns
         -------

climada/hazard/test/test_forecast.py

@@ -23,6 +23,7 @@
 import numpy.testing as npt
 import pandas as pd
 import pytest
+from scipy.sparse import csr_matrix
 
 from climada.hazard.base import Hazard
 from climada.hazard.forecast import HazardForecast
@@ -37,13 +38,13 @@ def haz_kwargs():
 
 
 @pytest.fixture
-def dummy_hazard(haz_kwargs):
+def hazard(haz_kwargs):
     return Hazard(**haz_kwargs)
 
 
 @pytest.fixture
 def lead_time():
-    return pd.date_range("2000-01-01", "2000-01-02", periods=6).to_numpy()
+    return pd.timedelta_range("1h", periods=6).to_numpy()
 
 
 @pytest.fixture
@@ -60,80 +61,30 @@ def haz_fc(lead_time, member, haz_kwargs):
     )
 
 
+def assert_hazard_kwargs(hazard: Hazard, **kwargs):
+    for key, value in kwargs.items():
+        attr = getattr(hazard, key)
+        if isinstance(value, (np.ndarray, list)):
+            npt.assert_array_equal(attr, value)
+        elif isinstance(value, csr_matrix):
+            npt.assert_array_equal(attr.todense(), value.todense())
+        else:
+            assert attr == value
+
+
 def test_init_hazard_forecast(haz_fc, member, lead_time, haz_kwargs):
     assert isinstance(haz_fc, HazardForecast)
-    npt.assert_array_equal(
-        haz_fc.lead_time,
-        lead_time,
-    )
+    npt.assert_array_equal(haz_fc.lead_time, lead_time)
     assert haz_fc.lead_time.dtype == lead_time.dtype
     npt.assert_array_equal(haz_fc.member, member)
-    assert haz_fc.haz_type == haz_kwargs["haz_type"]
-    assert haz_fc.pool == haz_kwargs["pool"]
-    assert haz_fc.units == haz_kwargs["units"]
-    assert haz_fc.centroids == haz_kwargs["centroids"]
-    npt.assert_array_equal(haz_fc.event_id, haz_kwargs["event_id"])
-    npt.assert_array_equal(haz_fc.frequency, haz_kwargs["frequency"])
-    assert haz_fc.frequency_unit == haz_kwargs["frequency_unit"]
-    npt.assert_array_equal(haz_fc.event_name, haz_kwargs["event_name"])
-    npt.assert_array_equal(haz_fc.date, haz_kwargs["date"])
-    npt.assert_array_equal(haz_fc.orig, haz_kwargs["orig"])
-    npt.assert_array_equal(
-        haz_fc.intensity.todense(), haz_kwargs["intensity"].todense()
-    )
-    npt.assert_array_equal(haz_fc.fraction.todense(), haz_kwargs["fraction"].todense())
+    assert_hazard_kwargs(haz_fc, **haz_kwargs)
 
 
-def test_from_hazard(lead_time, member, dummy_hazard):
+def test_from_hazard(lead_time, member, hazard, haz_kwargs):
     haz_fc_from_haz = HazardForecast.from_hazard(
-        dummy_hazard, lead_time=lead_time, member=member
+        hazard, lead_time=lead_time, member=member
     )
-
     assert isinstance(haz_fc_from_haz, HazardForecast)
     npt.assert_array_equal(haz_fc_from_haz.lead_time, lead_time)
     npt.assert_array_equal(haz_fc_from_haz.member, member)
-    assert haz_fc_from_haz.haz_type == dummy_hazard.haz_type
-    assert haz_fc_from_haz.pool == dummy_hazard.pool
-    assert haz_fc_from_haz.units == dummy_hazard.units
-    assert haz_fc_from_haz.centroids == dummy_hazard.centroids
-    npt.assert_array_equal(haz_fc_from_haz.event_id, dummy_hazard.event_id)
-    npt.assert_array_equal(haz_fc_from_haz.frequency, dummy_hazard.frequency)
-    assert haz_fc_from_haz.frequency_unit == dummy_hazard.frequency_unit
-    npt.assert_array_equal(haz_fc_from_haz.event_name, dummy_hazard.event_name)
-    npt.assert_array_equal(haz_fc_from_haz.date, dummy_hazard.date)
-    npt.assert_array_equal(haz_fc_from_haz.orig, dummy_hazard.orig)
-    npt.assert_array_equal(
-        haz_fc_from_haz.intensity.todense(), dummy_hazard.intensity.todense()
-    )
-    npt.assert_array_equal(
-        haz_fc_from_haz.fraction.todense(), dummy_hazard.fraction.todense()
-    )
-
-
-def test_hazard_forecast_select(haz_fc, lead_time, member):
-    """Check if Hazard.select works on the derived class"""
-    haz_fc_select = haz_fc.select(event_id=[4, 1])
-    # NOTE: Events keep their original order
-    npt.assert_array_equal(haz_fc_select.event_id, haz_fc.event_id[np.array([3, 0])])
-    npt.assert_array_equal(haz_fc_select.member, member[np.array([3, 0])])
-    npt.assert_array_equal(haz_fc_select.lead_time, lead_time[np.array([3, 0])])
-
-
-@pytest.fixture
-def hazard():
-    return Hazard()
-
-
-def test_empty_hazard(hazard):
-    assert hazard.size == 0
-    assert hazard.haz_type == ""
-
-
-class TestSomething:
-
-    @pytest.fixture(autouse=True)
-    def haz_type(self, hazard):
-        hazard.haz_type = "foo"
-
-    def test_haz_type(self, hazard):
-        assert hazard.haz_type == "foo"
+    assert_hazard_kwargs(haz_fc_from_haz, **haz_kwargs)