Merge branch 'forecast-class' into impactCalc_block_nonsense_attrs

Author: luseverin

climada/engine/impact_forecast.py

@@ -45,9 +45,9 @@ def __init__(
         Parameters
         ----------
         lead_time : np.ndarray, optional
-            The lead time associated with each event entry
+            The lead time associated with each event entry, given as timedelta64 type
         member : np.ndarray, optional
-            The ensemble member associated with each event entry
+            The ensemble member associated with each event entry, given as integers
         impact_kwargs
             Keyword-arguments passed to ~:py:class`climada.engine.impact.Impact`.
         """
@@ -65,9 +65,9 @@ def from_impact(
         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
+            The lead time associated with each event entry, given as timedelta64 type
         member : np.ndarray, optional
-            The ensemble member associated with each event entry
+            The ensemble member associated with each event entry, given as integers
         """
         with log_level("WARNING", "climada.engine.impact"):
             return cls(

climada/engine/test/test_impact_forecast.py

@@ -40,35 +40,66 @@ 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
+@pytest.fixture
+def lead_time():
+    return pd.timedelta_range(start="1 day", periods=6).to_numpy()
 
 
-class TestImpactForecastInit:
-    lead_time = pd.date_range("2000-01-01", "2000-01-02", periods=6).to_numpy()
-    member = np.arange(6)
+@pytest.fixture
+def member():
+    return np.arange(6)
+
+
+@pytest.fixture
+def impact_forecast(impact, lead_time, member):
+    return ImpactForecast.from_impact(impact, lead_time=lead_time, member=member)
+
 
-    def test_impact_forecast_init(self, impact_kwargs):
+class TestImpactForecastInit:
+    def assert_impact_kwargs(self, 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
+
+    def test_impact_forecast_init(self, impact_kwargs, lead_time, member):
         forecast1 = ImpactForecast(
-            lead_time=self.lead_time,
-            member=self.member,
+            lead_time=lead_time,
+            member=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)
+        npt.assert_array_equal(forecast1.lead_time, lead_time)
+        npt.assert_array_equal(forecast1.member, member)
+        self.assert_impact_kwargs(forecast1, **impact_kwargs)
+
+    def test_impact_forecast_from_impact(
+        self, impact_forecast, impact_kwargs, lead_time, member
+    ):
+        npt.assert_array_equal(impact_forecast.lead_time, lead_time)
+        npt.assert_array_equal(impact_forecast.member, member)
+        self.assert_impact_kwargs(impact_forecast, **impact_kwargs)
+
+
+def test_impact_forecast_select(impact_forecast, lead_time, member, impact_kwargs):
+    """Check if Impact.select works on the derived class"""
+    event_ids = impact_kwargs["event_id"][np.array([2, 0])]
+    impact_fc = impact_forecast.select(event_ids=event_ids)
+    # NOTE: Events keep their original order
+    npt.assert_array_equal(
+        impact_fc.event_id, impact_forecast.event_id[np.array([0, 2])]
+    )
+    npt.assert_array_equal(impact_fc.member, member[np.array([0, 2])])
+    npt.assert_array_equal(impact_fc.lead_time, lead_time[np.array([0, 2])])
+
+
+@pytest.mark.skip("Concat from base class does not work")
+def test_impact_forecast_concat(impact_forecast, member):
+    """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]))

climada/hazard/test/test_forecast.py

@@ -29,8 +29,6 @@
 from climada.hazard.forecast import HazardForecast
 from climada.hazard.test.test_base import hazard_kwargs
 
-# --- Examples for fixtures and test organization --- #
-
 
 @pytest.fixture
 def haz_kwargs():
@@ -88,3 +86,24 @@ def test_from_hazard(lead_time, member, hazard, haz_kwargs):
     npt.assert_array_equal(haz_fc_from_haz.lead_time, lead_time)
     npt.assert_array_equal(haz_fc_from_haz.member, member)
     assert_hazard_kwargs(haz_fc_from_haz, **haz_kwargs)
+
+
+@pytest.mark.skip("Concat from base class does not work")
+def test_hazard_forecast_concat(haz_fc, lead_time, member):
+    haz_fc1 = haz_fc.select(event_id=[1, 2])
+    haz_fc2 = haz_fc.select(event_id=[3, 4])
+    haz_fc_concat = HazardForecast.concat([haz_fc1, haz_fc2])
+    assert isinstance(haz_fc_concat, HazardForecast)
+    npt.assert_array_equal(
+        haz_fc_concat.lead_time, np.concatenate([lead_time, lead_time])
+    )
+    npt.assert_array_equal(haz_fc_concat.member, np.concatenate([member, member]))
+
+
+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])])

climada/util/forecast.py

@@ -28,8 +28,8 @@ class Forecast:
     Attributes
     ----------
     lead_time : np.ndarray
-        Array of forecast lead times, given as datetime64 objects.
-        Represents the time points for which forecasts are made.
+        Array of forecast lead times, given as timedelta64 objects.
+        Represents the lead times of the forecasts.
     member : np.ndarray
         Array of ensemble member identifiers, given as integers.
         Represents different forecast ensemble members.

climada/util/test/test_forecast.py

@@ -21,6 +21,7 @@
 
 import numpy as np
 import numpy.testing as npt
+import pandas as pd
 
 from climada.util.forecast import Forecast
 
@@ -34,19 +35,18 @@ def test_forecast_init():
     forecast = Forecast(member=np.array([1, 2]))
     npt.assert_array_equal(forecast.member, np.array([1, 2]), strict=True)
 
-    forecast = Forecast(lead_time=np.array([1, 2]))
-    npt.assert_array_equal(forecast.lead_time, np.array([1, 2]), strict=True)
+    forecast = Forecast(lead_time=np.array([6, 12], dtype="timedelta64[h]"))
+    npt.assert_array_equal(
+        forecast.lead_time, np.array([6, 12], dtype="timedelta64[h]"), strict=True
+    )
 
     forecast = Forecast(lead_time=np.array([1, 2]), member=[3, 4])
     npt.assert_array_equal(forecast.lead_time, np.array([1, 2]), strict=True)
     npt.assert_array_equal(forecast.member, np.array([3, 4]), strict=True)
     assert isinstance(forecast.member, np.ndarray)
 
     # Test with datetime64 including seconds
-    lead_times_seconds = np.array(
-        ["2024-01-01T00:00:00", "2024-01-01T00:01:00", "2024-01-01"],
-        dtype="datetime64[s]",
-    )
+    lead_times_seconds = pd.timedelta_range(start="1 day", periods=4).to_numpy()
     forecast = Forecast(lead_time=lead_times_seconds, member=[1, 2, 3])
     npt.assert_array_equal(forecast.lead_time, lead_times_seconds, strict=True)
-    assert forecast.lead_time.dtype == np.dtype("datetime64[s]")
+    assert forecast.lead_time.dtype == np.dtype("timedelta64[ns]")