scriptengine-tasks-ecearth 0.8.0__tar.gz → 0.10.0__tar.gz

{scriptengine_tasks_ecearth-0.8.0 → scriptengine_tasks_ecearth-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptengine-tasks-ecearth
-Version: 0.8.0
+Version: 0.10.0
 Summary: ScriptEngine tasks for use with the EC-Earth climate model
 Author-email: Valentina Schueller <valentina.schueller@gmail.com>, Uwe Fladrich <uwe.fladrich@protonmail.com>
 Project-URL: Homepage, https://github.com/uwefladrich/scriptengine-tasks-ecearth
@@ -8,7 +8,7 @@ Project-URL: Bug Tracker, https://github.com/uwefladrich/scriptengine-tasks-ecea
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: scriptengine>=0.8.1
@@ -16,7 +16,7 @@ Requires-Dist: pyYAML>=5.1
 Requires-Dist: matplotlib>=3.1
 Requires-Dist: numpy>=1.18
 Requires-Dist: imageio>=2.18
-Requires-Dist: scitools-iris>=3.5
+Requires-Dist: scitools-iris>=3.12.2
 Requires-Dist: cartopy>=0.20
 Requires-Dist: python-redmine
 Requires-Dist: python-gitlab

{scriptengine_tasks_ecearth-0.8.0 → scriptengine_tasks_ecearth-0.10.0}/helpers/cubes.py

@@ -3,6 +3,7 @@
 import warnings
 
 import iris
+import iris.analysis.cartography
 import iris.cube
 import numpy as np
 from iris.util import equalise_attributes
@@ -97,7 +98,10 @@ def compute_time_weights(monthly_data_cube, cube_shape=None):
 
 def compute_annual_mean(cube):
     # Remove auxiliary time coordinate before collapsing cube
-    cube.remove_coord(cube.coord("time", dim_coords=False))
+    try:
+        cube.coord("time")
+    except iris.exceptions.CoordinateNotFoundError:
+        cube.remove_coord(cube.coord("time", dim_coords=False))
 
     annual_mean = cube.collapsed(
         "time",
@@ -157,3 +161,43 @@ def mask_other_hemisphere(cube, hemisphere):
     else:
         raise ValueError("Invalid hemisphere, must be 'north' or 'south'")
     return cube
+
+
+def compute_area_weights(cube):
+    if is_grid_regular(cube):
+        return compute_regular_grid_weights(cube)
+    return compute_reduced_grid_weights(cube)
+
+
+def is_grid_regular(cube) -> bool:
+    if not cube.coords("latitude", dim_coords=True):
+        return False
+    return True
+
+
+def compute_reduced_grid_weights(cube):
+    """compute area weights for the reduced gaussian grid"""
+    nh_latitudes = np.ma.masked_less(cube.coord("latitude").points, 0)
+    unique_lats, gridpoints_per_lat = np.unique(nh_latitudes, return_counts=True)
+    unique_lats, gridpoints_per_lat = unique_lats[0:-1], gridpoints_per_lat[0:-1]
+    areas = []
+    last_angle = 0
+    earth_radius = 6371
+    for latitude, amount in zip(unique_lats, gridpoints_per_lat):
+        delta = latitude - last_angle
+        current_angle = last_angle + 2 * delta
+        sin_diff = np.sin(np.deg2rad(current_angle)) - np.sin(np.deg2rad(last_angle))
+        ring_area = 2 * np.pi * earth_radius**2 * sin_diff
+        grid_area = ring_area / amount
+        areas.extend([grid_area] * amount)
+        last_angle = current_angle
+    areas = np.append(areas[::-1], areas)
+    area_weights = np.broadcast_to(areas, cube.data.shape)
+    return area_weights
+
+
+def compute_regular_grid_weights(cube):
+    """compute area weights for a regular lat/lon grid"""
+    cube.coord("latitude").guess_bounds()
+    cube.coord("longitude").guess_bounds()
+    return iris.analysis.cartography.area_weights(cube)

scriptengine_tasks_ecearth-0.10.0/monitoring/oifs_timeseries.py

@@ -0,0 +1,130 @@
+"""Processing Tasks for computing Timeseries from OpenIFS output."""
+
+import warnings
+from pathlib import Path
+
+import iris
+from iris.analysis import WeightedAggregator
+from iris.coords import CellMeasure
+from scriptengine.tasks.core import timed_runner
+
+import helpers.cubes
+
+from .timeseries import Timeseries
+
+
+class OifsTimeseries(Timeseries):
+    """OifsTimeseries Processing Task"""
+
+    _required_arguments = (
+        "src",
+        "varname",
+        "dst",
+    )
+
+    def __init__(self, arguments):
+        OifsTimeseries.check_arguments(arguments)
+        super().__init__(
+            {**arguments, "title": None, "coord_value": None, "data_value": None}
+        )
+
+    def _load_input(self, context):
+        src = self.getarg("src", context)
+        var_name = self.getarg("varname", context)
+        self.log_info(f"Create time series for atmosphere variable {var_name}.")
+        self.log_debug(f"Source file(s): {src}")
+
+        var_data = helpers.cubes.load_input_cube(src, var_name)
+        return var_data
+
+    def _adjust_metadata(self, cube):
+        """Adjustments to the cube metadata before saving."""
+        long_name = cube.long_name
+        var_name = cube.standard_name
+        comment = f"Annual mean of {long_name} / **{var_name}**."
+        cube.add_cell_method(
+            iris.coords.CellMethod("mean", coords="time", intervals="1 year")
+        )
+        cube = helpers.cubes.set_metadata(
+            cube,
+            title=f"{long_name} (annual mean)",
+            comment=comment,
+        )
+        return helpers.cubes.convert_units(cube)
+
+    def _compute_global_aggregate(self, cube, operation: WeightedAggregator):
+        """Area-weighted aggregate of cube (e.g., sum, mean)."""
+        area_weights = helpers.cubes.compute_area_weights(cube)
+        cell_size = CellMeasure(
+            area_weights, var_name="cell_size", units="m2", measure="area"
+        )
+        dims = tuple(range(len(area_weights.shape)))
+        cube.add_cell_measure(cell_size, dims)
+        # Remove duplicate boundary values before averaging
+        cube.coord("latitude").bounds = cube.coord("latitude").bounds[:, [0, 1]]
+        cube.coord("longitude").bounds = cube.coord("longitude").bounds[:, [0, 1]]
+        with warnings.catch_warnings():
+            # Suppress warning about insufficient metadata.
+            warnings.filterwarnings(
+                "ignore",
+                "Collapsing a non-contiguous coordinate.",
+                UserWarning,
+            )
+            global_aggregate = cube.collapsed(
+                ["latitude", "longitude"],
+                operation,
+                weights="cell_size",
+            )
+        return global_aggregate
+
+
+class OifsGlobalMeanYearMeanTimeseries(OifsTimeseries):
+    """OifsGlobalMeanYearMeanTimeseries Processing Task"""
+
+    _required_arguments = ("src", "dst", "varname")
+
+    def __init__(self, arguments=None):
+        OifsGlobalMeanYearMeanTimeseries.check_arguments(arguments)
+        super().__init__(
+            {**arguments, "title": None, "coord_value": None, "data_value": None}
+        )
+
+    @timed_runner
+    def run(self, context):
+        oifs_cube = self._load_input(context)
+
+        global_mean = self._compute_global_aggregate(oifs_cube, iris.analysis.MEAN)
+        annual_mean = helpers.cubes.compute_annual_mean(global_mean)
+        annual_mean.cell_methods = (iris.coords.CellMethod("mean", coords="area"),)
+
+        annual_mean = self._adjust_metadata(annual_mean)
+
+        dst = Path(self.getarg("dst", context))
+        self.check_file_extension(dst)
+        self.save(annual_mean, dst)
+
+
+class OifsGlobalSumYearMeanTimeseries(OifsTimeseries):
+    """OifsGlobalSumYearMeanTimeseries Processing Task"""
+
+    _required_arguments = ("src", "dst", "varname")
+
+    def __init__(self, arguments=None):
+        OifsGlobalSumYearMeanTimeseries.check_arguments(arguments)
+        super().__init__(
+            {**arguments, "title": None, "coord_value": None, "data_value": None}
+        )
+
+    @timed_runner
+    def run(self, context):
+        oifs_cube = self._load_input(context)
+
+        global_sum = self._compute_global_aggregate(oifs_cube, iris.analysis.SUM)
+        annual_mean = helpers.cubes.compute_annual_mean(global_sum)
+        annual_mean.cell_methods = (iris.coords.CellMethod("sum", coords="area"),)
+
+        annual_mean = self._adjust_metadata(annual_mean)
+
+        dst = Path(self.getarg("dst", context))
+        self.check_file_extension(dst)
+        self.save(annual_mean, dst)

{scriptengine_tasks_ecearth-0.8.0 → scriptengine_tasks_ecearth-0.10.0}/pyproject.toml

@@ -7,7 +7,7 @@
 
 [project]
     name = "scriptengine-tasks-ecearth"
-    version = "0.8.0"
+    version = "0.10.0"
     authors = [
         { name = "Valentina Schueller", email = "valentina.schueller@gmail.com" },
         { name = "Uwe Fladrich", email = "uwe.fladrich@protonmail.com" },
@@ -19,14 +19,14 @@
         "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
         "Operating System :: OS Independent",
     ]
-    requires-python = ">=3.8"
+    requires-python = ">=3.11"
     dependencies = [
         "scriptengine>=0.8.1",
         "pyYAML>=5.1",
         "matplotlib>=3.1",
         "numpy>=1.18",
         "imageio>=2.18",
-        "scitools-iris>=3.5",
+        "scitools-iris>=3.12.2",  # https://github.com/SciTools/iris/issues/6417
         "cartopy>=0.20",
         "python-redmine",
         "python-gitlab",
@@ -52,7 +52,8 @@
         "ece.mon.si3_hemis_point_month_mean_temporalmap" = "monitoring.si3_hemis_point_month_mean_temporalmap:Si3HemisPointMonthMeanTemporalmap"
         "ece.mon.oifs_all_mean_map" = "monitoring.oifs_all_mean_map:OifsAllMeanMap"
         "ece.mon.oifs_year_mean_temporalmap" = "monitoring.oifs_year_mean_temporalmap:OifsYearMeanTemporalmap"
-        "ece.mon.oifs_global_mean_year_mean_timeseries" = "monitoring.oifs_global_mean_year_mean_timeseries:OifsGlobalMeanYearMeanTimeseries"
+        "ece.mon.oifs_global_mean_year_mean_timeseries" = "monitoring.oifs_timeseries:OifsGlobalMeanYearMeanTimeseries"
+        "ece.mon.oifs_global_sum_year_mean_timeseries" = "monitoring.oifs_timeseries:OifsGlobalSumYearMeanTimeseries"
         "ece.mon.presentation.markdown" = "monitoring.markdown:Markdown"
         "ece.mon.presentation.redmine" = "monitoring.redmine:Redmine"
         "ece.mon.presentation.gitlab" = "monitoring.gitlab:Gitlab"

{scriptengine_tasks_ecearth-0.8.0 → scriptengine_tasks_ecearth-0.10.0}/scriptengine_tasks_ecearth.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptengine-tasks-ecearth
-Version: 0.8.0
+Version: 0.10.0
 Summary: ScriptEngine tasks for use with the EC-Earth climate model
 Author-email: Valentina Schueller <valentina.schueller@gmail.com>, Uwe Fladrich <uwe.fladrich@protonmail.com>
 Project-URL: Homepage, https://github.com/uwefladrich/scriptengine-tasks-ecearth
@@ -8,7 +8,7 @@ Project-URL: Bug Tracker, https://github.com/uwefladrich/scriptengine-tasks-ecea
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: scriptengine>=0.8.1
@@ -16,7 +16,7 @@ Requires-Dist: pyYAML>=5.1
 Requires-Dist: matplotlib>=3.1
 Requires-Dist: numpy>=1.18
 Requires-Dist: imageio>=2.18
-Requires-Dist: scitools-iris>=3.5
+Requires-Dist: scitools-iris>=3.12.2
 Requires-Dist: cartopy>=0.20
 Requires-Dist: python-redmine
 Requires-Dist: python-gitlab

{scriptengine_tasks_ecearth-0.8.0 → scriptengine_tasks_ecearth-0.10.0}/scriptengine_tasks_ecearth.egg-info/SOURCES.txt

@@ -19,7 +19,7 @@ monitoring/nemo_all_mean_map.py
 monitoring/nemo_time_mean_temporalmap.py
 monitoring/nemo_timeseries.py
 monitoring/oifs_all_mean_map.py
-monitoring/oifs_global_mean_year_mean_timeseries.py
+monitoring/oifs_timeseries.py
 monitoring/oifs_year_mean_temporalmap.py
 monitoring/redmine.py
 monitoring/scalar.py
@@ -48,7 +48,7 @@ tests/test_nemo_all_mean_map.py
 tests/test_nemo_time_mean_temporalmap.py
 tests/test_nemo_timeseries.py
 tests/test_oifs_all_mean_map.py
-tests/test_oifs_global_mean_year_mean_timeseries.py
+tests/test_oifs_timeseries.py
 tests/test_oifs_year_mean_temporalmap.py
 tests/test_presentation_objects.py
 tests/test_redmine.py

{scriptengine_tasks_ecearth-0.8.0 → scriptengine_tasks_ecearth-0.10.0}/scriptengine_tasks_ecearth.egg-info/entry_points.txt

@@ -8,7 +8,8 @@ ece.mon.nemo_month_mean_temporalmap = monitoring.nemo_time_mean_temporalmap:Nemo
 ece.mon.nemo_year_mean_temporalmap = monitoring.nemo_time_mean_temporalmap:NemoYearMeanTemporalmap
 ece.mon.nemo_year_mean_timeseries = monitoring.nemo_timeseries:NemoYearMeanTimeseries
 ece.mon.oifs_all_mean_map = monitoring.oifs_all_mean_map:OifsAllMeanMap
-ece.mon.oifs_global_mean_year_mean_timeseries = monitoring.oifs_global_mean_year_mean_timeseries:OifsGlobalMeanYearMeanTimeseries
+ece.mon.oifs_global_mean_year_mean_timeseries = monitoring.oifs_timeseries:OifsGlobalMeanYearMeanTimeseries
+ece.mon.oifs_global_sum_year_mean_timeseries = monitoring.oifs_timeseries:OifsGlobalSumYearMeanTimeseries
 ece.mon.oifs_year_mean_temporalmap = monitoring.oifs_year_mean_temporalmap:OifsYearMeanTemporalmap
 ece.mon.presentation.gitlab = monitoring.gitlab:Gitlab
 ece.mon.presentation.markdown = monitoring.markdown:Markdown

{scriptengine_tasks_ecearth-0.8.0 → scriptengine_tasks_ecearth-0.10.0}/scriptengine_tasks_ecearth.egg-info/requires.txt

@@ -3,7 +3,7 @@ pyYAML>=5.1
 matplotlib>=3.1
 numpy>=1.18
 imageio>=2.18
-scitools-iris>=3.5
+scitools-iris>=3.12.2
 cartopy>=0.20
 python-redmine
 python-gitlab

{scriptengine_tasks_ecearth-0.8.0 → scriptengine_tasks_ecearth-0.10.0}/tests/test_oifs_all_mean_map.py

@@ -25,6 +25,24 @@ def test_oifs_all_mean_map_working(tmp_path):
     assert len(cube.coord("time").points) == 1
 
 
+def test_oifs_all_mean_map_regular_grid(tmp_path):
+    init = {
+        "src": ["./tests/testdata/regular_grid_tas.nc"],
+        "dst": str(tmp_path / "test.nc"),
+        "varname": "tas",
+    }
+    atmo_map = OifsAllMeanMap(init)
+    atmo_map.run(init)
+    cube = iris.load_cube(init["dst"])
+    assert cube.name() == "air_temperature"
+    assert cube.attributes["title"] is not None
+    assert cube.attributes["comment"] is not None
+    assert cube.attributes["diagnostic_type"] == "map"
+    assert cube.attributes["map_type"] == "global atmosphere"
+    assert cube.coord("time").climatological
+    assert len(cube.coord("time").points) == 1
+
+
 def test_oifs_all_mean_map_wrong_code(tmp_path):
     init = {
         "src": ["./tests/testdata/TES1_atm_1m_1990_2t.nc"],

scriptengine_tasks_ecearth-0.10.0/tests/test_oifs_timeseries.py

@@ -0,0 +1,84 @@
+"""Tests for monitoring/oifs_timeseries.py"""
+
+import iris
+import pytest
+import scriptengine.exceptions
+
+from monitoring.oifs_timeseries import (
+    OifsGlobalMeanYearMeanTimeseries,
+    OifsGlobalSumYearMeanTimeseries,
+)
+
+
+def test_oifs_global_mean_year_mean_timeseries_working(tmp_path):
+    init = {
+        "src": ["./tests/testdata/TES1_atm_1m_1990_2t.nc"],
+        "dst": str(tmp_path / "test.nc"),
+        "varname": "2t",
+    }
+    atmo_ts = OifsGlobalMeanYearMeanTimeseries(init)
+    atmo_ts.run(init)
+    cube = iris.load_cube(init["dst"])
+    assert cube.name() == "2 metre temperature"
+    assert cube.attributes["title"] is not None
+    assert cube.attributes["comment"] is not None
+    assert cube.attributes["diagnostic_type"] == "time series"
+    assert cube.cell_methods == (
+        iris.coords.CellMethod("mean", coords="area"),
+        iris.coords.CellMethod("mean", coords="time", intervals="1 year"),
+    )
+
+
+def test_oifs_timeseries_compare_grids(tmp_path):
+    init = {
+        "src": ["./tests/testdata/regular_grid_tas.nc"],
+        "dst": str(tmp_path / "test_reg.nc"),
+        "varname": "tas",
+    }
+    atmo_ts = OifsGlobalMeanYearMeanTimeseries(init)
+    atmo_ts.run(init)
+    cube_reg = iris.load_cube(init["dst"])
+
+    init = {
+        "src": ["./tests/testdata/reduced_grid_tas.nc"],
+        "dst": str(tmp_path / "test_red.nc"),
+        "varname": "tas",
+    }
+    atmo_ts = OifsGlobalMeanYearMeanTimeseries(init)
+    atmo_ts.run(init)
+    cube_red = iris.load_cube(init["dst"])
+    assert abs(cube_red.data - cube_reg.data) < 1e-3
+
+
+def test_oifs_global_mean_year_mean_timeseries_wrong_varname(tmp_path):
+    init = {
+        "src": ["./tests/testdata/TES1_atm_1m_1990_2t.nc"],
+        "dst": str(tmp_path / "test.nc"),
+        "varname": "sivolu",
+    }
+    atmo_ts = OifsGlobalMeanYearMeanTimeseries(init)
+    pytest.raises(
+        scriptengine.exceptions.ScriptEngineTaskArgumentInvalidError,
+        atmo_ts.run,
+        init,
+    )
+
+
+def test_oifs_global_sum_year_mean_timeseries_working(tmp_path):
+    init = {
+        "src": ["./tests/testdata/TES1_atm_1m_1990_2t.nc"],
+        "dst": str(tmp_path / "test.nc"),
+        "varname": "2t",
+    }
+    atmo_ts = OifsGlobalSumYearMeanTimeseries(init)
+    atmo_ts.run(init)
+    cube = iris.load_cube(init["dst"])
+    assert cube.name() == "2 metre temperature"
+    assert cube.units == "K m2"
+    assert cube.attributes["title"] is not None
+    assert cube.attributes["comment"] is not None
+    assert cube.attributes["diagnostic_type"] == "time series"
+    assert cube.cell_methods == (
+        iris.coords.CellMethod("sum", coords="area"),
+        iris.coords.CellMethod("mean", coords="time", intervals="1 year"),
+    )

{scriptengine_tasks_ecearth-0.8.0 → scriptengine_tasks_ecearth-0.10.0}/tests/test_oifs_year_mean_temporalmap.py

@@ -23,6 +23,22 @@ def test_oifs_year_mean_temporalmap_working(tmp_path):
     assert cube.attributes["map_type"] == "global atmosphere"
 
 
+def test_oifs_year_mean_temporalmap_regular_grid(tmp_path):
+    init = {
+        "src": ["./tests/testdata/regular_grid_tas.nc"],
+        "dst": str(tmp_path / "test.nc"),
+        "varname": "tas",
+    }
+    atmos_time_map = OifsYearMeanTemporalmap(init)
+    atmos_time_map.run(init)
+    cube = iris.load_cube(init["dst"])
+    assert cube.name() == "air_temperature"
+    assert cube.attributes["title"] is not None
+    assert cube.attributes["comment"] is not None
+    assert cube.attributes["diagnostic_type"] == "temporal map"
+    assert cube.attributes["map_type"] == "global atmosphere"
+
+
 def test_oifs_year_mean_temporalmap_wrong_varname(tmp_path):
     init = {
         "src": ["./tests/testdata/TES1_atm_1m_1990_2t.nc"],

scriptengine_tasks_ecearth-0.8.0/monitoring/oifs_global_mean_year_mean_timeseries.py

@@ -1,131 +0,0 @@
-"""Processing Task that creates a 2D map of a given extensive ocean quantity."""
-
-import warnings
-from pathlib import Path
-
-import iris
-import numpy as np
-from scriptengine.tasks.core import timed_runner
-
-import helpers.cubes
-
-from .timeseries import Timeseries
-
-
-class OifsGlobalMeanYearMeanTimeseries(Timeseries):
-    """OifsGlobalMeanYearMeanTimeseries Processing Task"""
-
-    _required_arguments = ("src", "dst", "varname")
-
-    def __init__(self, arguments=None):
-        OifsGlobalMeanYearMeanTimeseries.check_arguments(arguments)
-        super().__init__(
-            {**arguments, "title": None, "coord_value": None, "data_value": None}
-        )
-
-    @timed_runner
-    def run(self, context):
-        src = self.getarg("src", context)
-        dst = Path(self.getarg("dst", context))
-        varname = self.getarg("varname", context)
-        self.log_info(f"Create time series for atmosphere variable {varname} at {dst}.")
-        self.log_debug(f"Source file(s): {src}")
-
-        self.check_file_extension(dst)
-
-        oifs_cube = helpers.cubes.load_input_cube(src, varname)
-
-        time_mean_cube = self.compute_time_mean(oifs_cube)
-
-        area_weights = self.compute_area_weights(time_mean_cube)
-        timeseries_cube = self.compute_spatial_mean(time_mean_cube, area_weights)
-
-        self.set_cell_methods(timeseries_cube)
-        timeseries_cube = self.adjust_metadata(timeseries_cube, varname)
-        self.save(timeseries_cube, dst)
-
-    def compute_area_weights(self, cube):
-        """compute area weights for the reduced gaussian grid"""
-        self.log_debug("Computing area weights.")
-        nh_latitudes = np.ma.masked_less(cube.coord("latitude").points, 0)
-        unique_lats, gridpoints_per_lat = np.unique(nh_latitudes, return_counts=True)
-        unique_lats, gridpoints_per_lat = unique_lats[0:-1], gridpoints_per_lat[0:-1]
-        areas = []
-        last_angle = 0
-        earth_radius = 6371
-        for latitude, amount in zip(unique_lats, gridpoints_per_lat):
-            delta = latitude - last_angle
-            current_angle = last_angle + 2 * delta
-            sin_diff = np.sin(np.deg2rad(current_angle)) - np.sin(
-                np.deg2rad(last_angle)
-            )
-            ring_area = 2 * np.pi * earth_radius**2 * sin_diff
-            grid_area = ring_area / amount
-            areas.extend([grid_area] * amount)
-            last_angle = current_angle
-        areas = np.append(areas[::-1], areas)
-        area_weights = np.broadcast_to(areas, cube.data.shape)
-        return area_weights
-
-    def set_cell_methods(self, timeseries_cube):
-        """add the correct cell methods"""
-        timeseries_cube.cell_methods = ()
-        timeseries_cube.add_cell_method(
-            iris.coords.CellMethod("mean", coords="time", intervals="1 year")
-        )
-        timeseries_cube.add_cell_method(iris.coords.CellMethod("mean", coords="area"))
-
-    def compute_time_mean(self, output_cube):
-        """Apply the temporal average."""
-        self.log_debug("Averaging over the time coordinate.")
-        # Remove auxiliary time coordinate before collapsing cube
-        try:
-            output_cube.coord("time")
-        except iris.exceptions.CoordinateNotFoundError:
-            output_cube.remove_coord(output_cube.coord("time", dim_coords=False))
-        time_mean_cube = output_cube.collapsed(
-            "time",
-            iris.analysis.MEAN,
-        )
-        # Promote time from scalar to dimension coordinate
-        time_mean_cube = iris.util.new_axis(time_mean_cube, "time")
-        return time_mean_cube
-
-    def compute_spatial_mean(self, time_mean_cube, area_weights):
-        """Apply the spatial average."""
-        self.log_debug("Averaging over latitude and longitude.")
-        # Remove duplicate boundary values before averaging
-        time_mean_cube.coord("latitude").bounds = time_mean_cube.coord(
-            "latitude"
-        ).bounds[:, [0, 1]]
-        time_mean_cube.coord("longitude").bounds = time_mean_cube.coord(
-            "longitude"
-        ).bounds[:, [0, 2]]
-        with warnings.catch_warnings():
-            # Suppress warning about insufficient metadata.
-            warnings.filterwarnings(
-                "ignore",
-                "Collapsing a non-contiguous coordinate.",
-                UserWarning,
-            )
-            spatial_mean_cube = time_mean_cube.collapsed(
-                ["latitude", "longitude"],
-                iris.analysis.MEAN,
-                weights=area_weights,
-            )
-        return spatial_mean_cube
-
-    def adjust_metadata(self, timeseries_cube, varname: str):
-        """Do further adjustments to the cube metadata before saving."""
-        # Add File Metadata
-        comment = (
-            f"Global average time series of **{varname}**. "
-            f"Each data point represents the (spatial and temporal) "
-            f"average over one year."
-        )
-        timeseries_cube = helpers.cubes.set_metadata(
-            timeseries_cube,
-            title=f"{timeseries_cube.long_name} (annual mean)",
-            comment=comment,
-        )
-        return helpers.cubes.convert_units(timeseries_cube)

scriptengine_tasks_ecearth-0.8.0/tests/test_oifs_global_mean_year_mean_timeseries.py

@@ -1,42 +0,0 @@
-"""Tests for monitoring/oifs_global_mean_year_mean_timeseries.py"""
-
-import iris
-import pytest
-import scriptengine.exceptions
-
-from monitoring.oifs_global_mean_year_mean_timeseries import (
-    OifsGlobalMeanYearMeanTimeseries,
-)
-
-
-def test_oifs_global_mean_year_mean_timeseries_working(tmp_path):
-    init = {
-        "src": ["./tests/testdata/TES1_atm_1m_1990_2t.nc"],
-        "dst": str(tmp_path / "test.nc"),
-        "varname": "2t",
-    }
-    atmo_ts = OifsGlobalMeanYearMeanTimeseries(init)
-    atmo_ts.run(init)
-    cube = iris.load_cube(init["dst"])
-    assert cube.name() == "2 metre temperature"
-    assert cube.attributes["title"] is not None
-    assert cube.attributes["comment"] is not None
-    assert cube.attributes["diagnostic_type"] == "time series"
-    assert cube.cell_methods == (
-        iris.coords.CellMethod("mean", coords="time", intervals="1 year"),
-        iris.coords.CellMethod("mean", coords="area"),
-    )
-
-
-def test_oifs_global_mean_year_mean_timeseries_wrong_varname(tmp_path):
-    init = {
-        "src": ["./tests/testdata/TES1_atm_1m_1990_2t.nc"],
-        "dst": str(tmp_path / "test.nc"),
-        "varname": "sivolu",
-    }
-    atmo_ts = OifsGlobalMeanYearMeanTimeseries(init)
-    pytest.raises(
-        scriptengine.exceptions.ScriptEngineTaskArgumentInvalidError,
-        atmo_ts.run,
-        init,
-    )