diff --git a/README.md b/README.md
index 15c0dff8d..2aae459c2 100644
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@ Below is a **curated selection** of the metrics, tools and statistical tests inc
 |-----------------------	|-----------------	|--------------	|
 | **[Continuous](https://scores.readthedocs.io/en/stable/included.html#continuous)**        	|Scores for evaluating single-valued continuous forecasts.                  	|MAE, MSE, RMSE, Additive Bias, Multiplicative Bias, Percent Bias, Pearson's Correlation Coefficient, Kling-Gupta Efficiency, Flip-Flop Index, Quantile Loss, Quantile Interval Score, Interval Score, Murphy Score, and threshold weighted scores for expectiles, quantiles and Huber Loss.             	|
 | **[Probability](https://scores.readthedocs.io/en/stable/included.html#probability)**        |Scores for evaluating forecasts that are expressed as predictive distributions, ensembles, and probabilities of binary events.                   |Brier Score, Continuous Ranked Probability Score (CRPS) for Cumulative Density Functions (CDF) and ensembles (including threshold weighted versions), Receiver Operating Characteristic (ROC), Isotonic Regression (reliability diagrams).               |
-| **[Categorical](https://scores.readthedocs.io/en/stable/included.html#categorical)**       	|Scores for evaluating forecasts of categories.                	|18 binary contingency table (confusion matrix) metrics and the FIxed Risk Multicategorical (FIRM) Score.               	|
+| **[Categorical](https://scores.readthedocs.io/en/stable/included.html#categorical)**       	|Scores for evaluating forecasts of categories.                	|18 binary contingency table (confusion matrix) metrics, the FIxed Risk Multicategorical (FIRM) Score, and the SEEPS score.               	|
 | **[Spatial](https://scores.readthedocs.io/en/stable/included.html#spatial)** 	|Scores that take into account spatial structure.                 	|Fractions Skill Score.              	|
 | **[Statistical Tests](https://scores.readthedocs.io/en/stable/included.html#statistical-tests)** 	|Tools to conduct statistical tests and generate confidence intervals.                 	|Diebold Mariano.              	|
 | **[Processing Tools](https://scores.readthedocs.io/en/stable/included.html#processing-tools-for-preparing-data)**        	|Tools to pre-process data.                 	|Data matching, Discretisation, Cumulative Density Function Manipulation.              	|
diff --git a/docs/api.md b/docs/api.md
index 9900cec54..ba0e8fac8 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -68,6 +68,7 @@
     :members:
 .. autoclass:: scores.categorical.EventOperator
     :members:
+.. autofunction:: scores.categorical.seeps
 ```
 
 ## scores.spatial
diff --git a/docs/included.md b/docs/included.md
index 8c571e92d..ee42ea343 100644
--- a/docs/included.md
+++ b/docs/included.md
@@ -559,6 +559,10 @@
   - [API](api.md#scores.categorical.probability_of_false_detection)
   - [Tutorial](project:./tutorials/ROC.md)
   - [Probability of false detection (WWRP/WGNE Joint Working Group on Forecast Verification Research)](https://www.cawcr.gov.au/projects/verification/#POFD)
+* - Stable Equitable Error in Probability Space (SEEPS)
+  - [API](api.md#scores.categorical.seeps)
+  - [Tutorial](project:./tutorials/SEEPS.md)
+  - [Rodwell et al. (2010)](https://doi.org/10.1002/qj.656)
 * - Threshold Event Operator
   - [API](api.md#scores.categorical.ThresholdEventOperator)
   - [Tutorial](project:./tutorials/Binary_Contingency_Scores.md)
diff --git a/src/scores/categorical/__init__.py b/src/scores/categorical/__init__.py
index 084c1e820..b5f50366f 100644
--- a/src/scores/categorical/__init__.py
+++ b/src/scores/categorical/__init__.py
@@ -12,12 +12,13 @@
     EventOperator,
     ThresholdEventOperator,
 )
-from scores.categorical.multicategorical_impl import firm
+from scores.categorical.multicategorical_impl import firm, seeps
 
 __all__ = [
     "probability_of_detection",
     "probability_of_false_detection",
     "firm",
+    "seeps",
     "BasicContingencyManager",
     "BinaryContingencyManager",
     "ThresholdEventOperator",
diff --git a/src/scores/categorical/multicategorical_impl.py b/src/scores/categorical/multicategorical_impl.py
index a7f218bd7..ff7fbbc80 100644
--- a/src/scores/categorical/multicategorical_impl.py
+++ b/src/scores/categorical/multicategorical_impl.py
@@ -3,12 +3,13 @@
 """
 
 from collections.abc import Sequence
-from typing import Iterable, Optional, Union
+from typing import Optional, Union
 
 import numpy as np
 import xarray as xr
 
 from scores.functions import apply_weights
+from scores.processing import broadcast_and_match_nan
 from scores.typing import FlexibleDimensionTypes
 from scores.utils import check_dims, gather_dimensions
 
@@ -132,7 +133,7 @@ def firm(  # pylint: disable=too-many-arguments
 
 def _check_firm_inputs(
     obs, risk_parameter, categorical_thresholds, threshold_weights, discount_distance, threshold_assignment
-):  # pylint: disable=too-many-positional-arguments
+):
     """
     Checks that the FIRM inputs are suitable
     """
@@ -244,3 +245,176 @@ def _single_category_score(
     )
     score = score.transpose(*fcst.dims)
     return score
+
+
+def seeps(  # pylint: disable=too-many-arguments, too-many-locals
+    fcst: xr.DataArray,
+    obs: xr.DataArray,
+    p1: xr.DataArray,
+    p3: xr.DataArray,
+    light_heavy_threshold: xr.DataArray,
+    *,  # Force keywords arguments to be keyword-only
+    dry_light_threshold: Optional[float] = 0.2,
+    mask_clim_extremes: Optional[bool] = True,
+    min_masked_value: Optional[float] = 0.1,
+    max_masked_value: Optional[float] = 0.85,
+    reduce_dims: Optional[FlexibleDimensionTypes] = None,
+    preserve_dims: Optional[FlexibleDimensionTypes] = None,
+    weights: Optional[xr.DataArray] = None,
+) -> xr.DataArray:
+    r"""
+    Calculates the stable equitable error in probability space (SEEPS) score.
+
+    When used to evaluate precipitation forecasts, the SEEPS score calculates the
+    performance of a forecast across three categories:
+
+    - Dry weather (e.g., less than or equal to 0.2mm),
+    - Light precipitation (the climatological lower two-thirds of rainfall above
+      the dry threshold),
+    - Heavy precipitation (the climatological upper one-third of rainfall above
+      the dry threshold).
+
+    The SEEPS penalty matrix is defined as
+
+    
+    .. math::
+        s = \frac{1}{2} \left(
+        \begin{matrix}
+         0 & \frac{1}{1-p_1} & \frac{1}{p_3}+\frac{1}{1-p_1} \\
+        \frac{1}{p_1} & 0 & \frac{1}{p_3} \\
+        \frac{1}{p_1}+\frac{1}{1-p_3} & \frac{1}{1-p_3} & 0
+        \end{matrix}
+        \right)
+
+        
+    where 
+        - :math:`p_1` is the climatological probability of the dry weather category
+        - :math:`p_3` is the climatological probability of the heavy precipitation category.
+        - The rows correspond to the forecast category (dry, light, heavy).
+        - The columns correspond to the observation category (dry, light, heavy).
+
+    Note that although :math:`p_2`, does not appear in the penalty matrix, it is defined as
+    :math:`p_2 = 2p_3` with :math:`p_1 + p_2 + p_3 = 1` which means that the light 
+    precipitation category is twice as likely to occur climatologically as the 
+    heavy precipitation category.
+
+    This implementation of the score is negatively oriented, meaning that lower scores are better. 
+    Sometimes in the literature, a SEEPS skill score is used, which is defined as 1 - SEEPS.
+
+    By default, the scores are only calculated for points where :math:`p_1 \in [0.1, 0.85]` 
+    as per Rodwell et al. (2010). This can be changed by setting ``mask_clim_extremes`` to ``False`` or
+    by changing the ``min_masked_value`` and ``max_masked_value`` parameters.
+
+    For further details on generating the p1 and p3 arrays, see Rodwell et al. (2010).
+
+    Args:
+        fcst: An array of real-valued forecasts.
+        obs: An array of real-valued observations.
+        p1: The climatological probability of the dry weather category.
+        p3: The climatological probability of the heavy precipitation category. 
+        light_heavy_threshold: An array of the rainfall thresholds that separates 
+            light and heavy precipitation. Light precipitation is inclusive of this
+            threshold.
+        dry_light_threshold: The threshold that separates dry weather from light precipitation.
+            Defaults to 0.2. Dry weather is defined as less than or equal to this threshold.
+        mask_clim_extremes: If True, mask out the climatological extremes.
+        min_masked_value: Points with climatolgical probabilities of dry weather
+            less than this value are masked. Defaults to 0.1.
+        max_masked_value: Points with climatolgical probabilities of dry weather
+            greater than this value are masked. Defaults to 0.85.
+        reduce_dims: Optionally specify which dimensions to reduce when
+            calculating the SEEPS score. All other dimensions will be preserved. As a
+            special case, 'all' will allow all dimensions to be reduced. Only one
+            of `reduce_dims` and `preserve_dims` can be supplied. The default behaviour
+            if neither are supplied is to reduce all dims.
+        preserve_dims: Optionally specify which dimensions to preserve
+            when calculating SEEPS. All other dimensions will be reduced.
+            As a special case, 'all' will allow all dimensions to be
+            preserved. In this case, the result will be in the same
+            shape/dimensionality as the forecast, and the errors will be
+            the SEEPS score at each point (i.e. single-value comparison
+            against observed), and the forecast and observed dimensions
+            must match precisely. Only one of `reduce_dims` and `preserve_dims` can be
+            supplied. The default behaviour if neither are supplied is to reduce all dims.
+        weights: Optionally provide an array for weighted averaging (e.g. by area).
+
+    Returns:
+        An xarray DataArray containing the SEEPS score.
+
+    Raises:
+        ValueError: if any values in `p1` are outside the range [0, 1].
+        ValueError: if any values in `p3` are outside the range [0, 1].
+    
+    References:
+        Rodwell, M. J., Richardson, D. S., Hewson, T. D., & Haiden, T. (2010). 
+        A new equitable score suitable for verifying precipitation in numerical 
+        weather prediction. Quarterly Journal of the Royal Meteorological Society, 
+        136(650), 1344–1363. https://doi.org/10.1002/qj.656
+
+    Examples:
+        >>> import numpy as np
+        >>> import xarray as xr
+        >>> from scores.categorical import seeps
+        >>> fcst = xr.DataArray(np.random.rand(4, 6, 8), dims=['time', 'lat', 'lon'])
+        >>> obs = xr.DataArray(np.random.rand(4, 6, 8), dims=['time', 'lat', 'lon'])
+        >>> p1 = xr.DataArray(np.random.rand(6, 8), dims=['lat', 'lon'])
+        >>> p3 = (1 - p1) / 3 
+        >>> light_heavy_threshold = 2 * xr.DataArray(np.random.rand(4, 6, 8), dims=['time', 'lat', 'lon'])
+        >>> seeps(fcst, obs, p1, p3, light_heavy_threshold=light_heavy_threshold)
+    """
+    if p1.min() < 0 or p1.max() > 1:
+        raise ValueError("`p1` must have values between 0 and 1 inclusive")
+    if p3.min() < 0 or p3.max() > 1:
+        raise ValueError("`p3` must have values between 0 and 1 inclusive")
+
+    reduce_dims = gather_dimensions(fcst.dims, obs.dims, reduce_dims=reduce_dims, preserve_dims=preserve_dims)
+    fcst, obs = broadcast_and_match_nan(fcst, obs)
+
+    # Penalties for index i, j in the penalty matrix. Row i corresponds to the
+    # forecast category while row j corresponds to the observation category
+    # row 1 of the penalty matrix
+    index_12 = 1 / (1 - p1)
+    index_13 = (1 / p3) + (1 / (1 - p1))
+    # row 2 of the penalty matrix
+    index_21 = 1 / p1
+    index_23 = 1 / p3
+    # row 3 of the penalty matrix
+    index_31 = (1 / p1) + (1 / (1 - p3))
+    index_32 = 1 / (1 - p3)
+
+    # Get conditions for each category
+    fcst1_condition = fcst <= dry_light_threshold
+    fcst2_condition = (fcst > dry_light_threshold) & (fcst <= light_heavy_threshold)
+    fcst3_condition = fcst > light_heavy_threshold
+
+    obs1_condition = obs <= dry_light_threshold
+    obs2_condition = (obs > dry_light_threshold) & (obs <= light_heavy_threshold)
+    obs3_condition = obs > light_heavy_threshold
+
+    # Calculate the penalties
+    result = fcst.copy() * 0
+    result = result.where(~(fcst1_condition & obs2_condition), index_12.broadcast_like(result))
+    result = result.where(~(fcst1_condition & obs3_condition), index_13.broadcast_like(result))
+    result = result.where(~(fcst2_condition & obs1_condition), index_21.broadcast_like(result))
+    result = result.where(~(fcst2_condition & obs3_condition), index_23.broadcast_like(result))
+    result = result.where(~(fcst3_condition & obs1_condition), index_31.broadcast_like(result))
+    result = result.where(~(fcst3_condition & obs2_condition), index_32.broadcast_like(result))
+
+    result = result / 2
+    # return NaNs
+    result = result.where(
+        ~np.isnan(fcst)
+        & ~np.isnan(obs)
+        & ~np.isnan(p1)
+        & ~np.isnan(p3)
+        & ~np.isnan(light_heavy_threshold)
+        & ~np.isnan(dry_light_threshold)
+    )
+
+    if mask_clim_extremes:
+        result = result.where(np.logical_and(p1 <= max_masked_value, p1 >= min_masked_value))
+
+    result = apply_weights(result, weights=weights)
+    result = result.mean(dim=reduce_dims)
+
+    return result
diff --git a/tests/categorical/multicategorical_test_data.py b/tests/categorical/multicategorical_test_data.py
index 473a2eeb5..8d4660b9c 100644
--- a/tests/categorical/multicategorical_test_data.py
+++ b/tests/categorical/multicategorical_test_data.py
@@ -3,6 +3,7 @@
 """
 
 import numpy as np
+import pandas as pd
 import xarray as xr
 
 DA_FCST_SC = xr.DataArray(
@@ -665,3 +666,170 @@
         "overforecast_penalty": EXP_FIRM_OVER_CASE6,
     }
 )
+# Data for SEEPS testing
+DA_OBS_SEEPS = xr.DataArray(
+    data=[[0, 0.21, 15, -0.1, 5], [20, 0.2, 10, 200, 3], [20, 0.2, 10, 200, 3]],
+    dims=["t", "j"],
+    coords={
+        "j": [1, 2, 3, 4, 5],
+        "t": pd.date_range("2020-01-01", periods=3),
+    },
+)
+
+DA_FCST_SEEPS = xr.DataArray(
+    data=[[0, 0.1, 0.2, 0.21, 5], [10, 15, 20, 200, np.nan]],
+    dims=["t", "j"],
+    coords={
+        "j": [1, 2, 3, 4, 5],
+        "t": pd.date_range("2020-01-01", periods=2),
+    },
+)
+DA_FCST2_SEEPS = xr.DataArray(
+    data=[
+        [[0, np.nan, np.nan, np.nan, 5], [np.nan, np.nan, np.nan, 200, np.nan]],
+        [[0, 0.1, 0.2, 0.21, 5], [10, 15, 20, 200, np.nan]],
+    ],
+    dims=["i", "t", "j"],
+    coords={
+        "i": [1, 2],
+        "j": [1, 2, 3, 4, 5],
+        "t": pd.date_range("2020-01-01", periods=2),
+    },
+)
+DA_SEEPS_WEIGHTS = xr.DataArray(
+    data=[1, 2],
+    dims=["i"],
+    coords={"i": [1, 2]},
+)
+
+DA_P1_SEEPS = xr.DataArray(0.5)
+DA_P3_SEEPS = (1 - DA_P1_SEEPS) / 3
+DA_P1_VARY1_SEEPS = xr.DataArray(
+    data=[0.5, 0.09, 0.1, 0.5, 0.5],
+    dims=["j"],
+    coords={"j": [1, 2, 3, 4, 5]},
+)
+DA_P3_VARY1_SEEPS = (1 - DA_P1_VARY1_SEEPS) / 3
+
+DA_P1_VARY2_SEEPS = xr.DataArray(
+    data=[0.5, 0.85, 0.86, 0.5, 0.5],
+    dims=["j"],
+    coords={"j": [1, 2, 3, 4, 5]},
+)
+DA_P3_VARY2_SEEPS = (1 - DA_P1_VARY2_SEEPS) / 3
+
+
+DA_LIGHT_HEAVY_THRESHOLD_SEEPS = xr.DataArray(10)
+DA_LIGHT_HEAVY_THRESHOLD_VARY_SEEPS = xr.DataArray(
+    data=[10, 20], dims=["t"], coords={"t": pd.date_range("2020-01-01", periods=2)}
+)
+
+P1 = 0.5
+P3 = (1 - P1) / 3
+
+ALL_INDEX_ARRAY_RESULT = [
+    [0, 1 / (1 - P1), 1 / P3 + 1 / (1 - P1), 1 / P1, 0],
+    [1 / P3, 1 / P1 + 1 / (1 - P3), 1 / (1 - P3), 0, np.nan],
+]
+
+EXP_SEEPS_CASE0 = 0.5 * xr.DataArray(
+    data=ALL_INDEX_ARRAY_RESULT,
+    dims=["t", "j"],
+    coords={
+        "j": [1, 2, 3, 4, 5],
+        "t": pd.date_range("2020-01-01", periods=2),
+    },
+)
+EXP_SEEPS_CASE1 = EXP_SEEPS_CASE0.mean()
+EXP_SEEPS_CASE2 = EXP_SEEPS_CASE0.mean(dim="j")
+EXP_SEEPS_CASE3 = EXP_SEEPS_CASE0.mean(dim="t")
+EXP_SEEPS_CASE4 = 0.5 * xr.DataArray(
+    data=[
+        [
+            [0, np.nan, np.nan, np.nan, 0],
+            [np.nan, np.nan, np.nan, 0, np.nan],
+        ],
+        ALL_INDEX_ARRAY_RESULT,
+    ],
+    dims=["i", "t", "j"],
+    coords={
+        "i": [1, 2],
+        "j": [1, 2, 3, 4, 5],
+        "t": pd.date_range("2020-01-01", periods=2),
+    },
+)
+EXP_SEEPS_CASE5 = 0.5 * xr.DataArray(
+    data=[
+        np.array([[0, np.nan, np.nan, np.nan, 0], [np.nan, np.nan, np.nan, 0, np.nan]]),
+        2 * np.array(ALL_INDEX_ARRAY_RESULT),
+    ],
+    dims=["i", "t", "j"],
+    coords={
+        "i": [1, 2],
+        "j": [1, 2, 3, 4, 5],
+        "t": pd.date_range("2020-01-01", periods=2),
+    },
+)
+
+EXP_SEEPS_CASE6 = EXP_SEEPS_CASE0 * 0
+
+# P1 varies by j with 0.5, 0.09, 0.1, 0.5, 0.5
+EXP_SEEPS_CASE7 = 0.5 * xr.DataArray(
+    data=[
+        [0, 1 / (1 - 0.09), 1 / ((1 - 0.1) / 3) + 1 / (1 - 0.1), 1 / 0.5, 0],
+        [1 / (1 / 6), 1 / 0.09 + 1 / (1 - ((1 - 0.09) / 3)), 1 / (1 - (0.9 / 3)), 0, np.nan],
+    ],
+    dims=["t", "j"],
+    coords={
+        "j": [1, 2, 3, 4, 5],
+        "t": pd.date_range("2020-01-01", periods=2),
+    },
+)
+# P1 varies by j with 0.5, 0.85, 0.86, 0.5, 0.5
+EXP_SEEPS_CASE8 = 0.5 * xr.DataArray(
+    data=[
+        [0, 1 / (1 - 0.85), 1 / ((1 - 0.86) / 3) + 1 / (1 - 0.86), 1 / 0.5, 0],
+        [1 / (1 / 6), 1 / 0.85 + 1 / (1 - 0.15 / 3), 1 / (1 - ((1 - 0.86) / 3)), 0, np.nan],
+    ],
+    dims=["t", "j"],
+    coords={
+        "j": [1, 2, 3, 4, 5],
+        "t": pd.date_range("2020-01-01", periods=2),
+    },
+)
+# j = 2 should be masked
+EXP_SEEPS_CASE9 = 0.5 * xr.DataArray(
+    data=[
+        [0, np.nan, 1 / ((1 - 0.1) / 3) + 1 / (1 - 0.1), 1 / 0.5, 0],
+        [1 / (1 / 6), np.nan, 1 / (1 - (0.9 / 3)), 0, np.nan],
+    ],
+    dims=["t", "j"],
+    coords={
+        "j": [1, 2, 3, 4, 5],
+        "t": pd.date_range("2020-01-01", periods=2),
+    },
+)
+# j =3 should be masked
+EXP_SEEPS_CASE10 = 0.5 * xr.DataArray(
+    data=[
+        [0, 1 / (1 - 0.85), np.nan, 1 / 0.5, 0],
+        [1 / (1 / 6), 1 / 0.85 + 1 / (1 - 0.15 / 3), np.nan, 0, np.nan],
+    ],
+    dims=["t", "j"],
+    coords={
+        "j": [1, 2, 3, 4, 5],
+        "t": pd.date_range("2020-01-01", periods=2),
+    },
+)
+
+EXP_SEEPS_CASE11 = 0.5 * xr.DataArray(
+    data=[
+        [0, 1 / (1 - P1), 1 / P3 + 1 / (1 - P1), 1 / P1, 0],
+        [0, 1 / P1, 0, 0, np.nan],
+    ],
+    dims=["t", "j"],
+    coords={
+        "j": [1, 2, 3, 4, 5],
+        "t": pd.date_range("2020-01-01", periods=2),
+    },
+)
diff --git a/tests/categorical/test_multicategorical.py b/tests/categorical/test_multicategorical.py
index 8a7ee5c1e..0f04e8eca 100644
--- a/tests/categorical/test_multicategorical.py
+++ b/tests/categorical/test_multicategorical.py
@@ -12,7 +12,7 @@
 import pytest
 import xarray as xr
 
-from scores.categorical import firm
+from scores.categorical import firm, seeps
 from scores.categorical.multicategorical_impl import _single_category_score
 from scores.utils import DimensionError
 from tests.categorical import multicategorical_test_data as mtd
@@ -509,3 +509,301 @@ def test_firm_raises(
             preserve_dims=preserve_dims,
             threshold_assignment=threshold_assignment,
         )
+
+
+@pytest.mark.parametrize(
+    (
+        "fcst",
+        "obs",
+        "p1",
+        "p3",
+        "light_heavy_threshold",
+        "dry_light_threshold",
+        "mask_clim_extremes",
+        "min_masked_value",
+        "max_masked_value",
+        "reduce_dims",
+        "preserve_dims",
+        "weights",
+        "expected",
+    ),
+    [
+        # Preserve all dims, tests each entry of the penalty matrix
+        (
+            mtd.DA_FCST_SEEPS,
+            mtd.DA_OBS_SEEPS,
+            mtd.DA_P1_SEEPS,
+            mtd.DA_P3_SEEPS,
+            mtd.DA_LIGHT_HEAVY_THRESHOLD_SEEPS,
+            0.2,
+            True,
+            0.1,
+            0.85,
+            None,
+            "all",
+            None,
+            mtd.EXP_SEEPS_CASE0,
+        ),
+        # Reduce all dims, tests each entry of the penalty matrix
+        (
+            mtd.DA_FCST_SEEPS,
+            mtd.DA_OBS_SEEPS,
+            mtd.DA_P1_SEEPS,
+            mtd.DA_P3_SEEPS,
+            mtd.DA_LIGHT_HEAVY_THRESHOLD_SEEPS,
+            0.2,
+            True,
+            0.1,
+            0.85,
+            None,
+            None,
+            None,
+            mtd.EXP_SEEPS_CASE1,
+        ),
+        # Preserve dim t, tests each entry of the penalty matrix
+        (
+            mtd.DA_FCST_SEEPS,
+            mtd.DA_OBS_SEEPS,
+            mtd.DA_P1_SEEPS,
+            mtd.DA_P3_SEEPS,
+            mtd.DA_LIGHT_HEAVY_THRESHOLD_SEEPS,
+            0.2,
+            True,
+            0.1,
+            0.85,
+            None,
+            "t",
+            None,
+            mtd.EXP_SEEPS_CASE2,
+        ),
+        # Reduce dim t, tests each entry of the penalty matrix
+        (
+            mtd.DA_FCST_SEEPS,
+            mtd.DA_OBS_SEEPS,
+            mtd.DA_P1_SEEPS,
+            mtd.DA_P3_SEEPS,
+            mtd.DA_LIGHT_HEAVY_THRESHOLD_SEEPS,
+            0.2,
+            True,
+            0.1,
+            0.85,
+            "t",
+            None,
+            None,
+            mtd.EXP_SEEPS_CASE3,
+        ),
+        # Test broadcasting of extra fcst dim
+        (
+            mtd.DA_FCST2_SEEPS,
+            mtd.DA_OBS_SEEPS,
+            mtd.DA_P1_SEEPS,
+            mtd.DA_P3_SEEPS,
+            mtd.DA_LIGHT_HEAVY_THRESHOLD_SEEPS,
+            0.2,
+            True,
+            0.1,
+            0.85,
+            None,
+            "all",
+            None,
+            mtd.EXP_SEEPS_CASE4,
+        ),
+        # Test weighting
+        (
+            mtd.DA_FCST2_SEEPS,
+            mtd.DA_OBS_SEEPS,
+            mtd.DA_P1_SEEPS,
+            mtd.DA_P3_SEEPS,
+            mtd.DA_LIGHT_HEAVY_THRESHOLD_SEEPS,
+            0.2,
+            True,
+            0.1,
+            0.85,
+            None,
+            "all",
+            mtd.DA_SEEPS_WEIGHTS,
+            mtd.EXP_SEEPS_CASE5,
+        ),
+        # Test different dry_light_threshold
+        (
+            mtd.DA_FCST_SEEPS,
+            mtd.DA_OBS_SEEPS,
+            mtd.DA_P1_SEEPS,
+            mtd.DA_P3_SEEPS,
+            1000 * mtd.DA_LIGHT_HEAVY_THRESHOLD_SEEPS,
+            1000,
+            True,
+            0.1,
+            0.85,
+            None,
+            "all",
+            None,
+            mtd.EXP_SEEPS_CASE6,
+        ),
+        # Vary P1 and P3, with no masking
+        (
+            mtd.DA_FCST_SEEPS,
+            mtd.DA_OBS_SEEPS,
+            mtd.DA_P1_VARY1_SEEPS,
+            mtd.DA_P3_VARY1_SEEPS,
+            mtd.DA_LIGHT_HEAVY_THRESHOLD_SEEPS,
+            0.2,
+            False,
+            None,
+            None,
+            None,
+            "all",
+            None,
+            mtd.EXP_SEEPS_CASE7,
+        ),
+        # Vary P1 and P3 to test with different edge cases from above, with no masking
+        (
+            mtd.DA_FCST_SEEPS,
+            mtd.DA_OBS_SEEPS,
+            mtd.DA_P1_VARY2_SEEPS,
+            mtd.DA_P3_VARY2_SEEPS,
+            mtd.DA_LIGHT_HEAVY_THRESHOLD_SEEPS,
+            0.2,
+            False,
+            None,
+            None,
+            None,
+            "all",
+            None,
+            mtd.EXP_SEEPS_CASE8,
+        ),
+        # Test masking of lower masking threshold
+        (
+            mtd.DA_FCST_SEEPS,
+            mtd.DA_OBS_SEEPS,
+            mtd.DA_P1_VARY1_SEEPS,
+            mtd.DA_P3_VARY1_SEEPS,
+            mtd.DA_LIGHT_HEAVY_THRESHOLD_SEEPS,
+            0.2,
+            True,
+            0.1,
+            0.85,
+            None,
+            "all",
+            None,
+            mtd.EXP_SEEPS_CASE9,
+        ),
+        # Test masking of upper masking threshold
+        (
+            mtd.DA_FCST_SEEPS,
+            mtd.DA_OBS_SEEPS,
+            mtd.DA_P1_VARY2_SEEPS,
+            mtd.DA_P3_VARY2_SEEPS,
+            mtd.DA_LIGHT_HEAVY_THRESHOLD_SEEPS,
+            0.2,
+            True,
+            0.1,
+            0.85,
+            None,
+            "all",
+            None,
+            mtd.EXP_SEEPS_CASE10,
+        ),
+        # Test varying light_heavy_threshold
+        (
+            mtd.DA_FCST_SEEPS,
+            mtd.DA_OBS_SEEPS,
+            mtd.DA_P1_SEEPS,
+            mtd.DA_P3_SEEPS,
+            mtd.DA_LIGHT_HEAVY_THRESHOLD_VARY_SEEPS,
+            0.2,
+            True,
+            0.1,
+            0.85,
+            None,
+            "all",
+            None,
+            mtd.EXP_SEEPS_CASE11,
+        ),
+    ],
+)
+def test_seeps(  # pylint: disable=too-many-arguments
+    fcst,
+    obs,
+    p1,
+    p3,
+    light_heavy_threshold,
+    dry_light_threshold,
+    mask_clim_extremes,
+    min_masked_value,
+    max_masked_value,
+    reduce_dims,
+    preserve_dims,
+    weights,
+    expected,
+):
+    """Tests seeps"""
+    calculated = seeps(
+        fcst,
+        obs,
+        p1,
+        p3,
+        light_heavy_threshold=light_heavy_threshold,
+        dry_light_threshold=dry_light_threshold,
+        mask_clim_extremes=mask_clim_extremes,
+        min_masked_value=min_masked_value,
+        max_masked_value=max_masked_value,
+        reduce_dims=reduce_dims,
+        preserve_dims=preserve_dims,
+        weights=weights,
+    )
+
+    xr.testing.assert_allclose(
+        calculated,
+        expected,
+    )
+
+
+@pytest.mark.parametrize(
+    ("p1", "p3", "exp"),
+    [
+        (xr.DataArray(-0.01), xr.DataArray(0.5), "`p1` must have values between 0 and 1 inclusive"),
+        (xr.DataArray(1.01), xr.DataArray(0.5), "`p1` must have values between 0 and 1 inclusive"),
+        (xr.DataArray(0.5), xr.DataArray(-0.01), "`p3` must have values between 0 and 1 inclusive"),
+        (xr.DataArray(0.5), xr.DataArray(1.01), "`p3` must have values between 0 and 1 inclusive"),
+    ],
+)
+def test_seeps_raises(p1, p3, exp):
+    """Tests that seeps raises the correct errors"""
+    with pytest.raises(ValueError, match=exp):
+        seeps(
+            mtd.DA_FCST_SEEPS,
+            mtd.DA_OBS_SEEPS,
+            p1,
+            p3,
+            light_heavy_threshold=mtd.DA_LIGHT_HEAVY_THRESHOLD_SEEPS,
+        )
+
+
+def test_seeps_dask():
+    """Tests seeps works with dask"""
+
+    if dask == "Unavailable":  # pragma: no cover
+        pytest.skip("Dask unavailable, could not run dask tests")  # pragma: no cover
+
+    calculated = seeps(
+        mtd.DA_FCST_SEEPS.chunk(),
+        mtd.DA_OBS_SEEPS.chunk(),
+        mtd.DA_P1_SEEPS.chunk(),
+        mtd.DA_P3_SEEPS.chunk(),
+        light_heavy_threshold=mtd.DA_LIGHT_HEAVY_THRESHOLD_SEEPS.chunk(),
+        dry_light_threshold=0.2,
+        mask_clim_extremes=True,
+        min_masked_value=0.1,
+        max_masked_value=0.85,
+        reduce_dims=None,
+        preserve_dims="all",
+    )
+
+    assert isinstance(calculated.data, dask.array.Array)
+    calculated = calculated.compute()
+    assert isinstance(calculated.data, np.ndarray)
+    xr.testing.assert_allclose(
+        calculated,
+        mtd.EXP_SEEPS_CASE0,
+    )
diff --git a/tutorials/SEEPS.ipynb b/tutorials/SEEPS.ipynb
new file mode 100644
index 000000000..b341a2c4b
--- /dev/null
+++ b/tutorials/SEEPS.ipynb
@@ -0,0 +1,1029 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Stable Equitable Error in Probability Space (SEEPS)\n",
+    "\n",
+    "SEEPS is a verification score that is typically used to evaluate precipitation forecasts. SEEPS is an equitable score which means that random forecasts and constant valued forecasts all receive the same expected score.\n",
+    "\n",
+    "The SEEPS score calculates the performance of forecasts across three categories:\n",
+    "- Dry weather (usually this is defined as less than or equal to 0.2mm),\n",
+    "- Light precipitation (the climatological lower two-thirds of rainfall above the dry threshold),\n",
+    "- Heavy precipitation (the climatological upper one-third of rainfall above the dry threshold).\n",
+    "\n",
+    "The SEEPS penalty matrix that is applied to the categorical forecasts and observations is defined as\n",
+    "\n",
+    "$$\n",
+    "s = \\frac{1}{2} \\left(\n",
+    "\\begin{matrix}\n",
+    "    0 & \\frac{1}{1-p_1} & \\frac{1}{p_3}+\\frac{1}{1-p_1} \\\\\n",
+    "\\frac{1}{p_1} & 0 & \\frac{1}{p_3} \\\\\n",
+    "\\frac{1}{p_1}+\\frac{1}{1-p_3} & \\frac{1}{1-p_3} & 0\n",
+    "\\end{matrix}\n",
+    "\\right)\n",
+    "$$\n",
+    "\n",
+    "where \n",
+    "\n",
+    "- $p_1$ is the climatological probability of the dry weather category\n",
+    "- $p_3$ is the climatological probability of the heavy precipitation category.\n",
+    "- The rows correspond to the forecast category (dry, light, heavy).\n",
+    "- The columns correspond to the observation category (dry, light, heavy).\n",
+    "\n",
+    "Although $p_2$, does not appear in the penalty matrix, it is defined as\n",
+    "$p_2 = 2p_3$ with $p_1 + p_2 + p_3 = 1$ which means that the light \n",
+    "precipitation category is twice as likely to occur climatologically as the \n",
+    "heavy precipitation category.\n",
+    "\n",
+    "## Implementation notes on the SEEPS score in *scores*\n",
+    "\n",
+    "- The thresholds that determine the categories as well as the $p_1$ and $p_3$ values typically vary in time and space. The implementation in *scores* allows the user to pass in `xr.DataArray` objects that can vary across whatever dimensions are deemed necessary. \n",
+    "- This implementation of the score is negatively oriented, meaning that lower scores are better. \n",
+    "Sometimes in the literature, a SEEPS skill score is used, which is defined as 1 - SEEPS.\n",
+    "- By default, the scores are only calculated for points where $p_1 \\in [0.1, 0.85]$ \n",
+    "as per [Rodwell et al. (2010)](https://doi.org/10.1002/qj.656). This can be modified if needed.\n",
+    "- The threshold that splits the light rain from the dry rain threshold defaults to 0.2. We show how this is done in the example below\n",
+    "\n",
+    "## Calculating the SEEPS score in *scores*."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scores.categorical import seeps\n",
+    "from scores.functions import create_latitude_weights\n",
+    "import xarray as xr\n",
+    "import pandas as pd\n",
+    "\n",
+    "# You can view the documentation for the function by running the following\n",
+    "# help(seeps)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's show how to calculate the SEEPS score with weatherbench2 data. The data has been regridded to a common 1.5° grid.\n",
+    "\n",
+    "We will first get some forecast and observation data for January 2020. We will get GraphCast forecasts, ECMWF IFS (deterministic) forecasts and ERA5 observations. We will just use the lead day 2 data in this example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# It may take around 30 seconds to connect to the cloud storage for the first time.\n",
+    "DATES = pd.date_range(\"2019-12-30\", \"2020-01-31\")\n",
+    "LEAD_TIME = pd.Timedelta(\"2d\")\n",
+    "\n",
+    "era5 = xr.open_zarr(\n",
+    "    \"gs://weatherbench2/datasets/era5/1959-2023_01_10-6h-240x121_equiangular_with_poles_conservative.zarr\"\n",
+    ")\n",
+    "graphcast = xr.open_zarr(\n",
+    "    \"gs://weatherbench2/datasets/graphcast/2020/date_range_2019-11-16_2021-02-01_12_hours-240x121_equiangular_with_poles_conservative.zarr\"\n",
+    ")\n",
+    "ifs = xr.open_zarr(\"gs://weatherbench2/datasets/hres/2016-2022-0012-240x121_equiangular_with_poles_conservative.zarr\")\n",
+    "\n",
+    "graphcast_precip = (\n",
+    "    graphcast.total_precipitation_24hr.sel(time=DATES, prediction_timedelta=LEAD_TIME).compute() * 1000\n",
+    ")  # convert to mm\n",
+    "ifs_precip = (\n",
+    "    ifs.total_precipitation_24hr.sel(time=DATES, prediction_timedelta=LEAD_TIME).compute() * 1000\n",
+    ")  # convert to mms\n",
+    "era5_precip = era5.total_precipitation_24hr.sel(time=DATES).compute() * 1000  # convert to mm\n",
+    "\n",
+    "# Update the time coords in the forecast to match up to the observations\n",
+    "graphcast_precip = graphcast_precip.assign_coords({\"time\": graphcast_precip.time + LEAD_TIME})\n",
+    "ifs_precip = ifs_precip.assign_coords({\"time\": ifs_precip.time + LEAD_TIME})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.QuadMesh at 0x7f12361cb490>"
+      ]
+     },
+     "execution_count": 83,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Let's take a look at the obervations at the first time step\n",
+    "era5_precip.sel(time=\"2020-01-01T00:00:00.000000000\").T.plot(vmin=0, vmax=30)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's get some data needed for the thresholds in SEEPS. \n",
+    "We need $p_1$, $p_3$, and the light_heavy_threshold data. This data varies in space and time\n",
+    "\n",
+    "The WeatherBench2 data uses 0.25mm rather than 0.2mm to differentiate between light rain and dry conditions. To account for this, we will have to set `dry_light_threshold=0.25` in the `seeps` function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "clim = xr.open_zarr(\n",
+    "    \"gs://weatherbench2/datasets/era5-hourly-climatology/1990-2017_6h_240x121_equiangular_with_poles_conservative.zarr\"\n",
+    ")\n",
+    "\n",
+    "seeps_threshold = clim.total_precipitation_24hr_seeps_threshold.sel(hour=0, dayofyear=slice(1, 31)).compute()\n",
+    "p1 = clim.total_precipitation_24hr_seeps_dry_fraction.sel(hour=0, dayofyear=slice(1, 31)).compute()\n",
+    "\n",
+    "# We just got data for the first 31 days of the year. We need to convert the dim  \"dayofyear\" into a \"time\" dim\n",
+    "seeps_threshold = seeps_threshold.rename({\"dayofyear\": \"time\"})\n",
+    "seeps_threshold = seeps_threshold.assign_coords({\"time\": pd.date_range(\"2020-01-01\", \"2020-01-31\")})\n",
+    "\n",
+    "p1 = p1.rename({\"dayofyear\": \"time\"})\n",
+    "p1 = p1.assign_coords({\"time\": pd.date_range(\"2020-01-01\", \"2020-01-31\")})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since SEEPS was set up so that $p_2 = 2p_3$ and $p_1 + p_2 + p_3 = 1$, we can substitute the first equation into the second to determine that $p_3 = \\frac{1-p_1}{3}$. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p3 = (1 - p1) / 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now our data has been wrangled into the right format to pass into the *scores* SEEPS function.\n",
+    "\n",
+    "Note that although SEEPS uses a categories to determine penalties, we pass in continuous forecast and observation values. The `seeps` function then handles the categorical nature of the score."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 108,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n",
+       "<defs>\n",
+       "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n",
+       "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n",
+       "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n",
+       "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n",
+       "</symbol>\n",
+       "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n",
+       "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n",
+       "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
+       "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
+       "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
+       "</symbol>\n",
+       "</defs>\n",
+       "</svg>\n",
+       "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n",
+       " *\n",
+       " */\n",
+       "\n",
+       ":root {\n",
+       "  --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n",
+       "  --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n",
+       "  --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n",
+       "  --xr-border-color: var(--jp-border-color2, #e0e0e0);\n",
+       "  --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n",
+       "  --xr-background-color: var(--jp-layout-color0, white);\n",
+       "  --xr-background-color-row-even: var(--jp-layout-color1, white);\n",
+       "  --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n",
+       "}\n",
+       "\n",
+       "html[theme=dark],\n",
+       "body[data-theme=dark],\n",
+       "body.vscode-dark {\n",
+       "  --xr-font-color0: rgba(255, 255, 255, 1);\n",
+       "  --xr-font-color2: rgba(255, 255, 255, 0.54);\n",
+       "  --xr-font-color3: rgba(255, 255, 255, 0.38);\n",
+       "  --xr-border-color: #1F1F1F;\n",
+       "  --xr-disabled-color: #515151;\n",
+       "  --xr-background-color: #111111;\n",
+       "  --xr-background-color-row-even: #111111;\n",
+       "  --xr-background-color-row-odd: #313131;\n",
+       "}\n",
+       "\n",
+       ".xr-wrap {\n",
+       "  display: block !important;\n",
+       "  min-width: 300px;\n",
+       "  max-width: 700px;\n",
+       "}\n",
+       "\n",
+       ".xr-text-repr-fallback {\n",
+       "  /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       ".xr-header {\n",
+       "  padding-top: 6px;\n",
+       "  padding-bottom: 6px;\n",
+       "  margin-bottom: 4px;\n",
+       "  border-bottom: solid 1px var(--xr-border-color);\n",
+       "}\n",
+       "\n",
+       ".xr-header > div,\n",
+       ".xr-header > ul {\n",
+       "  display: inline;\n",
+       "  margin-top: 0;\n",
+       "  margin-bottom: 0;\n",
+       "}\n",
+       "\n",
+       ".xr-obj-type,\n",
+       ".xr-array-name {\n",
+       "  margin-left: 2px;\n",
+       "  margin-right: 10px;\n",
+       "}\n",
+       "\n",
+       ".xr-obj-type {\n",
+       "  color: var(--xr-font-color2);\n",
+       "}\n",
+       "\n",
+       ".xr-sections {\n",
+       "  padding-left: 0 !important;\n",
+       "  display: grid;\n",
+       "  grid-template-columns: 150px auto auto 1fr 20px 20px;\n",
+       "}\n",
+       "\n",
+       ".xr-section-item {\n",
+       "  display: contents;\n",
+       "}\n",
+       "\n",
+       ".xr-section-item input {\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       ".xr-section-item input + label {\n",
+       "  color: var(--xr-disabled-color);\n",
+       "}\n",
+       "\n",
+       ".xr-section-item input:enabled + label {\n",
+       "  cursor: pointer;\n",
+       "  color: var(--xr-font-color2);\n",
+       "}\n",
+       "\n",
+       ".xr-section-item input:enabled + label:hover {\n",
+       "  color: var(--xr-font-color0);\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary {\n",
+       "  grid-column: 1;\n",
+       "  color: var(--xr-font-color2);\n",
+       "  font-weight: 500;\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary > span {\n",
+       "  display: inline-block;\n",
+       "  padding-left: 0.5em;\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in:disabled + label {\n",
+       "  color: var(--xr-font-color2);\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in + label:before {\n",
+       "  display: inline-block;\n",
+       "  content: '►';\n",
+       "  font-size: 11px;\n",
+       "  width: 15px;\n",
+       "  text-align: center;\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in:disabled + label:before {\n",
+       "  color: var(--xr-disabled-color);\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in:checked + label:before {\n",
+       "  content: '▼';\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in:checked + label > span {\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary,\n",
+       ".xr-section-inline-details {\n",
+       "  padding-top: 4px;\n",
+       "  padding-bottom: 4px;\n",
+       "}\n",
+       "\n",
+       ".xr-section-inline-details {\n",
+       "  grid-column: 2 / -1;\n",
+       "}\n",
+       "\n",
+       ".xr-section-details {\n",
+       "  display: none;\n",
+       "  grid-column: 1 / -1;\n",
+       "  margin-bottom: 5px;\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in:checked ~ .xr-section-details {\n",
+       "  display: contents;\n",
+       "}\n",
+       "\n",
+       ".xr-array-wrap {\n",
+       "  grid-column: 1 / -1;\n",
+       "  display: grid;\n",
+       "  grid-template-columns: 20px auto;\n",
+       "}\n",
+       "\n",
+       ".xr-array-wrap > label {\n",
+       "  grid-column: 1;\n",
+       "  vertical-align: top;\n",
+       "}\n",
+       "\n",
+       ".xr-preview {\n",
+       "  color: var(--xr-font-color3);\n",
+       "}\n",
+       "\n",
+       ".xr-array-preview,\n",
+       ".xr-array-data {\n",
+       "  padding: 0 5px !important;\n",
+       "  grid-column: 2;\n",
+       "}\n",
+       "\n",
+       ".xr-array-data,\n",
+       ".xr-array-in:checked ~ .xr-array-preview {\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       ".xr-array-in:checked ~ .xr-array-data,\n",
+       ".xr-array-preview {\n",
+       "  display: inline-block;\n",
+       "}\n",
+       "\n",
+       ".xr-dim-list {\n",
+       "  display: inline-block !important;\n",
+       "  list-style: none;\n",
+       "  padding: 0 !important;\n",
+       "  margin: 0;\n",
+       "}\n",
+       "\n",
+       ".xr-dim-list li {\n",
+       "  display: inline-block;\n",
+       "  padding: 0;\n",
+       "  margin: 0;\n",
+       "}\n",
+       "\n",
+       ".xr-dim-list:before {\n",
+       "  content: '(';\n",
+       "}\n",
+       "\n",
+       ".xr-dim-list:after {\n",
+       "  content: ')';\n",
+       "}\n",
+       "\n",
+       ".xr-dim-list li:not(:last-child):after {\n",
+       "  content: ',';\n",
+       "  padding-right: 5px;\n",
+       "}\n",
+       "\n",
+       ".xr-has-index {\n",
+       "  font-weight: bold;\n",
+       "}\n",
+       "\n",
+       ".xr-var-list,\n",
+       ".xr-var-item {\n",
+       "  display: contents;\n",
+       "}\n",
+       "\n",
+       ".xr-var-item > div,\n",
+       ".xr-var-item label,\n",
+       ".xr-var-item > .xr-var-name span {\n",
+       "  background-color: var(--xr-background-color-row-even);\n",
+       "  margin-bottom: 0;\n",
+       "}\n",
+       "\n",
+       ".xr-var-item > .xr-var-name:hover span {\n",
+       "  padding-right: 5px;\n",
+       "}\n",
+       "\n",
+       ".xr-var-list > li:nth-child(odd) > div,\n",
+       ".xr-var-list > li:nth-child(odd) > label,\n",
+       ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n",
+       "  background-color: var(--xr-background-color-row-odd);\n",
+       "}\n",
+       "\n",
+       ".xr-var-name {\n",
+       "  grid-column: 1;\n",
+       "}\n",
+       "\n",
+       ".xr-var-dims {\n",
+       "  grid-column: 2;\n",
+       "}\n",
+       "\n",
+       ".xr-var-dtype {\n",
+       "  grid-column: 3;\n",
+       "  text-align: right;\n",
+       "  color: var(--xr-font-color2);\n",
+       "}\n",
+       "\n",
+       ".xr-var-preview {\n",
+       "  grid-column: 4;\n",
+       "}\n",
+       "\n",
+       ".xr-index-preview {\n",
+       "  grid-column: 2 / 5;\n",
+       "  color: var(--xr-font-color2);\n",
+       "}\n",
+       "\n",
+       ".xr-var-name,\n",
+       ".xr-var-dims,\n",
+       ".xr-var-dtype,\n",
+       ".xr-preview,\n",
+       ".xr-attrs dt {\n",
+       "  white-space: nowrap;\n",
+       "  overflow: hidden;\n",
+       "  text-overflow: ellipsis;\n",
+       "  padding-right: 10px;\n",
+       "}\n",
+       "\n",
+       ".xr-var-name:hover,\n",
+       ".xr-var-dims:hover,\n",
+       ".xr-var-dtype:hover,\n",
+       ".xr-attrs dt:hover {\n",
+       "  overflow: visible;\n",
+       "  width: auto;\n",
+       "  z-index: 1;\n",
+       "}\n",
+       "\n",
+       ".xr-var-attrs,\n",
+       ".xr-var-data,\n",
+       ".xr-index-data {\n",
+       "  display: none;\n",
+       "  background-color: var(--xr-background-color) !important;\n",
+       "  padding-bottom: 5px !important;\n",
+       "}\n",
+       "\n",
+       ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n",
+       ".xr-var-data-in:checked ~ .xr-var-data,\n",
+       ".xr-index-data-in:checked ~ .xr-index-data {\n",
+       "  display: block;\n",
+       "}\n",
+       "\n",
+       ".xr-var-data > table {\n",
+       "  float: right;\n",
+       "}\n",
+       "\n",
+       ".xr-var-name span,\n",
+       ".xr-var-data,\n",
+       ".xr-index-name div,\n",
+       ".xr-index-data,\n",
+       ".xr-attrs {\n",
+       "  padding-left: 25px !important;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs,\n",
+       ".xr-var-attrs,\n",
+       ".xr-var-data,\n",
+       ".xr-index-data {\n",
+       "  grid-column: 1 / -1;\n",
+       "}\n",
+       "\n",
+       "dl.xr-attrs {\n",
+       "  padding: 0;\n",
+       "  margin: 0;\n",
+       "  display: grid;\n",
+       "  grid-template-columns: 125px auto;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs dt,\n",
+       ".xr-attrs dd {\n",
+       "  padding: 0;\n",
+       "  margin: 0;\n",
+       "  float: left;\n",
+       "  padding-right: 10px;\n",
+       "  width: auto;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs dt {\n",
+       "  font-weight: normal;\n",
+       "  grid-column: 1;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs dt:hover span {\n",
+       "  display: inline-block;\n",
+       "  background: var(--xr-background-color);\n",
+       "  padding-right: 10px;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs dd {\n",
+       "  grid-column: 2;\n",
+       "  white-space: pre-wrap;\n",
+       "  word-break: break-all;\n",
+       "}\n",
+       "\n",
+       ".xr-icon-database,\n",
+       ".xr-icon-file-text2,\n",
+       ".xr-no-icon {\n",
+       "  display: inline-block;\n",
+       "  vertical-align: middle;\n",
+       "  width: 1em;\n",
+       "  height: 1.5em !important;\n",
+       "  stroke-width: 0;\n",
+       "  stroke: currentColor;\n",
+       "  fill: currentColor;\n",
+       "}\n",
+       "</style><pre class='xr-text-repr-fallback'>&lt;xarray.DataArray ()&gt;\n",
+       "array(0.4504091)\n",
+       "Coordinates:\n",
+       "    prediction_timedelta  timedelta64[ns] 2 days\n",
+       "    hour                  int64 0</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.DataArray</div><div class='xr-array-name'></div></div><ul class='xr-sections'><li class='xr-section-item'><div class='xr-array-wrap'><input id='section-1c96c93d-47fb-48fe-85ed-d525ce50f47a' class='xr-array-in' type='checkbox' checked><label for='section-1c96c93d-47fb-48fe-85ed-d525ce50f47a' title='Show/hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-array-preview xr-preview'><span>0.4504</span></div><div class='xr-array-data'><pre>array(0.4504091)</pre></div></div></li><li class='xr-section-item'><input id='section-e9ef0a39-931b-438c-948a-4621997eafcc' class='xr-section-summary-in' type='checkbox'  checked><label for='section-e9ef0a39-931b-438c-948a-4621997eafcc' class='xr-section-summary' >Coordinates: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span>prediction_timedelta</span></div><div class='xr-var-dims'>()</div><div class='xr-var-dtype'>timedelta64[ns]</div><div class='xr-var-preview xr-preview'>2 days</div><input id='attrs-a411f3db-53a4-4766-8e12-e1e156197319' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-a411f3db-53a4-4766-8e12-e1e156197319' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-1bdcb16a-9a0a-4422-8290-4a9de7a55507' class='xr-var-data-in' type='checkbox'><label for='data-1bdcb16a-9a0a-4422-8290-4a9de7a55507' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array(172800000000000, dtype=&#x27;timedelta64[ns]&#x27;)</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>hour</span></div><div class='xr-var-dims'>()</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>0</div><input id='attrs-f0d7ace0-8d54-4ab9-8deb-69f3a31b01f0' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-f0d7ace0-8d54-4ab9-8deb-69f3a31b01f0' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-96072afc-4613-493c-b34b-62b4f57f3036' class='xr-var-data-in' type='checkbox'><label for='data-96072afc-4613-493c-b34b-62b4f57f3036' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array(0)</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-afda5dee-ba73-4a3e-8f34-8967892b4408' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-afda5dee-ba73-4a3e-8f34-8967892b4408' class='xr-section-summary'  title='Expand/collapse section'>Indexes: <span>(0)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'></ul></div></li><li class='xr-section-item'><input id='section-d1f1b1a9-32e1-4220-b3e6-15fdcd4f3e67' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-d1f1b1a9-32e1-4220-b3e6-15fdcd4f3e67' class='xr-section-summary'  title='Expand/collapse section'>Attributes: <span>(0)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'></dl></div></li></ul></div></div>"
+      ],
+      "text/plain": [
+       "<xarray.DataArray ()>\n",
+       "array(0.4504091)\n",
+       "Coordinates:\n",
+       "    prediction_timedelta  timedelta64[ns] 2 days\n",
+       "    hour                  int64 0"
+      ]
+     },
+     "execution_count": 108,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Need to create weights to be able to weight by latitude\n",
+    "lat_weights = create_latitude_weights(graphcast_precip.latitude)\n",
+    "\n",
+    "# Calculate SEEPS score for GraphCast\n",
+    "seeps(graphcast_precip, era5_precip, p1, p3, seeps_threshold, weights=lat_weights, dry_light_threshold=0.25)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 109,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n",
+       "<defs>\n",
+       "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n",
+       "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n",
+       "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n",
+       "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n",
+       "</symbol>\n",
+       "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n",
+       "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n",
+       "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
+       "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
+       "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
+       "</symbol>\n",
+       "</defs>\n",
+       "</svg>\n",
+       "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n",
+       " *\n",
+       " */\n",
+       "\n",
+       ":root {\n",
+       "  --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n",
+       "  --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n",
+       "  --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n",
+       "  --xr-border-color: var(--jp-border-color2, #e0e0e0);\n",
+       "  --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n",
+       "  --xr-background-color: var(--jp-layout-color0, white);\n",
+       "  --xr-background-color-row-even: var(--jp-layout-color1, white);\n",
+       "  --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n",
+       "}\n",
+       "\n",
+       "html[theme=dark],\n",
+       "body[data-theme=dark],\n",
+       "body.vscode-dark {\n",
+       "  --xr-font-color0: rgba(255, 255, 255, 1);\n",
+       "  --xr-font-color2: rgba(255, 255, 255, 0.54);\n",
+       "  --xr-font-color3: rgba(255, 255, 255, 0.38);\n",
+       "  --xr-border-color: #1F1F1F;\n",
+       "  --xr-disabled-color: #515151;\n",
+       "  --xr-background-color: #111111;\n",
+       "  --xr-background-color-row-even: #111111;\n",
+       "  --xr-background-color-row-odd: #313131;\n",
+       "}\n",
+       "\n",
+       ".xr-wrap {\n",
+       "  display: block !important;\n",
+       "  min-width: 300px;\n",
+       "  max-width: 700px;\n",
+       "}\n",
+       "\n",
+       ".xr-text-repr-fallback {\n",
+       "  /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       ".xr-header {\n",
+       "  padding-top: 6px;\n",
+       "  padding-bottom: 6px;\n",
+       "  margin-bottom: 4px;\n",
+       "  border-bottom: solid 1px var(--xr-border-color);\n",
+       "}\n",
+       "\n",
+       ".xr-header > div,\n",
+       ".xr-header > ul {\n",
+       "  display: inline;\n",
+       "  margin-top: 0;\n",
+       "  margin-bottom: 0;\n",
+       "}\n",
+       "\n",
+       ".xr-obj-type,\n",
+       ".xr-array-name {\n",
+       "  margin-left: 2px;\n",
+       "  margin-right: 10px;\n",
+       "}\n",
+       "\n",
+       ".xr-obj-type {\n",
+       "  color: var(--xr-font-color2);\n",
+       "}\n",
+       "\n",
+       ".xr-sections {\n",
+       "  padding-left: 0 !important;\n",
+       "  display: grid;\n",
+       "  grid-template-columns: 150px auto auto 1fr 20px 20px;\n",
+       "}\n",
+       "\n",
+       ".xr-section-item {\n",
+       "  display: contents;\n",
+       "}\n",
+       "\n",
+       ".xr-section-item input {\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       ".xr-section-item input + label {\n",
+       "  color: var(--xr-disabled-color);\n",
+       "}\n",
+       "\n",
+       ".xr-section-item input:enabled + label {\n",
+       "  cursor: pointer;\n",
+       "  color: var(--xr-font-color2);\n",
+       "}\n",
+       "\n",
+       ".xr-section-item input:enabled + label:hover {\n",
+       "  color: var(--xr-font-color0);\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary {\n",
+       "  grid-column: 1;\n",
+       "  color: var(--xr-font-color2);\n",
+       "  font-weight: 500;\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary > span {\n",
+       "  display: inline-block;\n",
+       "  padding-left: 0.5em;\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in:disabled + label {\n",
+       "  color: var(--xr-font-color2);\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in + label:before {\n",
+       "  display: inline-block;\n",
+       "  content: '►';\n",
+       "  font-size: 11px;\n",
+       "  width: 15px;\n",
+       "  text-align: center;\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in:disabled + label:before {\n",
+       "  color: var(--xr-disabled-color);\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in:checked + label:before {\n",
+       "  content: '▼';\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in:checked + label > span {\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary,\n",
+       ".xr-section-inline-details {\n",
+       "  padding-top: 4px;\n",
+       "  padding-bottom: 4px;\n",
+       "}\n",
+       "\n",
+       ".xr-section-inline-details {\n",
+       "  grid-column: 2 / -1;\n",
+       "}\n",
+       "\n",
+       ".xr-section-details {\n",
+       "  display: none;\n",
+       "  grid-column: 1 / -1;\n",
+       "  margin-bottom: 5px;\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in:checked ~ .xr-section-details {\n",
+       "  display: contents;\n",
+       "}\n",
+       "\n",
+       ".xr-array-wrap {\n",
+       "  grid-column: 1 / -1;\n",
+       "  display: grid;\n",
+       "  grid-template-columns: 20px auto;\n",
+       "}\n",
+       "\n",
+       ".xr-array-wrap > label {\n",
+       "  grid-column: 1;\n",
+       "  vertical-align: top;\n",
+       "}\n",
+       "\n",
+       ".xr-preview {\n",
+       "  color: var(--xr-font-color3);\n",
+       "}\n",
+       "\n",
+       ".xr-array-preview,\n",
+       ".xr-array-data {\n",
+       "  padding: 0 5px !important;\n",
+       "  grid-column: 2;\n",
+       "}\n",
+       "\n",
+       ".xr-array-data,\n",
+       ".xr-array-in:checked ~ .xr-array-preview {\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       ".xr-array-in:checked ~ .xr-array-data,\n",
+       ".xr-array-preview {\n",
+       "  display: inline-block;\n",
+       "}\n",
+       "\n",
+       ".xr-dim-list {\n",
+       "  display: inline-block !important;\n",
+       "  list-style: none;\n",
+       "  padding: 0 !important;\n",
+       "  margin: 0;\n",
+       "}\n",
+       "\n",
+       ".xr-dim-list li {\n",
+       "  display: inline-block;\n",
+       "  padding: 0;\n",
+       "  margin: 0;\n",
+       "}\n",
+       "\n",
+       ".xr-dim-list:before {\n",
+       "  content: '(';\n",
+       "}\n",
+       "\n",
+       ".xr-dim-list:after {\n",
+       "  content: ')';\n",
+       "}\n",
+       "\n",
+       ".xr-dim-list li:not(:last-child):after {\n",
+       "  content: ',';\n",
+       "  padding-right: 5px;\n",
+       "}\n",
+       "\n",
+       ".xr-has-index {\n",
+       "  font-weight: bold;\n",
+       "}\n",
+       "\n",
+       ".xr-var-list,\n",
+       ".xr-var-item {\n",
+       "  display: contents;\n",
+       "}\n",
+       "\n",
+       ".xr-var-item > div,\n",
+       ".xr-var-item label,\n",
+       ".xr-var-item > .xr-var-name span {\n",
+       "  background-color: var(--xr-background-color-row-even);\n",
+       "  margin-bottom: 0;\n",
+       "}\n",
+       "\n",
+       ".xr-var-item > .xr-var-name:hover span {\n",
+       "  padding-right: 5px;\n",
+       "}\n",
+       "\n",
+       ".xr-var-list > li:nth-child(odd) > div,\n",
+       ".xr-var-list > li:nth-child(odd) > label,\n",
+       ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n",
+       "  background-color: var(--xr-background-color-row-odd);\n",
+       "}\n",
+       "\n",
+       ".xr-var-name {\n",
+       "  grid-column: 1;\n",
+       "}\n",
+       "\n",
+       ".xr-var-dims {\n",
+       "  grid-column: 2;\n",
+       "}\n",
+       "\n",
+       ".xr-var-dtype {\n",
+       "  grid-column: 3;\n",
+       "  text-align: right;\n",
+       "  color: var(--xr-font-color2);\n",
+       "}\n",
+       "\n",
+       ".xr-var-preview {\n",
+       "  grid-column: 4;\n",
+       "}\n",
+       "\n",
+       ".xr-index-preview {\n",
+       "  grid-column: 2 / 5;\n",
+       "  color: var(--xr-font-color2);\n",
+       "}\n",
+       "\n",
+       ".xr-var-name,\n",
+       ".xr-var-dims,\n",
+       ".xr-var-dtype,\n",
+       ".xr-preview,\n",
+       ".xr-attrs dt {\n",
+       "  white-space: nowrap;\n",
+       "  overflow: hidden;\n",
+       "  text-overflow: ellipsis;\n",
+       "  padding-right: 10px;\n",
+       "}\n",
+       "\n",
+       ".xr-var-name:hover,\n",
+       ".xr-var-dims:hover,\n",
+       ".xr-var-dtype:hover,\n",
+       ".xr-attrs dt:hover {\n",
+       "  overflow: visible;\n",
+       "  width: auto;\n",
+       "  z-index: 1;\n",
+       "}\n",
+       "\n",
+       ".xr-var-attrs,\n",
+       ".xr-var-data,\n",
+       ".xr-index-data {\n",
+       "  display: none;\n",
+       "  background-color: var(--xr-background-color) !important;\n",
+       "  padding-bottom: 5px !important;\n",
+       "}\n",
+       "\n",
+       ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n",
+       ".xr-var-data-in:checked ~ .xr-var-data,\n",
+       ".xr-index-data-in:checked ~ .xr-index-data {\n",
+       "  display: block;\n",
+       "}\n",
+       "\n",
+       ".xr-var-data > table {\n",
+       "  float: right;\n",
+       "}\n",
+       "\n",
+       ".xr-var-name span,\n",
+       ".xr-var-data,\n",
+       ".xr-index-name div,\n",
+       ".xr-index-data,\n",
+       ".xr-attrs {\n",
+       "  padding-left: 25px !important;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs,\n",
+       ".xr-var-attrs,\n",
+       ".xr-var-data,\n",
+       ".xr-index-data {\n",
+       "  grid-column: 1 / -1;\n",
+       "}\n",
+       "\n",
+       "dl.xr-attrs {\n",
+       "  padding: 0;\n",
+       "  margin: 0;\n",
+       "  display: grid;\n",
+       "  grid-template-columns: 125px auto;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs dt,\n",
+       ".xr-attrs dd {\n",
+       "  padding: 0;\n",
+       "  margin: 0;\n",
+       "  float: left;\n",
+       "  padding-right: 10px;\n",
+       "  width: auto;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs dt {\n",
+       "  font-weight: normal;\n",
+       "  grid-column: 1;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs dt:hover span {\n",
+       "  display: inline-block;\n",
+       "  background: var(--xr-background-color);\n",
+       "  padding-right: 10px;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs dd {\n",
+       "  grid-column: 2;\n",
+       "  white-space: pre-wrap;\n",
+       "  word-break: break-all;\n",
+       "}\n",
+       "\n",
+       ".xr-icon-database,\n",
+       ".xr-icon-file-text2,\n",
+       ".xr-no-icon {\n",
+       "  display: inline-block;\n",
+       "  vertical-align: middle;\n",
+       "  width: 1em;\n",
+       "  height: 1.5em !important;\n",
+       "  stroke-width: 0;\n",
+       "  stroke: currentColor;\n",
+       "  fill: currentColor;\n",
+       "}\n",
+       "</style><pre class='xr-text-repr-fallback'>&lt;xarray.DataArray ()&gt;\n",
+       "array(0.54390164)\n",
+       "Coordinates:\n",
+       "    prediction_timedelta  timedelta64[ns] 2 days\n",
+       "    hour                  int64 0</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.DataArray</div><div class='xr-array-name'></div></div><ul class='xr-sections'><li class='xr-section-item'><div class='xr-array-wrap'><input id='section-071eee1c-1792-4163-8d54-1c5ba805f1f2' class='xr-array-in' type='checkbox' checked><label for='section-071eee1c-1792-4163-8d54-1c5ba805f1f2' title='Show/hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-array-preview xr-preview'><span>0.5439</span></div><div class='xr-array-data'><pre>array(0.54390164)</pre></div></div></li><li class='xr-section-item'><input id='section-3ab0a780-795c-462d-aaaa-7fd95efe5dec' class='xr-section-summary-in' type='checkbox'  checked><label for='section-3ab0a780-795c-462d-aaaa-7fd95efe5dec' class='xr-section-summary' >Coordinates: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span>prediction_timedelta</span></div><div class='xr-var-dims'>()</div><div class='xr-var-dtype'>timedelta64[ns]</div><div class='xr-var-preview xr-preview'>2 days</div><input id='attrs-a7e19158-20a9-4d23-8ead-562ec938b4ed' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-a7e19158-20a9-4d23-8ead-562ec938b4ed' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-4b8dd6e6-4608-4dc0-8fb6-e55165104796' class='xr-var-data-in' type='checkbox'><label for='data-4b8dd6e6-4608-4dc0-8fb6-e55165104796' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>long_name :</span></dt><dd>time since forecast_reference_time</dd><dt><span>standard_name :</span></dt><dd>forecast_period</dd></dl></div><div class='xr-var-data'><pre>array(172800000000000, dtype=&#x27;timedelta64[ns]&#x27;)</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span>hour</span></div><div class='xr-var-dims'>()</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>0</div><input id='attrs-cc847b52-4877-45d4-8dcf-fbb3afa4e458' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-cc847b52-4877-45d4-8dcf-fbb3afa4e458' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-7670641d-1cf4-4df6-8da1-df842c005dcb' class='xr-var-data-in' type='checkbox'><label for='data-7670641d-1cf4-4df6-8da1-df842c005dcb' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array(0)</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-09322665-aec4-4d5b-98a2-807173a07c77' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-09322665-aec4-4d5b-98a2-807173a07c77' class='xr-section-summary'  title='Expand/collapse section'>Indexes: <span>(0)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'></ul></div></li><li class='xr-section-item'><input id='section-cbf456f0-da86-4a8c-ae45-784bbd7cff9b' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-cbf456f0-da86-4a8c-ae45-784bbd7cff9b' class='xr-section-summary'  title='Expand/collapse section'>Attributes: <span>(0)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'></dl></div></li></ul></div></div>"
+      ],
+      "text/plain": [
+       "<xarray.DataArray ()>\n",
+       "array(0.54390164)\n",
+       "Coordinates:\n",
+       "    prediction_timedelta  timedelta64[ns] 2 days\n",
+       "    hour                  int64 0"
+      ]
+     },
+     "execution_count": 109,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Calculate SEEPS for ECMWF IFS\n",
+    "seeps(ifs_precip, era5_precip, p1, p3, seeps_threshold, weights=lat_weights, dry_light_threshold=0.25)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this case, GraphCast received a lower, better score.\n",
+    "\n",
+    "## Things to try next\n",
+    "- Set `mask_clim_extremes` to `False` which turns off the masking of climatologically very dry or very wet regions (i.e, it doesn't mask data where p1 is less than 0.1, or greater than 0.85)\n",
+    "- You can vary the p1 thresholds that the masking occurs with the `min_masked_value` and `max_masked_value` args\n",
+    "\n",
+    "## Further reading\n",
+    "\n",
+    "[Rodwell, M. J., Richardson, D. S., Hewson, T. D., & Haiden, T. (2010). A new equitable score suitable for verifying precipitation in numerical weather prediction. Quarterly Journal of the Royal Meteorological Society, 136(650), 1344–1363.](https://doi.org/10.1002/qj.656)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tutorials/Tutorial_Gallery.ipynb b/tutorials/Tutorial_Gallery.ipynb
index eb03a2289..6ce46ca54 100644
--- a/tutorials/Tutorial_Gallery.ipynb
+++ b/tutorials/Tutorial_Gallery.ipynb
@@ -104,8 +104,9 @@
     ]
    },
    "source": [
+    "- [Binary (Categorical/Contingency/Confusion Matrix) Scores](./Binary_Contingency_Scores.ipynb)\n",
     "- [FIRM](./FIRM.ipynb)\n",
-    "- [Binary (Categorical/Contingency/Confusion Matrix) Scores](./Binary_Contingency_Scores.ipynb)"
+    "- [SEEPS](.SEEPS.ipynb)"
    ]
   },
   {