test: updates with new names and removing of risk transfer

Author: spjuhel

climada/trajectories/test/test_risk_trajectory.py

@@ -113,8 +113,6 @@ def test_init_with_custom_params(self):
         self.assertEqual(rt._interval_freq, "MS")
         self.assertEqual(rt._all_groups_name, "CustomAll")
         self.assertEqual(rt._risk_disc, mock_disc)
-        self.assertEqual(rt._risk_transf_cover, 0.5)
-        self.assertEqual(rt._risk_transf_attach, 0.1)
 
     ## Test Properties (`@property` and `@setter`)
     def test_default_rp_getter_setter(self):
@@ -157,22 +155,16 @@ def test_risk_periods_lazy_computation(self, MockCalcRiskPeriod):
                 call(
                     self.mock_snapshot1,
                     self.mock_snapshot2,
-                    interval_freq="YS",
+                    time_resolution="YS",
                     interpolation_strategy=self.mock_interpolation_strategy,
                     impact_computation_strategy=self.mock_impact_computation_strategy,
-                    risk_transf_cover=None,
-                    risk_transf_attach=None,
-                    calc_residual=True,
                 ),
                 call(
                     self.mock_snapshot2,
                     self.mock_snapshot3,
-                    interval_freq="YS",
+                    time_resolution="YS",
                     interpolation_strategy=self.mock_interpolation_strategy,
                     impact_computation_strategy=self.mock_impact_computation_strategy,
-                    risk_transf_cover=None,
-                    risk_transf_attach=None,
-                    calc_residual=True,
                 ),
             ]
         )
@@ -912,12 +904,16 @@ def test_plot_per_date_waterfall(
 
         # Call the method
         fig, ax = rt.plot_per_date_waterfall(
-            start_date=datetime.date(2023, 1, 1), end_date=datetime.date(2023, 1, 2)
+            start_date=datetime.date(2023, 1, 1),
+            end_date=datetime.date(2023, 1, 2),
+            npv=True,
         )
 
         # Assertions
         mock_calc_data.assert_called_once_with(
-            start_date=datetime.date(2023, 1, 1), end_date=datetime.date(2023, 1, 2)
+            start_date=datetime.date(2023, 1, 1),
+            end_date=datetime.date(2023, 1, 2),
+            npv=True,
         )
         mock_ax.stackplot.assert_called_once()
         self.assertEqual(
@@ -980,12 +976,16 @@ def test_plot_waterfall(self, mock_calc_data, mock_subplots):
 
         # Call the method
         ax = rt.plot_waterfall(
-            start_date=datetime.date(2023, 1, 1), end_date=datetime.date(2024, 1, 1)
+            start_date=datetime.date(2023, 1, 1),
+            end_date=datetime.date(2024, 1, 1),
+            npv=True,
         )
 
         # Assertions
         mock_calc_data.assert_called_once_with(
-            start_date=datetime.date(2023, 1, 1), end_date=datetime.date(2024, 1, 1)
+            start_date=datetime.date(2023, 1, 1),
+            end_date=datetime.date(2024, 1, 1),
+            npv=True,
         )
         mock_ax.bar.assert_called_once()
         # Verify the bar arguments are correct for the end_date data
@@ -1027,16 +1027,16 @@ def test_reset_metrics(self):
     def test_get_risk_periods(self):
         # Create dummy CalcRiskPeriod mocks with specific dates
         mock_rp1 = Mock()
-        mock_rp1.snapshot0.date = datetime.date(2020, 1, 1)
-        mock_rp1.snapshot1.date = datetime.date(2021, 1, 1)
+        mock_rp1.snapshot_start.date = datetime.date(2020, 1, 1)
+        mock_rp1.snapshot_end.date = datetime.date(2021, 1, 1)
 
         mock_rp2 = Mock()
-        mock_rp2.snapshot0.date = datetime.date(2021, 1, 1)
-        mock_rp2.snapshot1.date = datetime.date(2022, 1, 1)
+        mock_rp2.snapshot_start.date = datetime.date(2021, 1, 1)
+        mock_rp2.snapshot_end.date = datetime.date(2022, 1, 1)
 
         mock_rp3 = Mock()
-        mock_rp3.snapshot0.date = datetime.date(2022, 1, 1)
-        mock_rp3.snapshot1.date = datetime.date(2023, 1, 1)
+        mock_rp3.snapshot_start.date = datetime.date(2022, 1, 1)
+        mock_rp3.snapshot_end.date = datetime.date(2023, 1, 1)
 
         all_risk_periods = [mock_rp1, mock_rp2, mock_rp3]
 

climada/trajectories/test/test_riskperiod.py

@@ -98,13 +98,13 @@ def setUp(self):
         )
 
         # Create mock snapshots
-        self.mock_snapshot0 = Snapshot(
+        self.mock_snapshot_start = Snapshot(
             self.exposure_present,
             self.hazard_present,
             self.impfset_present,
             self.present_date,
         )
-        self.mock_snapshot1 = Snapshot(
+        self.mock_snapshot_end = Snapshot(
             self.exposure_future,
             self.hazard_future,
             self.impfset_future,
@@ -113,8 +113,8 @@ def setUp(self):
 
         # Create an instance of CalcRiskPeriod
         self.calc_risk_period = CalcRiskPeriod(
-            self.mock_snapshot0,
-            self.mock_snapshot1,
+            self.mock_snapshot_start,
+            self.mock_snapshot_end,
             time_resolution="AS-JAN",
             interpolation_strategy=AllLinearStrategy(),
             impact_computation_strategy=ImpactCalcComputation(),
@@ -125,8 +125,8 @@ def setUp(self):
         )
 
     def test_init(self):
-        self.assertEqual(self.calc_risk_period.snapshot_start, self.mock_snapshot0)
-        self.assertEqual(self.calc_risk_period.snapshot_end, self.mock_snapshot1)
+        self.assertEqual(self.calc_risk_period.snapshot_start, self.mock_snapshot_start)
+        self.assertEqual(self.calc_risk_period.snapshot_end, self.mock_snapshot_end)
         self.assertEqual(self.calc_risk_period.time_resolution, "AS-JAN")
         self.assertEqual(
             self.calc_risk_period.time_points, self.future_date - self.present_date + 1
@@ -139,11 +139,11 @@ def test_init(self):
         )
         np.testing.assert_array_equal(
             self.calc_risk_period._group_id_E0,
-            self.mock_snapshot0.exposure.gdf["group_id"].values,
+            self.mock_snapshot_start.exposure.gdf["group_id"].values,
         )
         np.testing.assert_array_equal(
             self.calc_risk_period._group_id_E1,
-            self.mock_snapshot1.exposure.gdf["group_id"].values,
+            self.mock_snapshot_end.exposure.gdf["group_id"].values,
         )
         self.assertIsInstance(self.calc_risk_period.date_idx, pd.DatetimeIndex)
         self.assertEqual(
@@ -198,7 +198,7 @@ def test_set_time_points_wtype(self):
         with self.assertRaises(ValueError):
             self.calc_risk_period.time_points = "1"
 
-    def test_set_interval_freq(self):
+    def test_set_time_resolution(self):
         self.calc_risk_period.time_resolution = "MS"
         self.assertEqual(self.calc_risk_period.time_resolution, "MS")
         pd.testing.assert_index_equal(
@@ -298,10 +298,6 @@ def test_set_impact_computation_strategy_wtype(self):
         with self.assertRaises(ValueError):
             self.calc_risk_period.impact_computation_strategy = "A"
 
-    def test_set_calc_residual_wtype(self):
-        with self.assertRaises(ValueError):
-            self.calc_risk_period.calc_residual = "A"
-
     # The computation are tested in the CalcImpactStrategy / InterpolationStrategyBase tests
     # Here we just make sure that the calling works
     @patch.object(CalcRiskPeriod, "impact_computation_strategy")
@@ -321,9 +317,6 @@ def test_impacts_arrays(self, mock_impact_compute):
                     self.calc_risk_period.snapshot_start,
                     self.calc_risk_period.snapshot_end,
                     fut,
-                    self.calc_risk_period.risk_transf_attach,
-                    self.calc_risk_period.risk_transf_cover,
-                    self.calc_risk_period.calc_residual,
                 )
                 for fut in [
                     (0, 0, 0),
@@ -340,43 +333,43 @@ def test_impacts_arrays(self, mock_impact_compute):
 
     @patch.object(CalcRiskPeriod, "interpolation_strategy")
     def test_imp_mats_H0V0(self, mock_interpolate):
-        mock_interpolate.interp_exposure_dim.return_value = 1
+        mock_interpolate.interp_over_exposure_dim.return_value = 1
         result = self.calc_risk_period.imp_mats_H0V0
         self.assertEqual(result, 1)
-        mock_interpolate.interp_exposure_dim.assert_called_with(
+        mock_interpolate.interp_over_exposure_dim.assert_called_with(
             self.calc_risk_period.E0H0V0.imp_mat,
             self.calc_risk_period.E1H0V0.imp_mat,
             self.calc_risk_period.time_points,
         )
 
     @patch.object(CalcRiskPeriod, "interpolation_strategy")
     def test_imp_mats_H1V0(self, mock_interpolate):
-        mock_interpolate.interp_exposure_dim.return_value = 1
+        mock_interpolate.interp_over_exposure_dim.return_value = 1
         result = self.calc_risk_period.imp_mats_H1V0
         self.assertEqual(result, 1)
-        mock_interpolate.interp_exposure_dim.assert_called_with(
+        mock_interpolate.interp_over_exposure_dim.assert_called_with(
             self.calc_risk_period.E0H1V0.imp_mat,
             self.calc_risk_period.E1H1V0.imp_mat,
             self.calc_risk_period.time_points,
         )
 
     @patch.object(CalcRiskPeriod, "interpolation_strategy")
     def test_imp_mats_H0V1(self, mock_interpolate):
-        mock_interpolate.interp_exposure_dim.return_value = 1
+        mock_interpolate.interp_over_exposure_dim.return_value = 1
         result = self.calc_risk_period.imp_mats_H0V1
         self.assertEqual(result, 1)
-        mock_interpolate.interp_exposure_dim.assert_called_with(
+        mock_interpolate.interp_over_exposure_dim.assert_called_with(
             self.calc_risk_period.E0H0V1.imp_mat,
             self.calc_risk_period.E1H0V1.imp_mat,
             self.calc_risk_period.time_points,
         )
 
     @patch.object(CalcRiskPeriod, "interpolation_strategy")
     def test_imp_mats_H1V1(self, mock_interpolate):
-        mock_interpolate.interp_exposure_dim.return_value = 1
+        mock_interpolate.interp_over_exposure_dim.return_value = 1
         result = self.calc_risk_period.imp_mats_H1V1
         self.assertEqual(result, 1)
-        mock_interpolate.interp_exposure_dim.assert_called_with(
+        mock_interpolate.interp_over_exposure_dim.assert_called_with(
             self.calc_risk_period.E0H1V1.imp_mat,
             self.calc_risk_period.E1H1V1.imp_mat,
             self.calc_risk_period.time_points,
@@ -609,14 +602,14 @@ def setUp(self):
         self.calc_risk_period.date_idx = pd.DatetimeIndex(
             ["2020-01-01", "2025-01-01", "2030-01-01"], name="date"
         )
-        self.calc_risk_period.snapshot0.exposure.gdf = gpd.GeoDataFrame(
+        self.calc_risk_period.snapshot_start.exposure.gdf = gpd.GeoDataFrame(
             {
                 "group_id": [1, 2, 2],
                 "geometry": [Point(0, 0), Point(1, 1), Point(2, 2)],
                 "value": [10, 10, 20],
             }
         )
-        self.calc_risk_period.snapshot1.exposure.gdf = gpd.GeoDataFrame(
+        self.calc_risk_period.snapshot_end.exposure.gdf = gpd.GeoDataFrame(
             {
                 "group_id": [1, 2, 2],
                 "geometry": [Point(0, 0), Point(1, 1), Point(2, 2)],
@@ -627,20 +620,20 @@ def setUp(self):
         self.calc_risk_period.measure.name = "dummy_measure"
 
     def test_calc_eai(self):
-        # Mock the return values of interp_hazard_dim
-        self.calc_risk_period.interpolation_strategy.interp_hazard_dim.side_effect = [
+        # Mock the return values of interp_over_hazard_dim
+        self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.side_effect = [
             "V0_interpolated_data",  # First call (for per_date_eai_V0)
             "V1_interpolated_data",  # Second call (for per_date_eai_V1)
         ]
-        # Mock the return value of interp_vulnerability_dim
-        self.calc_risk_period.interpolation_strategy.interp_vulnerability_dim.return_value = (
+        # Mock the return value of interp_over_vulnerability_dim
+        self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.return_value = (
             "final_eai_result"
         )
 
         result = self.calc_risk_period.calc_eai()
 
-        # Assert that interp_hazard_dim was called with the correct arguments
-        self.calc_risk_period.interpolation_strategy.interp_hazard_dim.assert_has_calls(
+        # Assert that interp_over_hazard_dim was called with the correct arguments
+        self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.assert_has_calls(
             [
                 call(
                     self.calc_risk_period.per_date_eai_H0V0,
@@ -653,8 +646,8 @@ def test_calc_eai(self):
             ]
         )
 
-        # Assert that interp_vulnerability_dim was called with the results of interp_hazard_dim
-        self.calc_risk_period.interpolation_strategy.interp_vulnerability_dim.assert_called_once_with(
+        # Assert that interp_over_vulnerability_dim was called with the results of interp_over_hazard_dim
+        self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.assert_called_once_with(
             "V0_interpolated_data", "V1_interpolated_data"
         )
 
@@ -743,25 +736,25 @@ def test_calc_return_periods_metric(self):
         self.calc_risk_period.per_date_return_periods_H1V0.return_value = "H1V0"
         self.calc_risk_period.per_date_return_periods_H0V1.return_value = "H0V1"
         self.calc_risk_period.per_date_return_periods_H1V1.return_value = "H1V1"
-        # Mock the return values of interp_hazard_dim
-        self.calc_risk_period.interpolation_strategy.interp_hazard_dim.side_effect = [
+        # Mock the return values of interp_over_hazard_dim
+        self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.side_effect = [
             "V0_interpolated_data",  # First call (for per_date_rp_V0)
             "V1_interpolated_data",  # Second call (for per_date_rp_V1)
         ]
-        # Mock the return value of interp_vulnerability_dim
-        self.calc_risk_period.interpolation_strategy.interp_vulnerability_dim.return_value = np.array(
+        # Mock the return value of interp_over_vulnerability_dim
+        self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.return_value = np.array(
             [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
         )
 
         result = self.calc_risk_period.calc_return_periods_metric([10, 20, 30])
 
-        # Assert that interp_hazard_dim was called with the correct arguments
-        self.calc_risk_period.interpolation_strategy.interp_hazard_dim.assert_has_calls(
+        # Assert that interp_over_hazard_dim was called with the correct arguments
+        self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.assert_has_calls(
             [call("H0V0", "H1V0"), call("H0V1", "H1V1")]
         )
 
-        # Assert that interp_vulnerability_dim was called with the results of interp_hazard_dim
-        self.calc_risk_period.interpolation_strategy.interp_vulnerability_dim.assert_called_once_with(
+        # Assert that interp_over_vulnerability_dim was called with the results of interp_over_hazard_dim
+        self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.assert_called_once_with(
             "V0_interpolated_data", "V1_interpolated_data"
         )
 
@@ -791,26 +784,26 @@ def test_calc_risk_components_metric(self):
         self.calc_risk_period.per_date_aai_H1V1 = np.array([3, 3, 3])
         self.calc_risk_period.per_date_aai = np.array([0, 6 / 4, 3])
 
-        # Mock the return values of interp_hazard_dim
-        self.calc_risk_period.interpolation_strategy.interp_hazard_dim.return_value = (
-            np.array([0, 0.5, 1])
+        # Mock the return values of interp_over_hazard_dim
+        self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.return_value = np.array(
+            [0, 0.5, 1]
         )
 
-        # Mock the return value of interp_vulnerability_dim
-        self.calc_risk_period.interpolation_strategy.interp_vulnerability_dim.return_value = np.array(
+        # Mock the return value of interp_over_vulnerability_dim
+        self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.return_value = np.array(
             [0, 1, 2]
         )
 
         result = self.calc_risk_period.calc_risk_components_metric()
 
-        # Assert that interp_hazard_dim was called with the correct arguments
-        self.calc_risk_period.interpolation_strategy.interp_hazard_dim.assert_called_once_with(
+        # Assert that interp_over_hazard_dim was called with the correct arguments
+        self.calc_risk_period.interpolation_strategy.interp_over_hazard_dim.assert_called_once_with(
             self.calc_risk_period.per_date_aai_H0V0,
             self.calc_risk_period.per_date_aai_H1V0,
         )
 
-        # Assert that interp_vulnerability_dim was called with the results of interp_hazard_dim
-        self.calc_risk_period.interpolation_strategy.interp_vulnerability_dim.assert_called_once_with(
+        # Assert that interp_over_vulnerability_dim was called with the results of interp_over_hazard_dim
+        self.calc_risk_period.interpolation_strategy.interp_over_vulnerability_dim.assert_called_once_with(
             self.calc_risk_period.per_date_aai_H0V0,
             self.calc_risk_period.per_date_aai_H0V1,
         )
@@ -847,20 +840,17 @@ def test_calc_risk_components_metric(self):
     @patch("climada.trajectories.riskperiod.CalcRiskPeriod")
     def test_apply_measure(self, mock_CalcRiskPeriod):
         mock_CalcRiskPeriod.return_value = MagicMock(spec=CalcRiskPeriod)
-        self.calc_risk_period.snapshot0.apply_measure.return_value = 2
-        self.calc_risk_period.snapshot1.apply_measure.return_value = 3
+        self.calc_risk_period.snapshot_start.apply_measure.return_value = 2
+        self.calc_risk_period.snapshot_end.apply_measure.return_value = 3
         result = self.calc_risk_period.apply_measure(self.calc_risk_period.measure)
         self.assertEqual(result.measure, self.calc_risk_period.measure)
         mock_CalcRiskPeriod.assert_called_with(
             2,
             3,
-            self.calc_risk_period.interval_freq,
+            self.calc_risk_period.time_resolution,
             self.calc_risk_period.time_points,
             self.calc_risk_period.interpolation_strategy,
             self.calc_risk_period.impact_computation_strategy,
-            self.calc_risk_period.risk_transf_attach,
-            self.calc_risk_period.risk_transf_cover,
-            self.calc_risk_period.calc_residual,
         )