scriptengine-tasks-ecearth 0.6.2__tar.gz → 0.7.0__tar.gz

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/PKG-INFO

@@ -1,16 +1,24 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: scriptengine-tasks-ecearth
-Version: 0.6.2
+Version: 0.7.0
 Summary: ScriptEngine tasks for use with the EC-Earth climate model
-Home-page: https://github.com/uwefladrich/scriptengine-tasks-ecearth
-Author: Valentina Schueller, Uwe Fladrich
-Author-email: valentina.schueller@gmail.com, uwe.fladrich@protonmail.com
+Author-email: Valentina Schueller <valentina.schueller@gmail.com>, Uwe Fladrich <uwe.fladrich@protonmail.com>
+Project-URL: Homepage, https://github.com/uwefladrich/scriptengine-tasks-ecearth
+Project-URL: Bug Tracker, https://github.com/uwefladrich/scriptengine-tasks-ecearth/issues
 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.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: scriptengine>=0.8.1
+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: cartopy>=0.20
+Requires-Dist: python-redmine
 
 [![Tests](https://github.com/uwefladrich/scriptengine-tasks-ecearth/actions/workflows/pytest.yml/badge.svg)](https://github.com/uwefladrich/scriptengine-tasks-ecearth/actions)
 [![Coverage Status](https://coveralls.io/repos/github/uwefladrich/scriptengine-tasks-ecearth/badge.svg)](https://coveralls.io/github/uwefladrich/scriptengine-tasks-ecearth)

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/helpers/cubes.py

@@ -3,6 +3,7 @@
 import warnings
 
 import iris
+import iris.cube
 import numpy as np
 from iris.util import equalise_attributes
 from scriptengine.exceptions import ScriptEngineTaskArgumentInvalidError
@@ -35,6 +36,34 @@ def load_input_cube(src, varname):
     return leg_cube
 
 
+DEFAULT_UNIT_CONVERSIONS = {
+    "kelvin": "degC",
+    "meter^-2-kilogram-second^-1": "meter^-2-kilogram-day^-1",
+}
+
+
+def convert_units(cube: iris.cube.Cube, conversions=None) -> iris.cube.Cube:
+    """Converts units of an Iris cube
+
+    Converts units if the current unit is present in the 'conversions' dict.
+    Does nothing otherwise.
+
+    Args:
+        cube: An Iris cube
+        conversions: A mapping (dict) with 'unit': 'converted_unit' strings.
+          If None (default), then DEFAULT_UNIT_CONVERSIONS (defined above) is used.
+    Returns:
+        An Iris cube with modified units.
+    """
+    if conversions is None:
+        conversions = DEFAULT_UNIT_CONVERSIONS
+    try:
+        cube.convert_units(conversions[cube.units.name])
+    except KeyError:
+        pass
+    return cube
+
+
 def set_metadata(cube, **kwargs):
     """Set metadata for diagnostic."""
     defaults = {
@@ -66,6 +95,20 @@ def compute_time_weights(monthly_data_cube, cube_shape=None):
     return month_weights
 
 
+def compute_annual_mean(cube):
+    # Remove auxiliary time coordinate before collapsing cube
+    cube.remove_coord(cube.coord("time", dim_coords=False))
+
+    annual_mean = cube.collapsed(
+        "time",
+        iris.analysis.MEAN,
+        weights=compute_time_weights(cube),
+    )
+    # Promote time from scalar to dimension coordinate
+    annual_mean = iris.util.new_axis(annual_mean, "time")
+    return annual_mean
+
+
 def extract_month(cube, month):
     return cube.extract(
         iris.Constraint(time=lambda cell: cell.point.month == month_number(month))
@@ -83,7 +126,6 @@ def remove_aux_time(cube):
 
 
 def annual_time_bounds(cube):
-
     t_coord = cube.coord("time")
     cube.remove_coord("time")
 

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/helpers/map_type_handling.py

@@ -24,7 +24,7 @@ def global_ocean_plot(
     units=None,
     value_range=[None, None],
     colormap="RdBu_r",
-    **kwargs
+    **kwargs,
 ):
     """Map Type Handling for Global Ocean Maps"""
     fig = plt.figure(figsize=(6, 4), dpi=150)
@@ -74,7 +74,7 @@ def global_atmosphere_plot(
     units=None,
     value_range=[None, None],
     colormap="RdBu_r",
-    **kwargs
+    **kwargs,
 ):
     """Map Type Handling for Global Atmosphere Maps"""
     fig = plt.figure(figsize=(6, 4), dpi=150)
@@ -114,7 +114,7 @@ def polar_ice_sheet_plot(
     units=None,
     value_range=[None, None],
     colormap="RdBu_r",
-    **kwargs
+    **kwargs,
 ):
     fig = plt.figure(figsize=(6, 4), dpi=150)
     fig.suptitle(title)

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/helpers/nemo.py

@@ -1,7 +1,11 @@
 """Helper module for NEMO data."""
 
+import warnings
+
 import iris
 import numpy as np
+from iris.analysis import WeightedAggregator
+from iris.coords import CellMeasure
 from iris.exceptions import CoordinateNotFoundError
 
 _nemo_horizontal_coords = (
@@ -55,7 +59,7 @@ def has_depth(cube):
     return len(tuple(depth_coords(cube))) > 0
 
 
-def spatial_weights(cube, domain_file, grid):
+def _add_cell_size(cube, domain_file, grid):
     """Compute cell weights for spatial averaging in 2d and 3d"""
     domain = iris.load(domain_file)
     e1, e2 = (  # NEMO grid scale factors in horizontal directions
@@ -66,7 +70,17 @@ def spatial_weights(cube, domain_file, grid):
     if is_3d:
         e3 = domain.extract(f"e3{grid.lower()}_0")[0][0]
     weights = e1 * e2 * e3 if is_3d else e1 * e2
-    return np.broadcast_to(weights.data, cube.shape)
+    weights = np.broadcast_to(weights.data, cube.shape)
+    if is_3d:
+        cell_size = CellMeasure(
+            weights, var_name="cell_size", units="m3", measure="volume"
+        )
+    else:
+        cell_size = CellMeasure(
+            weights, var_name="cell_size", units="m2", measure="area"
+        )
+    dims = tuple(range(len(weights.shape)))
+    cube.add_cell_measure(cell_size, dims)
 
 
 def remove_unique_attributes(cube):
@@ -74,3 +88,20 @@ def remove_unique_attributes(cube):
     for attribute in drop:
         cube.attributes.pop(attribute, None)
     return cube
+
+
+def compute_global_aggregate(cube, domain, grid, operation: WeightedAggregator):
+    _add_cell_size(cube, domain, grid)
+    with warnings.catch_warnings():
+        # Suppress warning about insufficient metadata.
+        warnings.filterwarnings(
+            "ignore",
+            "Collapsing a multi-dimensional coordinate.",
+            UserWarning,
+        )
+        global_aggregate = cube.collapsed(
+            spatial_coords(cube),
+            operation,
+            weights="cell_size",
+        )
+    return global_aggregate

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/helpers/presentation_objects.py

@@ -98,6 +98,23 @@ class TimeseriesLoader(PresentationObjectLoader):
 
         fig = plt.figure(figsize=(6, 4), dpi=150)
         ax = fig.add_subplot(1, 1, 1)
+
+        # plot (constant) reference value if defined
+        ref = kwargs.get("reference", None)
+        if isinstance(ref, dict):
+            ref_value = ref.get("value", None)
+            if ref_value:
+                ref_label = ref.get("label", "Reference value")
+                ax.axhline(
+                    y=ref_value,
+                    xmin=0.05,
+                    xmax=0.95,
+                    color="r",
+                    linestyle=":",
+                    label=ref_label,
+                )
+                ax.legend()
+
         ax.plot(coord_points, self.cube.data, color="k")
         plt.setp(ax.spines.values(), color="grey")
         ax.grid()

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/monitoring/linear_combination.py

@@ -12,7 +12,6 @@ import helpers.cubes
 
 
 class LinearCombination(Task):
-
     _required_arguments = (
         "src",
         "dst",

scriptengine_tasks_ecearth-0.7.0/monitoring/nemo_timeseries.py

@@ -0,0 +1,157 @@
+"""Processing Tasks for computing Timeseries from NEMO output."""
+
+from pathlib import Path
+
+import iris
+from scriptengine.exceptions import ScriptEngineTaskArgumentInvalidError
+from scriptengine.tasks.core import timed_runner
+
+import helpers.cubes
+import helpers.nemo
+
+from .timeseries import Timeseries
+
+
+class NemoTimeseries(Timeseries):
+    """NemoTimeseries Processing Task"""
+
+    _required_arguments = (
+        "src",
+        "varname",
+        "dst",
+    )
+
+    def __init__(self, arguments):
+        NemoTimeseries.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 ocean variable {var_name}.")
+
+        var_data = helpers.cubes.load_input_cube(src, var_name)
+        return var_data
+
+
+class NemoGlobalSumYearMeanTimeseries(NemoTimeseries):
+    _required_arguments = ("domain",)
+
+    def __init__(self, arguments):
+        NemoGlobalSumYearMeanTimeseries.check_arguments(arguments)
+        super().__init__(arguments)
+
+    @timed_runner
+    def run(self, context):
+        var_data = self._load_input(context)
+
+        domain = self.getarg("domain", context)
+        grid = self.getarg("grid", context, default="T")
+        global_sum = helpers.nemo.compute_global_aggregate(
+            var_data, domain, grid, iris.analysis.SUM
+        )
+
+        annual_mean = helpers.cubes.compute_annual_mean(global_sum)
+
+        annual_mean.cell_methods = (
+            iris.coords.CellMethod("mean", coords="time", intervals="1 year"),
+            iris.coords.CellMethod(
+                "sum",
+                coords=(
+                    ("area", helpers.nemo.depth_coord(annual_mean).name())
+                    if helpers.nemo.has_depth(annual_mean)
+                    else "area"
+                ),
+            ),
+        )
+
+        long_name = annual_mean.long_name
+        var_name = annual_mean.standard_name
+        comment = f"Product of {long_name} / **{var_name}** and grid-cell area, summed over all grid cells."
+        annual_mean = helpers.cubes.set_metadata(
+            annual_mean,
+            title=f"{long_name} (annual mean)",
+            comment=comment,
+        )
+
+        dst = Path(self.getarg("dst", context))
+        self.check_file_extension(dst)
+        self.save(annual_mean, dst)
+
+
+class NemoGlobalMeanYearMeanTimeseries(NemoTimeseries):
+    _required_arguments = ("domain",)
+
+    def __init__(self, arguments):
+        NemoGlobalMeanYearMeanTimeseries.check_arguments(arguments)
+        super().__init__(arguments)
+
+    @timed_runner
+    def run(self, context):
+        var_data = self._load_input(context)
+
+        domain = self.getarg("domain", context)
+        grid = self.getarg("grid", context, default="T")
+        global_mean = helpers.nemo.compute_global_aggregate(
+            var_data, domain, grid, iris.analysis.MEAN
+        )
+
+        annual_mean = helpers.cubes.compute_annual_mean(global_mean)
+
+        annual_mean.cell_methods = (
+            iris.coords.CellMethod("mean", coords="time", intervals="1 year"),
+            iris.coords.CellMethod(
+                "mean",
+                coords=(
+                    ("area", helpers.nemo.depth_coord(annual_mean).name())
+                    if helpers.nemo.has_depth(annual_mean)
+                    else "area"
+                ),
+            ),
+        )
+
+        long_name = annual_mean.long_name
+        var_name = annual_mean.standard_name
+        comment = f"Global mean of {long_name} / **{var_name}**."
+
+        annual_mean = helpers.cubes.set_metadata(
+            annual_mean,
+            title=f"{long_name} (annual mean)",
+            comment=comment,
+        )
+
+        dst = Path(self.getarg("dst", context))
+        self.check_file_extension(dst)
+        self.save(annual_mean, dst)
+
+
+class NemoYearMeanTimeseries(NemoTimeseries):
+    @timed_runner
+    def run(self, context):
+        var_data = self._load_input(context)
+
+        if not var_data.ndim == 1:
+            self.log_error(f"Input data is not one-dimensional.")
+            raise ScriptEngineTaskArgumentInvalidError
+
+        annual_mean = helpers.cubes.compute_annual_mean(var_data)
+
+        annual_mean.cell_methods = (
+            iris.coords.CellMethod("mean", coords="time", intervals="1 year"),
+        )
+
+        long_name = annual_mean.long_name
+        var_name = annual_mean.standard_name
+        comment = f"Annual mean of {long_name} / **{var_name}**."
+
+        annual_mean = helpers.cubes.set_metadata(
+            annual_mean,
+            title=f"{long_name} (annual mean)",
+            comment=comment,
+        )
+
+        dst = Path(self.getarg("dst", context))
+        self.check_file_extension(dst)
+        self.save(annual_mean, dst)

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/monitoring/oifs_all_mean_map.py

@@ -1,4 +1,5 @@
 """Processing Task that creates a 2D map of a given extensive atmosphere quantity."""
+
 from pathlib import Path
 
 import iris
@@ -82,7 +83,4 @@ class OifsAllMeanMap(Map):
             comment=f"Simulation average of **{varname}**.",
             map_type="global atmosphere",
         )
-        # Convert unit to °C if varname is given in K
-        if map_cube.units.name == "kelvin":
-            map_cube.convert_units("degC")
-        return map_cube
+        return helpers.cubes.convert_units(map_cube)

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/monitoring/oifs_global_mean_year_mean_timeseries.py

@@ -128,7 +128,4 @@ class OifsGlobalMeanYearMeanTimeseries(Timeseries):
             title=f"{timeseries_cube.long_name} (annual mean)",
             comment=comment,
         )
-        # Convert unit to °C if varname is given in K
-        if timeseries_cube.units.name == "kelvin":
-            timeseries_cube.convert_units("degC")
-        return timeseries_cube
+        return helpers.cubes.convert_units(timeseries_cube)

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/monitoring/oifs_year_mean_temporalmap.py

@@ -71,7 +71,4 @@ class OifsYearMeanTemporalmap(Temporalmap):
             comment=f"Annual mean of **{varname}**.",
             map_type="global atmosphere",
         )
-        # Convert unit to °C if varname is given in K
-        if temporalmap_cube.units.name == "kelvin":
-            temporalmap_cube.convert_units("degC")
-        return temporalmap_cube
+        return helpers.cubes.convert_units(temporalmap_cube)

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/monitoring/si3_hemis_sum_month_mean_timeseries.py

@@ -18,14 +18,12 @@ _meta_dict = {
         "long_name": "Sea-Ice Volume",
         "standard_name": "sea_ice_volume",
         "var_name": "sivol",
-        "old_unit": "m3",
         "new_unit": "1e3 km3",
     },
     "siconc": {
         "long_name": "Sea-Ice Area",
         "standard_name": "sea_ice_area",
         "var_name": "siarea",
-        "old_unit": "m2",
         "new_unit": "1e6 km2",
     },
 }
@@ -98,21 +96,11 @@ class Si3HemisSumMonthMeanTimeseries(Timeseries):
         this_leg = helpers.cubes.mask_other_hemisphere(this_leg, hemisphere)
         this_leg = helpers.cubes.annual_time_bounds(this_leg)
 
-        with warnings.catch_warnings():
-            # Suppress warning about insufficient metadata.
-            warnings.filterwarnings(
-                "ignore",
-                "Collapsing a multi-dimensional coordinate.",
-                UserWarning,
-            )
-            this_leg_summed = this_leg.collapsed(
-                ["latitude", "longitude"],
-                iris.analysis.SUM,
-                weights=helpers.nemo.spatial_weights(this_leg, domain, "T"),
-            )
+        this_leg_summed = helpers.nemo.compute_global_aggregate(
+            this_leg, domain, "T", iris.analysis.SUM
+        )
 
         this_leg_summed.standard_name = _meta_dict[varname]["standard_name"]
-        this_leg_summed.units = cf_units.Unit(_meta_dict[varname]["old_unit"])
         this_leg_summed.convert_units(_meta_dict[varname]["new_unit"])
         this_leg_summed.long_name = (
             f"{long_name} {helpers.dates.month_name(month)} {hemisphere}"

scriptengine_tasks_ecearth-0.7.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+    requires = ["setuptools>=59.7", "wheel"]
+    build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+    packages = ["helpers", "monitoring"]
+
+[project]
+    name = "scriptengine-tasks-ecearth"
+    version = "0.7.0"
+    authors = [
+        { name = "Valentina Schueller", email = "valentina.schueller@gmail.com" },
+        { name = "Uwe Fladrich", email = "uwe.fladrich@protonmail.com" },
+    ]
+    description = "ScriptEngine tasks for use with the EC-Earth climate model"
+    readme = "README.md"
+    classifiers = [
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+        "Operating System :: OS Independent",
+    ]
+    requires-python = ">=3.8"
+    dependencies = [
+        "scriptengine>=0.8.1",
+        "pyYAML>=5.1",
+        "matplotlib>=3.1",
+        "numpy>=1.18",
+        "imageio>=2.18",
+        "scitools-iris>=3.5",
+        "cartopy>=0.20",
+        "python-redmine",
+    ]
+
+    [project.urls]
+        "Homepage" = "https://github.com/uwefladrich/scriptengine-tasks-ecearth"
+        "Bug Tracker" = "https://github.com/uwefladrich/scriptengine-tasks-ecearth/issues"
+
+    [project.entry-points."scriptengine.tasks"]
+        "ece.mon.scalar" = "monitoring.scalar:Scalar"
+        "ece.mon.timeseries" = "monitoring.timeseries:Timeseries"
+        "ece.mon.diskusage_rte_scalar" = "monitoring.diskusage_rte_scalar:DiskusageRteScalar"
+        "ece.mon.simulatedyears_rte_scalar" = "monitoring.simulatedyears_rte_scalar:SimulatedyearsRteScalar"
+        "ece.mon.nemo_global_mean_year_mean_timeseries" = "monitoring.nemo_timeseries:NemoGlobalMeanYearMeanTimeseries"
+        "ece.mon.nemo_global_sum_year_mean_timeseries" = "monitoring.nemo_timeseries:NemoGlobalSumYearMeanTimeseries"
+        "ece.mon.nemo_year_mean_timeseries" = "monitoring.nemo_timeseries:NemoYearMeanTimeseries"
+        "ece.mon.nemo_all_mean_map" = "monitoring.nemo_all_mean_map:NemoAllMeanMap"
+        "ece.mon.nemo_month_mean_temporalmap" = "monitoring.nemo_time_mean_temporalmap:NemoMonthMeanTemporalmap"
+        "ece.mon.nemo_year_mean_temporalmap" = "monitoring.nemo_time_mean_temporalmap:NemoYearMeanTemporalmap"
+        "ece.mon.si3_hemis_sum_month_mean_timeseries" = "monitoring.si3_hemis_sum_month_mean_timeseries:Si3HemisSumMonthMeanTimeseries"
+        "ece.mon.si3_hemis_point_month_mean_all_mean_map" = "monitoring.si3_hemis_point_month_mean_all_mean_map:Si3HemisPointMonthMeanAllMeanMap"
+        "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.presentation.markdown" = "monitoring.markdown:Markdown"
+        "ece.mon.presentation.redmine" = "monitoring.redmine:Redmine"
+        "ece.mon.linear_combination" = "monitoring.linear_combination:LinearCombination"

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/scriptengine_tasks_ecearth.egg-info/PKG-INFO

@@ -1,16 +1,24 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: scriptengine-tasks-ecearth
-Version: 0.6.2
+Version: 0.7.0
 Summary: ScriptEngine tasks for use with the EC-Earth climate model
-Home-page: https://github.com/uwefladrich/scriptengine-tasks-ecearth
-Author: Valentina Schueller, Uwe Fladrich
-Author-email: valentina.schueller@gmail.com, uwe.fladrich@protonmail.com
+Author-email: Valentina Schueller <valentina.schueller@gmail.com>, Uwe Fladrich <uwe.fladrich@protonmail.com>
+Project-URL: Homepage, https://github.com/uwefladrich/scriptengine-tasks-ecearth
+Project-URL: Bug Tracker, https://github.com/uwefladrich/scriptengine-tasks-ecearth/issues
 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.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: scriptengine>=0.8.1
+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: cartopy>=0.20
+Requires-Dist: python-redmine
 
 [![Tests](https://github.com/uwefladrich/scriptengine-tasks-ecearth/actions/workflows/pytest.yml/badge.svg)](https://github.com/uwefladrich/scriptengine-tasks-ecearth/actions)
 [![Coverage Status](https://coveralls.io/repos/github/uwefladrich/scriptengine-tasks-ecearth/badge.svg)](https://coveralls.io/github/uwefladrich/scriptengine-tasks-ecearth)

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/scriptengine_tasks_ecearth.egg-info/SOURCES.txt

@@ -15,8 +15,8 @@ monitoring/linear_combination.py
 monitoring/map.py
 monitoring/markdown.py
 monitoring/nemo_all_mean_map.py
-monitoring/nemo_global_mean_year_mean_timeseries.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_year_mean_temporalmap.py
@@ -34,7 +34,6 @@ scriptengine_tasks_ecearth.egg-info/dependency_links.txt
 scriptengine_tasks_ecearth.egg-info/entry_points.txt
 scriptengine_tasks_ecearth.egg-info/requires.txt
 scriptengine_tasks_ecearth.egg-info/top_level.txt
-tests/__init__.py
 tests/test_cubes.py
 tests/test_dates.py
 tests/test_diskusage_rte_scalar.py
@@ -44,8 +43,8 @@ tests/test_map.py
 tests/test_map_type_handling.py
 tests/test_markdown.py
 tests/test_nemo_all_mean_map.py
-tests/test_nemo_global_mean_year_mean_timeseries.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_year_mean_temporalmap.py

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/scriptengine_tasks_ecearth.egg-info/entry_points.txt

@@ -2,9 +2,11 @@
 ece.mon.diskusage_rte_scalar = monitoring.diskusage_rte_scalar:DiskusageRteScalar
 ece.mon.linear_combination = monitoring.linear_combination:LinearCombination
 ece.mon.nemo_all_mean_map = monitoring.nemo_all_mean_map:NemoAllMeanMap
-ece.mon.nemo_global_mean_year_mean_timeseries = monitoring.nemo_global_mean_year_mean_timeseries:NemoGlobalMeanYearMeanTimeseries
+ece.mon.nemo_global_mean_year_mean_timeseries = monitoring.nemo_timeseries:NemoGlobalMeanYearMeanTimeseries
+ece.mon.nemo_global_sum_year_mean_timeseries = monitoring.nemo_timeseries:NemoGlobalSumYearMeanTimeseries
 ece.mon.nemo_month_mean_temporalmap = monitoring.nemo_time_mean_temporalmap:NemoMonthMeanTemporalmap
 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_year_mean_temporalmap = monitoring.oifs_year_mean_temporalmap:OifsYearMeanTemporalmap

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/scriptengine_tasks_ecearth.egg-info/requires.txt

@@ -3,6 +3,6 @@ pyYAML>=5.1
 matplotlib>=3.1
 numpy>=1.18
 imageio>=2.18
-scitools-iris!=3.2.0,!=3.2.0.post0,>=3.1
+scitools-iris>=3.5
 cartopy>=0.20
 python-redmine

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/scriptengine_tasks_ecearth.egg-info/top_level.txt

@@ -1,3 +1,2 @@
 helpers
 monitoring
-tests

scriptengine_tasks_ecearth-0.7.0/setup.py

@@ -0,0 +1,5 @@
+import setuptools
+
+
+if __name__ == "__main__":
+    setuptools.setup()

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/tests/test_cubes.py

@@ -120,3 +120,17 @@ def test_annual_time_bounds():
         ]
     )
     assert (new_bounds == annual_bounds).all()
+
+
+@pytest.mark.parametrize(
+    ("unit", "converted_unit"),
+    (
+        ("m", "m"),
+        ("m-s^-1", "m-s^-1"),
+        ("kelvin", "degC"),
+        ("meter^-2-kilogram-second^-1", "meter^-2-kilogram-day^-1"),
+    ),
+)
+def test_unit_conversions(unit, converted_unit):
+    cube = Cube(np.array([1]), units=unit)
+    assert helpers.cubes.convert_units(cube).units == cf_units.Unit(converted_unit)

{scriptengine-tasks-ecearth-0.6.2 → scriptengine_tasks_ecearth-0.7.0}/tests/test_file_handling.py

@@ -38,7 +38,8 @@ def test_2d_spatial_weights(tmp_path):
     domain_file = str(tmp_path / "domain.nc")
     iris.save(domain, domain_file)
     expected_weights = np.array([6.0])
-    assert helpers.nemo.spatial_weights(data, domain_file, "t") == expected_weights
+    helpers.nemo._add_cell_size(data, domain_file, "t")
+    assert data.cell_measure("cell_size").data == expected_weights
 
 
 def test_3d_spatial_weights(tmp_path):
@@ -66,4 +67,5 @@ def test_3d_spatial_weights(tmp_path):
     domain_file = str(tmp_path / "domain.nc")
     iris.save(domain, domain_file)
     expected_weights = np.array([24.0])
-    assert helpers.nemo.spatial_weights(data, domain_file, "t") == expected_weights
+    helpers.nemo._add_cell_size(data, domain_file, "t")
+    assert data.cell_measure("cell_size").data == expected_weights

scriptengine_tasks_ecearth-0.7.0/tests/test_nemo_timeseries.py

@@ -0,0 +1,99 @@
+"""Tests for monitoring/nemo_global_mean_year_mean_timeseries.py"""
+
+import cf_units
+import iris
+import numpy as np
+import pytest
+import scriptengine.exceptions
+
+from monitoring.nemo_timeseries import (
+    NemoGlobalMeanYearMeanTimeseries,
+    NemoGlobalSumYearMeanTimeseries,
+    NemoYearMeanTimeseries,
+)
+
+
+def test_load_collapse_save(tmp_path):
+    # Tests for issue #53, caused by a bug in Iris 3.2.0.post0
+
+    src = "tests/testdata/NEMO_output_sivolu-199003.nc"
+    dst = tmp_path / "test.nc"
+    var = "sivolu"
+
+    cube = iris.load_cube(src, var).collapsed("latitude", iris.analysis.MEAN)
+    #   print(cube)  # Workaround for the Iris bug
+    iris.save(cube, str(dst))
+
+
+def test_nemo_global_mean_year_mean_timeseries_working(tmp_path):
+    init = {
+        "src": ["./tests/testdata/NEMO_output_sivolu-199003.nc"],
+        "dst": str(tmp_path / "test.nc"),
+        "domain": "./tests/testdata/domain_cfg_example.nc",
+        "varname": "sivolu",
+        "grid": "T",
+    }
+    global_avg = NemoGlobalMeanYearMeanTimeseries(init)
+    global_avg.run(init)
+    cube = iris.load_cube(init["dst"])
+    assert cube.name() == "sea_ice_thickness"
+    assert cube.units == cf_units.Unit("m")  # no unit change
+    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_nemo_global_sum_year_mean_timeseries_working(tmp_path):
+    init = {
+        "src": ["./tests/testdata/NEMO_output_sivolu-199003.nc"],
+        "dst": str(tmp_path / "test.nc"),
+        "domain": "./tests/testdata/domain_cfg_example.nc",
+        "varname": "sivolu",
+        "grid": "T",
+    }
+    global_avg = NemoGlobalSumYearMeanTimeseries(init)
+    global_avg.run(init)
+    cube = iris.load_cube(init["dst"])
+    assert cube.name() == "sea_ice_thickness"
+    assert cube.units == cf_units.Unit("m3")  # units were changed due to integration
+    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("sum", coords="area"),
+    )
+
+
+def test_nemo_year_mean_timeseries_wrong_dim(tmp_path):
+    init = {
+        "src": ["./tests/testdata/NEMO_output_sivolu-199003.nc"],
+        "dst": str(tmp_path / "test.nc"),
+        "varname": "sivolu",
+    }
+    year_mean_ts = NemoYearMeanTimeseries(init)
+    pytest.raises(
+        scriptengine.exceptions.ScriptEngineTaskArgumentInvalidError,
+        year_mean_ts.run,
+        init,
+    )
+
+
+def test_nemo_year_mean_timeseries_working(tmp_path):
+    init = {
+        "src": ["./tests/testdata/a8gx_bgc_5d_bioscalar_1990-1990.nc"],
+        "dst": str(tmp_path / "test.nc"),
+        "varname": "tdenit",
+    }
+    year_mean_ts = NemoYearMeanTimeseries(init)
+    year_mean_ts.run(init)
+    out_cube = iris.load_cube(init["dst"])
+    assert out_cube.shape == (1,)
+    assert out_cube.coord().has_bounds()
+    assert out_cube.cell_methods == (
+        iris.coords.CellMethod("mean", coords="time", intervals="1 year"),
+    )

scriptengine-tasks-ecearth-0.6.2/monitoring/nemo_global_mean_year_mean_timeseries.py

@@ -1,89 +0,0 @@
-"""Processing Task that calculates the annual global average of a given extensive quantity."""
-
-import warnings
-from pathlib import Path
-
-import iris
-from scriptengine.tasks.core import timed_runner
-
-import helpers.cubes
-import helpers.nemo
-
-from .timeseries import Timeseries
-
-
-class NemoGlobalMeanYearMeanTimeseries(Timeseries):
-    """NemoGlobalMeanYearMeanTimeseries Processing Task"""
-
-    _required_arguments = (
-        "src",
-        "domain",
-        "varname",
-        "dst",
-    )
-
-    def __init__(self, arguments):
-        NemoGlobalMeanYearMeanTimeseries.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))
-        var_name = self.getarg("varname", context)
-        domain = self.getarg("domain", context)
-        grid = self.getarg("grid", context, default="T")
-
-        comment = (
-            f"Global average time series of **{var_name}**. "
-            "Each data point represents the (spatial and temporal) "
-            "average over one leg."
-        )
-        self.log_info(f"Create time series for ocean variable {var_name} at {dst}.")
-        self.log_debug(f"Domain: {domain}, Source file(s): {src}")
-
-        self.check_file_extension(dst)
-
-        var_data = helpers.cubes.load_input_cube(src, var_name)
-        with warnings.catch_warnings():
-            # Suppress warning about insufficient metadata.
-            warnings.filterwarnings(
-                "ignore",
-                "Collapsing a multi-dimensional coordinate.",
-                UserWarning,
-            )
-            global_avg = var_data.collapsed(
-                helpers.nemo.spatial_coords(var_data),
-                iris.analysis.MEAN,
-                weights=helpers.nemo.spatial_weights(var_data, domain, grid),
-            )
-        # Remove auxiliary time coordinate before collapsing cube
-        global_avg.remove_coord(global_avg.coord("time", dim_coords=False))
-        global_annual_avg = global_avg.collapsed(
-            "time",
-            iris.analysis.MEAN,
-            weights=helpers.cubes.compute_time_weights(global_avg),
-        )
-        # Promote time from scalar to dimension coordinate
-        global_annual_avg = iris.util.new_axis(global_annual_avg, "time")
-
-        global_annual_avg = helpers.cubes.set_metadata(
-            global_annual_avg,
-            title=f"{global_annual_avg.long_name} (annual mean)",
-            comment=comment,
-        )
-
-        global_annual_avg.cell_methods = (
-            iris.coords.CellMethod("mean", coords="time", intervals="1 month"),
-            iris.coords.CellMethod(
-                "mean",
-                coords=("area", helpers.nemo.depth_coord(global_annual_avg).name())
-                if helpers.nemo.has_depth(global_annual_avg)
-                else "area",
-            ),
-        )
-
-        self.save(global_annual_avg, dst)

scriptengine-tasks-ecearth-0.6.2/pyproject.toml

@@ -1,6 +0,0 @@
-[build-system]
-requires = [
-    "setuptools>=42",
-    "wheel"
-]
-build-backend = "setuptools.build_meta"

scriptengine-tasks-ecearth-0.6.2/setup.py

@@ -1,77 +0,0 @@
-import codecs
-from pathlib import Path
-
-import setuptools
-
-
-def read(rel_path):
-    """
-    Helper function to read file in relative path.
-    """
-    here = Path(__file__).parent.resolve()
-    with codecs.open(here / rel_path, "r") as fp:
-        return fp.read()
-
-
-def get_version(rel_path):
-    """
-    Helper function to get package version.
-    """
-    for line in read(rel_path).splitlines():
-        if line.startswith("__version__"):
-            delim = '"' if '"' in line else "'"
-            return line.split(delim)[1]
-
-
-setuptools.setup(
-    name="scriptengine-tasks-ecearth",
-    version=get_version("version.py"),
-    author="Valentina Schueller, Uwe Fladrich",
-    author_email="valentina.schueller@gmail.com, uwe.fladrich@protonmail.com",
-    description="ScriptEngine tasks for use with the EC-Earth climate model",
-    long_description=read("README.md"),
-    long_description_content_type="text/markdown",
-    url="https://github.com/uwefladrich/scriptengine-tasks-ecearth",
-    packages=[
-        "helpers",
-        "monitoring",
-        "tests",
-    ],
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
-        "Operating System :: OS Independent",
-    ],
-    python_requires=">=3.7",
-    install_requires=[
-        "scriptengine>=0.8.1",
-        "pyYAML>=5.1",
-        "matplotlib>=3.1",
-        "numpy>=1.18",
-        "imageio>=2.18",
-        "scitools-iris>=3.1,!=3.2.0,!=3.2.0.post0",
-        "cartopy>=0.20",
-        "python-redmine",
-    ],
-    entry_points={
-        "scriptengine.tasks": [
-            "ece.mon.scalar = monitoring.scalar:Scalar",
-            "ece.mon.timeseries = monitoring.timeseries:Timeseries",
-            "ece.mon.diskusage_rte_scalar = monitoring.diskusage_rte_scalar:DiskusageRteScalar",
-            "ece.mon.simulatedyears_rte_scalar = monitoring.simulatedyears_rte_scalar:SimulatedyearsRteScalar",
-            "ece.mon.nemo_global_mean_year_mean_timeseries = monitoring.nemo_global_mean_year_mean_timeseries:NemoGlobalMeanYearMeanTimeseries",
-            "ece.mon.nemo_all_mean_map = monitoring.nemo_all_mean_map:NemoAllMeanMap",
-            "ece.mon.nemo_month_mean_temporalmap = monitoring.nemo_time_mean_temporalmap:NemoMonthMeanTemporalmap",
-            "ece.mon.nemo_year_mean_temporalmap = monitoring.nemo_time_mean_temporalmap:NemoYearMeanTemporalmap",
-            "ece.mon.si3_hemis_sum_month_mean_timeseries = monitoring.si3_hemis_sum_month_mean_timeseries:Si3HemisSumMonthMeanTimeseries",
-            "ece.mon.si3_hemis_point_month_mean_all_mean_map = monitoring.si3_hemis_point_month_mean_all_mean_map:Si3HemisPointMonthMeanAllMeanMap",
-            "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.presentation.markdown = monitoring.markdown:Markdown",
-            "ece.mon.presentation.redmine = monitoring.redmine:Redmine",
-            "ece.mon.linear_combination = monitoring.linear_combination:LinearCombination",
-        ]
-    },
-)

scriptengine-tasks-ecearth-0.6.2/tests/test_nemo_global_mean_year_mean_timeseries.py

@@ -1,40 +0,0 @@
-"""Tests for monitoring/nemo_global_mean_year_mean_timeseries.py"""
-
-import iris
-
-from monitoring.nemo_global_mean_year_mean_timeseries import (
-    NemoGlobalMeanYearMeanTimeseries,
-)
-
-
-def test_load_collapse_save(tmp_path):
-    # Tests for issue #53, caused by a bug in Iris 3.2.0.post0
-
-    src = "tests/testdata/NEMO_output_sivolu-199003.nc"
-    dst = tmp_path / "test.nc"
-    var = "sivolu"
-
-    cube = iris.load_cube(src, var).collapsed("latitude", iris.analysis.MEAN)
-    #   print(cube)  # Workaround for the Iris bug
-    iris.save(cube, str(dst))
-
-
-def test_nemo_global_mean_year_mean_timeseries_working(tmp_path):
-    init = {
-        "src": ["./tests/testdata/NEMO_output_sivolu-199003.nc"],
-        "dst": str(tmp_path / "test.nc"),
-        "domain": "./tests/testdata/domain_cfg_example.nc",
-        "varname": "sivolu",
-        "grid": "T",
-    }
-    global_avg = NemoGlobalMeanYearMeanTimeseries(init)
-    global_avg.run(init)
-    cube = iris.load_cube(init["dst"])
-    assert cube.name() == "sea_ice_thickness"
-    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 month"),
-        iris.coords.CellMethod("mean", coords="area"),
-    )