ocf-data-sampler 0.0.19__py3-none-any.whl → 0.0.21__py3-none-any.whl

tests/select/test_find_contiguous_time_periods.py

@@ -0,0 +1,202 @@
+import pandas as pd
+
+from ocf_data_sampler.select.find_contiguous_time_periods import (
+    find_contiguous_t0_periods, find_contiguous_t0_periods_nwp, 
+    intersection_of_multiple_dataframes_of_periods,
+)
+
+
+
+def test_find_contiguous_t0_periods():
+
+    # Create 5-minutely data timestamps
+    freq = pd.Timedelta(5, "min")
+    history_duration = pd.Timedelta(60, "min")
+    forecast_duration = pd.Timedelta(15, "min")
+
+    datetimes = (
+        pd.date_range("2023-01-01 12:00", "2023-01-01 17:00", freq=freq)
+        .delete([5, 6, 30])
+    )
+
+    periods = find_contiguous_t0_periods(
+        datetimes=datetimes,
+        history_duration=history_duration,
+        forecast_duration=forecast_duration,
+        sample_period_duration=freq,
+    )
+
+    expected_results = pd.DataFrame(
+        {
+            "start_dt": pd.to_datetime(
+                [
+                    "2023-01-01 13:35",
+                    "2023-01-01 15:35",
+                ]
+            ),
+            "end_dt": pd.to_datetime(
+                [
+                    "2023-01-01 14:10",
+                    "2023-01-01 16:45",
+                ]
+            ),
+        },
+    )
+
+    assert periods.equals(expected_results)
+
+
+def test_find_contiguous_t0_periods_nwp():
+
+    # These are the expected results of the test
+    expected_results = [
+        pd.DataFrame(
+            {
+                "start_dt": pd.to_datetime(["2023-01-01 03:00", "2023-01-02 03:00"]),
+                "end_dt": pd.to_datetime(["2023-01-01 21:00", "2023-01-03 06:00"]),
+            },
+        ),
+        pd.DataFrame(
+            {
+                "start_dt": pd.to_datetime(
+                    [
+                        "2023-01-01 05:00",
+                        "2023-01-02 05:00",
+                    ]
+                ),
+                "end_dt": pd.to_datetime(
+                    [
+                        "2023-01-01 21:00",
+                        "2023-01-03 06:00",
+                    ]
+                ),
+            },
+        ),
+        pd.DataFrame(
+            {
+                "start_dt": pd.to_datetime(
+                    [
+                        "2023-01-01 05:00",
+                        "2023-01-02 05:00",
+                        "2023-01-02 14:00",
+                    ]
+                ),
+                "end_dt": pd.to_datetime(
+                    [
+                        "2023-01-01 18:00",
+                        "2023-01-02 09:00",
+                        "2023-01-03 03:00",
+                    ]
+                ),
+            },
+        ),
+        pd.DataFrame(
+            {
+                "start_dt": pd.to_datetime(
+                    [
+                        "2023-01-01 05:00",
+                        "2023-01-01 11:00",
+                        "2023-01-02 05:00",
+                        "2023-01-02 14:00",
+                    ]
+                ),
+                "end_dt": pd.to_datetime(
+                    [
+                        "2023-01-01 06:00",
+                        "2023-01-01 15:00",
+                        "2023-01-02 06:00",
+                        "2023-01-03 00:00",
+                    ]
+                ),
+            },
+        ),
+        pd.DataFrame(
+            {
+                "start_dt": pd.to_datetime(
+                    [
+                        "2023-01-01 06:00",
+                        "2023-01-01 12:00",
+                        "2023-01-02 06:00",
+                        "2023-01-02 15:00",
+                    ]
+                ),
+                "end_dt": pd.to_datetime(
+                    [
+                        "2023-01-01 09:00",
+                        "2023-01-01 18:00",
+                        "2023-01-02 09:00",
+                        "2023-01-03 03:00",
+                    ]
+                ),
+            },
+        ),
+    ]
+
+    # Create 3-hourly init times with a few time stamps missing
+    freq = pd.Timedelta(3, "h")
+
+    datetimes = (
+        pd.date_range("2023-01-01 03:00", "2023-01-02 21:00", freq=freq)
+        .delete([1, 4, 5, 6, 7, 9, 10])
+    )
+
+    # Choose some history durations and max stalenesses
+    history_durations_hr = [0, 2, 2, 2, 2]
+    max_stalenesses_hr = [9, 9, 6, 3, 6]
+    max_dropouts_hr = [0, 0, 0, 0, 3]
+
+    for i in range(len(expected_results)):
+        history_duration = pd.Timedelta(history_durations_hr[i], "h")
+        max_staleness = pd.Timedelta(max_stalenesses_hr[i], "h")
+        max_dropout = pd.Timedelta(max_dropouts_hr[i], "h")
+
+        time_periods = find_contiguous_t0_periods_nwp(
+            datetimes=datetimes,
+            history_duration=history_duration,
+            max_staleness=max_staleness,
+            max_dropout=max_dropout,
+        )
+
+        # Check if results are as expected
+        assert time_periods.equals(expected_results[i])
+
+
+def test_intersection_of_multiple_dataframes_of_periods():
+    periods_1 = pd.DataFrame(
+        {
+            "start_dt": pd.to_datetime(["2023-01-01 05:00", "2023-01-01 14:10"]),
+            "end_dt": pd.to_datetime(["2023-01-01 13:35", "2023-01-01 18:00"]),
+        },
+    )
+
+    periods_2 = pd.DataFrame(
+        {
+            "start_dt": pd.to_datetime(["2023-01-01 12:00"]),
+            "end_dt": pd.to_datetime(["2023-01-02 00:00"]),
+        },
+    )
+
+    periods_3 = pd.DataFrame(
+        {
+            "start_dt": pd.to_datetime(["2023-01-01 00:00", "2023-01-01 13:00"]),
+            "end_dt": pd.to_datetime(["2023-01-01 12:30", "2023-01-01 23:00"]),
+        },
+    )
+
+    expected_result = pd.DataFrame(
+        {
+            "start_dt": pd.to_datetime(
+                ["2023-01-01 12:00", "2023-01-01 13:00", "2023-01-01 14:10"]
+            ),
+            "end_dt": pd.to_datetime([
+                "2023-01-01 12:30", "2023-01-01 13:35", "2023-01-01 18:00"]
+            ),
+        },
+    )
+
+    overlaping_periods = intersection_of_multiple_dataframes_of_periods(
+        [periods_1, periods_2, periods_3]
+    )   
+
+    # Check if results are as expected
+    assert overlaping_periods.equals(expected_result)

tests/select/test_location.py

@@ -0,0 +1,67 @@
+from ocf_data_sampler.select.location import Location
+import pytest
+
+
+def test_make_valid_location_object_with_default_coordinate_system():
+    x, y = -1000.5, 50000
+    location = Location(x=x, y=y)
+    assert location.x == x, "location.x value not set correctly"
+    assert location.y == y, "location.x value not set correctly"
+    assert (
+        location.coordinate_system == "osgb"
+    ), "location.coordinate_system value not set correctly"
+
+
+def test_make_valid_location_object_with_osgb_coordinate_system():
+    x, y, coordinate_system = 1.2, 22.9, "osgb"
+    location = Location(x=x, y=y, coordinate_system=coordinate_system)
+    assert location.x == x, "location.x value not set correctly"
+    assert location.y == y, "location.x value not set correctly"
+    assert (
+        location.coordinate_system == coordinate_system
+    ), "location.coordinate_system value not set correctly"
+
+
+def test_make_valid_location_object_with_lon_lat_coordinate_system():
+    x, y, coordinate_system = 1.2, 1.2, "lon_lat"
+    location = Location(x=x, y=y, coordinate_system=coordinate_system)
+    assert location.x == x, "location.x value not set correctly"
+    assert location.y == y, "location.x value not set correctly"
+    assert (
+        location.coordinate_system == coordinate_system
+    ), "location.coordinate_system value not set correctly"
+
+
+def test_make_invalid_location_object_with_invalid_osgb_x():
+    x, y, coordinate_system = 10000000, 1.2, "osgb"
+    with pytest.raises(ValueError) as err:
+        _ = Location(x=x, y=y, coordinate_system=coordinate_system)
+    assert err.typename == "ValidationError"
+
+
+def test_make_invalid_location_object_with_invalid_osgb_y():
+    x, y, coordinate_system = 2.5, 10000000, "osgb"
+    with pytest.raises(ValueError) as err:
+        _ = Location(x=x, y=y, coordinate_system=coordinate_system)
+    assert err.typename == "ValidationError"
+
+
+def test_make_invalid_location_object_with_invalid_lon_lat_x():
+    x, y, coordinate_system = 200, 1.2, "lon_lat"
+    with pytest.raises(ValueError) as err:
+        _ = Location(x=x, y=y, coordinate_system=coordinate_system)
+    assert err.typename == "ValidationError"
+
+
+def test_make_invalid_location_object_with_invalid_lon_lat_y():
+    x, y, coordinate_system = 2.5, -200, "lon_lat"
+    with pytest.raises(ValueError) as err:
+        _ = Location(x=x, y=y, coordinate_system=coordinate_system)
+    assert err.typename == "ValidationError"
+
+
+def test_make_invalid_location_object_with_invalid_coordinate_system():
+    x, y, coordinate_system = 2.5, 1000, "abcd"
+    with pytest.raises(ValueError) as err:
+        _ = Location(x=x, y=y, coordinate_system=coordinate_system)
+    assert err.typename == "ValidationError"

tests/select/test_select_spatial_slice.py

@@ -0,0 +1,154 @@
+import numpy as np
+import xarray as xr
+from ocf_datapipes.utils import Location
+import pytest
+
+from ocf_data_sampler.select.select_spatial_slice import (
+    select_spatial_slice_pixels, _get_idx_of_pixel_closest_to_poi
+)
+
+@pytest.fixture(scope="module")
+def da():
+    # Create dummy data
+    x = np.arange(-100, 100)
+    y = np.arange(-100, 100)
+
+    da = xr.DataArray(
+        np.random.normal(size=(len(x), len(y))),
+        coords=dict(
+            x_osgb=(["x_osgb"], x),
+            y_osgb=(["y_osgb"], y),
+        )
+    )
+    return da
+
+
+def test_get_idx_of_pixel_closest_to_poi(da):
+    
+    idx_location  = _get_idx_of_pixel_closest_to_poi(
+        da,
+        location=Location(x=10, y=10, coordinate_system="osgb"),
+    )
+
+    assert idx_location.coordinate_system == "idx"
+    assert idx_location.x == 110
+    assert idx_location.y == 110
+
+
+
+
+def test_select_spatial_slice_pixels(da):
+
+    # Select window which lies within x-y bounds of the data
+    da_sliced = select_spatial_slice_pixels(
+        da,
+        location=Location(x=-90, y=-80, coordinate_system="osgb"),
+        width_pixels=10,
+        height_pixels=10,
+        allow_partial_slice=True,
+    )
+
+
+    assert isinstance(da_sliced, xr.DataArray)
+    assert (da_sliced.x_osgb.values == np.arange(-95, -85)).all()
+    assert (da_sliced.y_osgb.values == np.arange(-85, -75)).all()
+    # No padding in this case so no NaNs
+    assert not da_sliced.isnull().any()
+
+
+    # Select window where the edge of the window lies right on the edge of the data
+    da_sliced = select_spatial_slice_pixels(
+        da,
+        location=Location(x=-90, y=-80, coordinate_system="osgb"),
+        width_pixels=20,
+        height_pixels=20,
+        allow_partial_slice=True,
+    )
+
+    assert isinstance(da_sliced, xr.DataArray)
+    assert (da_sliced.x_osgb.values == np.arange(-100, -80)).all()
+    assert (da_sliced.y_osgb.values == np.arange(-90, -70)).all()
+    # No padding in this case so no NaNs
+    assert not da_sliced.isnull().any()
+
+    # Select window which is partially outside the boundary of the data - padded on left
+    da_sliced = select_spatial_slice_pixels(
+        da,
+        location=Location(x=-90, y=-80, coordinate_system="osgb"),
+        width_pixels=30,
+        height_pixels=30,
+        allow_partial_slice=True,
+    )
+
+    assert isinstance(da_sliced, xr.DataArray)
+    assert (da_sliced.x_osgb.values == np.arange(-105, -75)).all()
+    assert (da_sliced.y_osgb.values == np.arange(-95, -65)).all()
+    # Data has been padded on left by 5 NaN pixels
+    assert da_sliced.isnull().sum() == 5*len(da_sliced.y_osgb)
+
+
+    # Select window which is partially outside the boundary of the data - padded on right
+    da_sliced = select_spatial_slice_pixels(
+        da,
+        location=Location(x=90, y=-80, coordinate_system="osgb"),
+        width_pixels=30,
+        height_pixels=30,
+        allow_partial_slice=True,
+    )
+
+    assert isinstance(da_sliced, xr.DataArray)
+    assert (da_sliced.x_osgb.values == np.arange(75, 105)).all()
+    assert (da_sliced.y_osgb.values == np.arange(-95, -65)).all()
+    # Data has been padded on right by 5 NaN pixels
+    assert da_sliced.isnull().sum() == 5*len(da_sliced.y_osgb)
+
+
+    location = Location(x=-90, y=-0, coordinate_system="osgb")
+
+    # Select window which is partially outside the boundary of the data - padded on top
+    da_sliced = select_spatial_slice_pixels(
+        da,
+        location=Location(x=-90, y=95, coordinate_system="osgb"),
+        width_pixels=20,
+        height_pixels=20,
+        allow_partial_slice=True,
+    )
+
+    assert isinstance(da_sliced, xr.DataArray)
+    assert (da_sliced.x_osgb.values == np.arange(-100, -80)).all()
+    assert (da_sliced.y_osgb.values == np.arange(85, 105)).all()
+    # Data has been padded on top by 5 NaN pixels
+    assert da_sliced.isnull().sum() == 5*len(da_sliced.x_osgb)
+
+    # Select window which is partially outside the boundary of the data - padded on bottom
+    da_sliced = select_spatial_slice_pixels(
+        da,
+        location=Location(x=-90, y=-95, coordinate_system="osgb"),
+        width_pixels=20,
+        height_pixels=20,
+        allow_partial_slice=True,
+    )
+
+    assert isinstance(da_sliced, xr.DataArray)
+    assert (da_sliced.x_osgb.values == np.arange(-100, -80)).all()
+    assert (da_sliced.y_osgb.values == np.arange(-105, -85)).all()
+    # Data has been padded on bottom by 5 NaN pixels
+    assert da_sliced.isnull().sum() == 5*len(da_sliced.x_osgb)
+
+    # Select window which is partially outside the boundary of the data - padded right and bottom
+    da_sliced = select_spatial_slice_pixels(
+        da,
+        location=Location(x=90, y=-80, coordinate_system="osgb"),
+        width_pixels=50,
+        height_pixels=50,
+        allow_partial_slice=True,
+    )
+
+    assert isinstance(da_sliced, xr.DataArray)
+    assert (da_sliced.x_osgb.values == np.arange(65, 115)).all()
+    assert (da_sliced.y_osgb.values == np.arange(-105, -55)).all()
+    # Data has been padded on right by 15 pixels and bottom by 5 NaN pixels
+    assert da_sliced.isnull().sum() == 15*len(da_sliced.y_osgb) + 5*len(da_sliced.x_osgb) - 15*5
+
+
+

tests/select/test_select_time_slice.py

@@ -0,0 +1,284 @@
+from ocf_data_sampler.select.select_time_slice import select_time_slice, select_time_slice_nwp
+
+import numpy as np
+import pandas as pd
+import xarray as xr
+import pytest
+
+
+NWP_FREQ = pd.Timedelta("3H")
+
+@pytest.fixture(scope="module")
+def da_sat_like():
+    """Create dummy data which looks like satellite data"""
+    x = np.arange(-100, 100)
+    y = np.arange(-100, 100)
+    datetimes = pd.date_range("2024-01-02 00:00", "2024-01-03 00:00", freq="5min")
+
+    da_sat = xr.DataArray(
+        np.random.normal(size=(len(datetimes), len(x), len(y))),
+        coords=dict(
+            time_utc=(["time_utc"], datetimes),
+            x_geostationary=(["x_geostationary"], x),
+            y_geostationary=(["y_geostationary"], y),
+        )
+    )
+    return da_sat
+
+
+@pytest.fixture(scope="module")
+def da_nwp_like():
+    """Create dummy data which looks like NWP data"""
+
+    x = np.arange(-100, 100)
+    y = np.arange(-100, 100)
+    datetimes = pd.date_range("2024-01-02 00:00", "2024-01-03 00:00", freq=NWP_FREQ)
+    steps = pd.timedelta_range("0H", "16H", freq="1H")
+    channels = ["t", "dswrf"]
+
+    da_nwp = xr.DataArray(
+        np.random.normal(size=(len(datetimes), len(steps), len(channels), len(x), len(y))),
+        coords=dict(
+            init_time_utc=(["init_time_utc"], datetimes),
+            step=(["step"], steps),
+            channel=(["channel"], channels),
+            x_osgb=(["x_osgb"], x),
+            y_osgb=(["y_osgb"], y),
+        )
+    )
+    return da_nwp
+
+
+@pytest.mark.parametrize("t0_str", ["12:30", "12:40", "12:00"])
+def test_select_time_slice(da_sat_like, t0_str):
+    """Test the basic functionality of select_time_slice"""
+
+    # Slice parameters
+    t0 = pd.Timestamp(f"2024-01-02 {t0_str}")
+    forecast_duration = pd.Timedelta("0min")
+    history_duration = pd.Timedelta("60min")
+    freq = pd.Timedelta("5min")
+
+    # Expect to return these timestamps from the selection
+    expected_datetimes = pd.date_range(t0 - history_duration, t0 + forecast_duration, freq=freq)
+
+    # Make the selection using the `[x]_duration` parameters
+    sat_sample = select_time_slice(
+        ds=da_sat_like,
+        t0=t0,
+        history_duration=history_duration,
+        forecast_duration=forecast_duration,
+        sample_period_duration=freq,
+    )
+
+    # Check the returned times are as expected
+    assert (sat_sample.time_utc == expected_datetimes).all()
+
+    # Make the selection using the `interval_[x]` parameters
+    sat_sample = select_time_slice(
+        ds=da_sat_like,
+        t0=t0,
+        interval_start=-history_duration,
+        interval_end=forecast_duration,
+        sample_period_duration=freq,
+    )
+
+    # Check the returned times are as expected
+    assert (sat_sample.time_utc == expected_datetimes).all()
+
+
+@pytest.mark.parametrize("t0_str", ["00:00", "00:25", "11:00", "11:55"])
+def test_select_time_slice_out_of_bounds(da_sat_like, t0_str):
+    """Test the behaviour of select_time_slice when the selection is out of bounds"""
+
+    # Slice parameters
+    t0 = pd.Timestamp(f"2024-01-02 {t0_str}")
+    forecast_duration = pd.Timedelta("30min")
+    history_duration = pd.Timedelta("60min")
+    freq = pd.Timedelta("5min")
+
+    # The data is available between these times
+    min_time = da_sat_like.time_utc.min()
+    max_time = da_sat_like.time_utc.max()
+
+    # Expect to return these timestamps from the selection
+    expected_datetimes = pd.date_range(t0 - history_duration, t0 + forecast_duration, freq=freq)
+
+    # Make the partially out of bounds selection
+    sat_sample = select_time_slice(
+        ds=da_sat_like,
+        t0=t0,
+        history_duration=history_duration,
+        forecast_duration=forecast_duration,
+        sample_period_duration=freq,
+        fill_selection=True
+    )
+
+    # Check the returned times are as expected
+    assert (sat_sample.time_utc == expected_datetimes).all()
+
+    
+    # Check all the values before the first timestamp available in the data are NaN
+    all_nan_space = sat_sample.isnull().all(dim=("x_geostationary", "y_geostationary"))
+    if expected_datetimes[0] < min_time:    
+        assert all_nan_space.sel(time_utc=slice(None, min_time-freq)).all(dim="time_utc") 
+
+    # Check all the values before the first timestamp available in the data are NaN
+    if expected_datetimes[-1] > max_time:    
+        assert all_nan_space.sel(time_utc=slice(max_time+freq, None)).all(dim="time_utc")   
+
+    # Check that none of the values between the first and last available timestamp are NaN
+    any_nan_space = sat_sample.isnull().any(dim=("x_geostationary", "y_geostationary"))
+    assert not any_nan_space.sel(time_utc=slice(min_time, max_time)).any(dim="time_utc")
+
+
+@pytest.mark.parametrize("t0_str", ["10:00", "11:00", "12:00"])
+def test_select_time_slice_nwp_basic(da_nwp_like, t0_str):
+    """Test the basic functionality of select_time_slice_nwp"""
+
+    # Slice parameters
+    t0 = pd.Timestamp(f"2024-01-02 {t0_str}")
+    forecast_duration = pd.Timedelta("6H")
+    history_duration = pd.Timedelta("3H")
+    freq = pd.Timedelta("1H")
+
+    # Make the selection
+    da_slice = select_time_slice_nwp(
+        da_nwp_like,
+        t0,
+        sample_period_duration=freq,
+        history_duration=history_duration,
+        forecast_duration=forecast_duration,
+        dropout_timedeltas = None,
+        dropout_frac = 0,
+        accum_channels = [],
+        channel_dim_name = "channel",
+    )
+
+    # Check the target-times are as expected
+    expected_target_times = pd.date_range(t0 - history_duration, t0 + forecast_duration, freq=freq)
+    assert (da_slice.target_time_utc==expected_target_times).all()
+
+    # Check the init-times are as expected
+    # - Forecast frequency is `NWP_FREQ`, and we can't have selected future init-times
+    expected_init_times = pd.to_datetime(
+        [t if t<t0 else t0 for t in expected_target_times]
+    ).floor(NWP_FREQ)
+    assert (da_slice.init_time_utc==expected_init_times).all()
+
+
+@pytest.mark.parametrize("dropout_hours", [1, 2, 5])
+def test_select_time_slice_nwp_with_dropout(da_nwp_like, dropout_hours):
+    """Test the functionality of select_time_slice_nwp with dropout"""
+
+    t0 = pd.Timestamp("2024-01-02 12:00")
+    forecast_duration = pd.Timedelta("6H")
+    history_duration = pd.Timedelta("3H")
+    freq = pd.Timedelta("1H")
+    dropout_timedelta = pd.Timedelta(f"-{dropout_hours}H")
+
+    da_slice = select_time_slice_nwp(
+        da_nwp_like,
+        t0,
+        sample_period_duration=freq,
+        history_duration=history_duration,
+        forecast_duration=forecast_duration,
+        dropout_timedeltas = [dropout_timedelta],
+        dropout_frac = 1,
+        accum_channels = [],
+        channel_dim_name = "channel",
+    )
+
+    # Check the target-times are as expected
+    expected_target_times = pd.date_range(t0 - history_duration, t0 + forecast_duration, freq=freq)
+    assert (da_slice.target_time_utc==expected_target_times).all()
+
+    # Check the init-times are as expected considering the delay
+    t0_delayed = t0 + dropout_timedelta
+    expected_init_times = pd.to_datetime(
+        [t if t<t0_delayed else t0_delayed for t in expected_target_times]
+    ).floor(NWP_FREQ)
+    assert (da_slice.init_time_utc==expected_init_times).all()
+
+
+@pytest.mark.parametrize("t0_str", ["10:00", "11:00", "12:00"])
+def test_select_time_slice_nwp_with_dropout_and_accum(da_nwp_like, t0_str):
+    """Test the functionality of select_time_slice_nwp with dropout and accumulated variables"""
+
+    # Slice parameters
+    t0 = pd.Timestamp(f"2024-01-02 {t0_str}")
+    forecast_duration = pd.Timedelta("6H")
+    history_duration = pd.Timedelta("3H")
+    freq = pd.Timedelta("1H")
+    dropout_timedelta = pd.Timedelta("-2H")
+
+    t0_delayed = (t0 + dropout_timedelta).floor(NWP_FREQ)
+
+    da_slice = select_time_slice_nwp(
+        da_nwp_like,
+        t0,
+        sample_period_duration=freq,
+        history_duration=history_duration,
+        forecast_duration=forecast_duration,
+        dropout_timedeltas=[dropout_timedelta],
+        dropout_frac=1,
+        accum_channels=["dswrf"],
+        channel_dim_name="channel",
+    )
+
+    # Check the target-times are as expected
+    expected_target_times = pd.date_range(t0 - history_duration, t0 + forecast_duration, freq=freq)
+    assert (da_slice.target_time_utc==expected_target_times).all()
+
+    # Check the init-times are as expected considering the delay
+    expected_init_times = pd.to_datetime(
+        [t if t<t0_delayed else t0_delayed for t in expected_target_times]
+    ).floor(NWP_FREQ)
+    assert (da_slice.init_time_utc==expected_init_times).all()
+
+    # Check channels are as expected
+    assert (da_slice.channel.values == ["t", "diff_dswrf"]).all()
+
+    # Check the accummulated channel has been differenced correctly
+
+    # This part of the data is pulled from the init-time: t0_delayed
+    da_slice_accum = da_slice.sel(
+        target_time_utc=slice(t0_delayed, None), 
+        channel="diff_dswrf"
+    )
+
+    # Get the original data for the t0_delayed init-time, and diff it along steps
+    # then select the steps which are expected to be used in the above slice
+    da_orig_diffed = (
+        da_nwp_like.sel(
+            init_time_utc=t0_delayed, 
+            channel="dswrf", 
+        ).diff(dim="step", label="lower")
+        .sel(step=slice(t0-t0_delayed - history_duration, t0-t0_delayed + forecast_duration))
+    )
+
+    # Check the values are the same
+    assert (da_slice_accum.values == da_orig_diffed.values).all()
+
+    # Check the non-accummulated channel has not been differenced
+
+    # This part of the data is pulled from the init-time: t0_delayed
+    da_slice_nonaccum = da_slice.sel(
+        target_time_utc=slice(t0_delayed, None), 
+        channel="t"
+    )
+
+    # Get the original data for the t0_delayed init-time, and select the steps which are expected 
+    # to be used in the above slice
+    da_orig = (
+        da_nwp_like.sel(
+            init_time_utc=t0_delayed, 
+            channel="t", 
+        )
+        .sel(step=slice(t0-t0_delayed - history_duration, t0-t0_delayed + forecast_duration))
+    )
+
+    # Check the values are the same
+    assert (da_slice_nonaccum.values == da_orig.values).all()
+
+