Add OifsGlobalSumYearMeanTimeseries Processing Task (#123)

* Add new processing task + test

* Refactor OIFS Timeseries task

- remove unused numpy import
- add a class OifsTimeseries to inherit from (analogous to NemoTimeseries)
- has methods: _load_input(), _adjust_metadata(), _compute_global_aggregate() that are shared by OifsGlobalMeanYearMeanTimeseries
*and* OifsGlobalSumYearMeanTimeseries tasks
- align text in added metadata with what we do in NemoTimeseries
- use more concise variable names
- remove compute_time_mean(): we can just use helpers.cubes.compute_annual_mean()
- rename module (cf. nemo_timeseries.py)

* Add documentation, update CHANGES

* Add new task to entry points

* Fix module docstring

Author: valentinaschueller

CHANGES.txt

@@ -1,3 +1,11 @@
+Next Release
+=============
+
+Features
+---------
+- Add a new processing task OifsGlobalSumYearMeanTimeseries (PR #123)
+
+
 ScriptEngine Tasks for EC-Earth 0.9.0
 ======================================
 

docs/sphinx/source/tasks/monitoring/openifs-diagnostics.rst

@@ -34,6 +34,31 @@ If it is, e.g., six months long, the task will compute the six month global mean
         varname: 2t
         dst: "{{mondir}}/2t_oifs_global_mean_year_mean_timeseries.nc"
 
+OifsGlobalSumYearMeanTimeseries
+================================
+
+| Diagnostic Type: Time Series
+| Mapped to: ``ece.mon.oifs_global_sum_year_mean_timeseries``
+
+This processing task computes the global area integral and temporal average of an atmospheric quantity, resulting in a time series diagnostic.
+Units are automatically converted.
+
+To compute an annual mean, the leg has to be one year long.
+If it is, e.g., six months long, the task will compute the six month global mean of the input variable.
+
+**Required arguments**
+
+* ``src``: A string containing the path to the OpenIFS output file.
+* ``varname``: The name of the variable in the output file. Refer to the `ECMWF parameter database`_ for the meaning of the variables.
+* ``dst``: A string ending in ``.nc``. This is where the diagnostic will be saved.
+
+::
+
+    - ece.mon.oifs_global_sum_year_mean_timeseries:
+        src: "{{rundir}}/output/oifs/{{exp_id}}_atm_1m_1990-1990.nc"
+        varname: tcwv
+        dst: "{{mondir}}/tcwv_oifs_global_mean_year_mean_timeseries.nc"
+
 
 OifsAllMeanMap
 ==============

helpers/cubes.py

@@ -98,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",

monitoring/oifs_global_mean_year_mean_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)

monitoring/oifs_timeseries.py

@@ -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"

pyproject.toml

@@ -1,11 +1,12 @@
-"""Tests for monitoring/oifs_global_mean_year_mean_timeseries.py"""
+"""Tests for monitoring/oifs_timeseries.py"""
 
 import iris
 import pytest
 import scriptengine.exceptions
 
-from monitoring.oifs_global_mean_year_mean_timeseries import (
+from monitoring.oifs_timeseries import (
     OifsGlobalMeanYearMeanTimeseries,
+    OifsGlobalSumYearMeanTimeseries,
 )
 
 
@@ -23,8 +24,8 @@ def test_oifs_global_mean_year_mean_timeseries_working(tmp_path):
     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"),
+        iris.coords.CellMethod("mean", coords="time", intervals="1 year"),
     )
 
 
@@ -61,3 +62,23 @@ def test_oifs_global_mean_year_mean_timeseries_wrong_varname(tmp_path):
         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"),
+    )