diff --git a/decoimpact/business/entities/rules/combine_results_rule.py b/decoimpact/business/entities/rules/combine_results_rule.py index 81249eb3..88c26368 100644 --- a/decoimpact/business/entities/rules/combine_results_rule.py +++ b/decoimpact/business/entities/rules/combine_results_rule.py @@ -19,7 +19,7 @@ from decoimpact.business.entities.rules.i_multi_array_based_rule import ( IMultiArrayBasedRule, ) -from decoimpact.business.entities.rules.multi_array_operation_type import ( +from decoimpact.business.entities.rules.options.multi_array_operation_type import ( MultiArrayOperationType, ) from decoimpact.business.entities.rules.rule_base import RuleBase diff --git a/decoimpact/business/entities/rules/depth_average_rule.py b/decoimpact/business/entities/rules/depth_average_rule.py index 8119429f..749e3305 100644 --- a/decoimpact/business/entities/rules/depth_average_rule.py +++ b/decoimpact/business/entities/rules/depth_average_rule.py @@ -54,11 +54,14 @@ def execute( interface_suffix = _get_layer_suffix(self._layer_type, logger) bed_level_values = _extract_variable_based_on_suffix( - value_arrays, BED_LEVEL_SUFFIX) + value_arrays, BED_LEVEL_SUFFIX + ) depths_interfaces = _extract_variable_based_on_suffix( - value_arrays, interface_suffix) + value_arrays, interface_suffix + ) water_level_values = _extract_variable_based_on_suffix( - value_arrays, WATER_LEVEL_SUFFIX) + value_arrays, WATER_LEVEL_SUFFIX + ) # Get the dimension names for the interfaces and for the layers dim_interfaces_name = list(depths_interfaces.dims)[0] @@ -118,9 +121,8 @@ def execute( def _extract_variable_based_on_suffix( - value_arrays: Dict[str, _xr.DataArray], - suffix: str - ) -> List: + value_arrays: Dict[str, _xr.DataArray], suffix: str +) -> List: """Extract the values from the XArray dataset based on the name suffixes by matching the name, irrespective of the dummy name prefix. @@ -134,10 +136,7 @@ def _extract_variable_based_on_suffix( return [value_arrays[name] for name in value_arrays if suffix in name][0] -def _get_layer_suffix( - layer_type: str, - logger: ILogger - ): +def _get_layer_suffix(layer_type: str, logger: ILogger): """Get the interface suffix depending on whether the model is a sigma or z layer model. Give error if the interface suffix cannot be determined. @@ -151,7 +150,9 @@ def _get_layer_suffix( return INTERFACES_SIGMA_SUFFIX if layer_type.lower() == "z": return INTERFACES_Z_SUFFIX - logger.log_error(f"Layer type {layer_type} unknown. Allowed layer " - "type: z or sigma. Interface " - "variable could not be determined.") + logger.log_error( + f"Layer type {layer_type} unknown. Allowed layer " + "type: z or sigma. Interface " + "variable could not be determined." + ) return "_unknown" diff --git a/decoimpact/business/entities/rules/filter_extremes_rule.py b/decoimpact/business/entities/rules/filter_extremes_rule.py new file mode 100644 index 00000000..5e58405d --- /dev/null +++ b/decoimpact/business/entities/rules/filter_extremes_rule.py @@ -0,0 +1,137 @@ +# This file is part of D-EcoImpact +# Copyright (C) 2022-2024 Stichting Deltares +# This program is free software distributed under the +# GNU Affero General Public License version 3.0 +# A copy of the GNU Affero General Public License can be found at +# https://github.com/Deltares/D-EcoImpact/blob/main/LICENSE.md +""" +Module for FilterExtremesRule class + +Classes: + FilterExtremesRule +""" + +from typing import List + +import xarray as _xr +import scipy as _sc +import numpy as _np + +from decoimpact.business.entities.rules.i_array_based_rule import IArrayBasedRule +from decoimpact.business.entities.rules.options.options_filter_extreme_rule import ( + ExtremeTypeOptions, +) +from decoimpact.business.entities.rules.rule_base import RuleBase +from decoimpact.business.entities.rules.time_operation_settings import ( + TimeOperationSettings, +) +from decoimpact.business.utils.data_array_utils import get_time_dimension_name +from decoimpact.crosscutting.i_logger import ILogger +from decoimpact.data.dictionary_utils import get_dict_element + + +class FilterExtremesRule(RuleBase, IArrayBasedRule): + """Implementation for the filter extremes rule""" + + # pylint: disable=too-many-arguments + def __init__( + self, + name: str, + input_variable_names: List[str], + extreme_type: ExtremeTypeOptions, + distance: int, + time_scale: str, + mask: bool, + ): + super().__init__(name, input_variable_names) + self._settings = TimeOperationSettings( + {"second": "s", "hour": "h", "day": "D", "month": "M", "year": "Y"} + ) + self._extreme_type: ExtremeTypeOptions = extreme_type + self._distance = distance + self._settings.time_scale = time_scale + self._mask = mask + + @property + def settings(self): + """Time operation settings""" + return self._settings + + @property + def extreme_type(self) -> ExtremeTypeOptions: + """Type of extremes (peaks or troughs)""" + return self._extreme_type + + @property + def distance(self) -> int: + """Minimal distance between peaks""" + return self._distance + + @property + def mask(self) -> bool: + """Return either directly the values of the filtered array or a + True/False array""" + return self._mask + + def validate(self, logger: ILogger) -> bool: + """Validates if the rule is valid + + Returns: + bool: wether the rule is valid + """ + return self.settings.validate(self.name, logger) + + def execute(self, value_array: _xr.DataArray, logger: ILogger) -> _xr.DataArray: + """ + Retrieve the extremes + extreme_type: Either retrieve the values at the peaks or troughs + mask: If False return the values at the peaks, otherwise return a + 1 at the extreme locations. + + Args: + value_array (DataArray): Values to filter at extremes + + Returns: + DataArray: Filtered DataArray with only the extremes remaining + at all other times the values are set to NaN + """ + + time_scale = get_dict_element( + self.settings.time_scale, self.settings.time_scale_mapping + ) + + time_dim_name = get_time_dimension_name(value_array, logger) + time = value_array.time.values + timestep = (time[-1] - time[0]) / len(time) + width_time = _np.timedelta64(self.distance, time_scale) + distance = width_time / timestep + + results = _xr.apply_ufunc( + self._process_peaks, + value_array, + input_core_dims=[[time_dim_name]], + output_core_dims=[[time_dim_name]], + vectorize=True, + kwargs={ + "distance": distance, + "mask": self.mask, + "extreme_type": self.extreme_type, + }, + ) + + results = results.transpose(*value_array.dims) + return results + + def _process_peaks( + self, arr: _xr.DataArray, distance: float, mask: bool, extreme_type: str + ): + factor = 1 + if extreme_type == "troughs": + factor = -1 + peaks, _ = _sc.signal.find_peaks(factor * arr, distance=distance) + values = arr[peaks] + if mask: + values = True + new_arr = _np.full_like(arr, _np.nan, dtype=float) + new_arr[peaks] = values + return new_arr diff --git a/decoimpact/business/entities/rules/multi_array_operation_type.py b/decoimpact/business/entities/rules/options/multi_array_operation_type.py similarity index 100% rename from decoimpact/business/entities/rules/multi_array_operation_type.py rename to decoimpact/business/entities/rules/options/multi_array_operation_type.py diff --git a/decoimpact/business/entities/rules/options/options_filter_extreme_rule.py b/decoimpact/business/entities/rules/options/options_filter_extreme_rule.py new file mode 100644 index 00000000..57fdb278 --- /dev/null +++ b/decoimpact/business/entities/rules/options/options_filter_extreme_rule.py @@ -0,0 +1,20 @@ +# This file is part of D-EcoImpact +# Copyright (C) 2022-2024 Stichting Deltares +# This program is free software distributed under the +# GNU Affero General Public License version 3.0 +# A copy of the GNU Affero General Public License can be found at +# https://github.com/Deltares/D-EcoImpact/blob/main/LICENSE.md +""" +Module for ExtremeTypeOptions Class + +Classes: + ExtremeTypeOptions +""" +from enum import Enum + + +class ExtremeTypeOptions(str, Enum): + """Classify the extreme type options.""" + + PEAKS = "peaks" + TROUGHS = "troughs" diff --git a/decoimpact/business/workflow/model_builder.py b/decoimpact/business/workflow/model_builder.py index 1eee980c..fcc16966 100644 --- a/decoimpact/business/workflow/model_builder.py +++ b/decoimpact/business/workflow/model_builder.py @@ -20,10 +20,11 @@ from decoimpact.business.entities.rules.classification_rule import ClassificationRule from decoimpact.business.entities.rules.combine_results_rule import CombineResultsRule from decoimpact.business.entities.rules.depth_average_rule import DepthAverageRule +from decoimpact.business.entities.rules.filter_extremes_rule import FilterExtremesRule from decoimpact.business.entities.rules.formula_rule import FormulaRule from decoimpact.business.entities.rules.i_rule import IRule from decoimpact.business.entities.rules.layer_filter_rule import LayerFilterRule -from decoimpact.business.entities.rules.multi_array_operation_type import ( +from decoimpact.business.entities.rules.options.multi_array_operation_type import ( MultiArrayOperationType, ) from decoimpact.business.entities.rules.multiply_rule import MultiplyRule @@ -41,6 +42,7 @@ from decoimpact.data.api.i_combine_results_rule_data import ICombineResultsRuleData from decoimpact.data.api.i_data_access_layer import IDataAccessLayer from decoimpact.data.api.i_depth_average_rule_data import IDepthAverageRuleData +from decoimpact.data.api.i_filter_extremes_rule_data import IFilterExtremesRuleData from decoimpact.data.api.i_formula_rule_data import IFormulaRuleData from decoimpact.data.api.i_layer_filter_rule_data import ILayerFilterRuleData from decoimpact.data.api.i_model_data import IModelData @@ -109,6 +111,15 @@ def _create_rule(rule_data: IRuleData) -> IRule: rule_data.input_variables, rule_data.layer_type, ) + elif isinstance(rule_data, IFilterExtremesRuleData): + rule = FilterExtremesRule( + rule_data.name, + rule_data.input_variables, + rule_data.extreme_type, + rule_data.distance, + rule_data.time_scale, + rule_data.mask, + ) elif isinstance(rule_data, ILayerFilterRuleData): rule = LayerFilterRule( rule_data.name, diff --git a/decoimpact/data/api/i_filter_extremes_rule_data.py b/decoimpact/data/api/i_filter_extremes_rule_data.py new file mode 100644 index 00000000..a9b8fd77 --- /dev/null +++ b/decoimpact/data/api/i_filter_extremes_rule_data.py @@ -0,0 +1,45 @@ +# This file is part of D-EcoImpact +# Copyright (C) 2022-2024 Stichting Deltares +# This program is free software distributed under the +# GNU Affero General Public License version 3.0 +# A copy of the GNU Affero General Public License can be found at +# https://github.com/Deltares/D-EcoImpact/blob/main/LICENSE.md +"""Module for IFilterExtremesRuleData interface + +Interfaces: + IFilterExtremesRuleData +""" + +from abc import ABC, abstractmethod +from typing import List + +from decoimpact.data.api.i_rule_data import IRuleData + + +class IFilterExtremesRuleData(IRuleData, ABC): + """Data for a filter extremes rule""" + + @property + @abstractmethod + def input_variables(self) -> List[str]: + """List with input variable name""" + + @property + @abstractmethod + def extreme_type(self) -> str: + """Type of extremes [peaks or throughs]""" + + @property + @abstractmethod + def distance(self) -> int: + """Property for the distance between peaks""" + + @property + @abstractmethod + def time_scale(self) -> str: + """Property for the timescale of the distance between peaks""" + + @property + @abstractmethod + def mask(self) -> bool: + """Property for mask""" diff --git a/decoimpact/data/entities/depth_average_rule_data.py b/decoimpact/data/entities/depth_average_rule_data.py index f3355022..8b6a765d 100644 --- a/decoimpact/data/entities/depth_average_rule_data.py +++ b/decoimpact/data/entities/depth_average_rule_data.py @@ -5,10 +5,10 @@ # A copy of the GNU Affero General Public License can be found at # https://github.com/Deltares/D-EcoImpact/blob/main/LICENSE.md """ -Module for (multiple) ClassificationRule class +Module for (multiple) DepthAverageRule class Classes: - (multiple) ClassificationRuleData + (multiple) DepthAverageRuleData """ diff --git a/decoimpact/data/entities/filter_extremes_rule_data.py b/decoimpact/data/entities/filter_extremes_rule_data.py new file mode 100644 index 00000000..2cffd1c6 --- /dev/null +++ b/decoimpact/data/entities/filter_extremes_rule_data.py @@ -0,0 +1,64 @@ +# This file is part of D-EcoImpact +# Copyright (C) 2022-2024 Stichting Deltares +# This program is free software distributed under the +# GNU Affero General Public License version 3.0 +# A copy of the GNU Affero General Public License can be found at +# https://github.com/Deltares/D-EcoImpact/blob/main/LICENSE.md +""" +Module for FilterExtremesRuleData class + +Classes: + FilterExtremesRuleData + +""" + +from typing import List + +from decoimpact.data.api.i_filter_extremes_rule_data import IFilterExtremesRuleData +from decoimpact.data.entities.rule_data import RuleData + + +class FilterExtremesRuleData(IFilterExtremesRuleData, RuleData): + """Class for storing data related to filter extremes rule""" + + # pylint: disable=too-many-arguments + def __init__( + self, + name: str, + input_variables: List[str], + extreme_type: str, + distance: int, + time_scale: str, + mask: bool, + ): + super().__init__(name) + self._input_variables = input_variables + self._extreme_type = extreme_type + self._distance = distance + self._time_scale = time_scale + self._mask = mask + + @property + def input_variables(self) -> List[str]: + """List with input variables""" + return self._input_variables + + @property + def extreme_type(self) -> str: + """Property for the extremes type""" + return self._extreme_type + + @property + def distance(self) -> int: + """Property for the distance between peaks""" + return self._distance + + @property + def time_scale(self) -> str: + """Property for the timescale of the distance between peaks""" + return self._time_scale + + @property + def mask(self) -> bool: + """Property for mask""" + return self._mask diff --git a/decoimpact/data/parsers/parser_combine_results_rule.py b/decoimpact/data/parsers/parser_combine_results_rule.py index c4dec555..aa4d6fb3 100644 --- a/decoimpact/data/parsers/parser_combine_results_rule.py +++ b/decoimpact/data/parsers/parser_combine_results_rule.py @@ -12,7 +12,7 @@ """ from typing import Any, Dict -from decoimpact.business.entities.rules.multi_array_operation_type import ( +from decoimpact.business.entities.rules.options.multi_array_operation_type import ( MultiArrayOperationType, ) from decoimpact.crosscutting.i_logger import ILogger @@ -54,7 +54,7 @@ def parse_dict(self, dictionary: Dict[str, Any], logger: ILogger) -> IRuleData: return rule_data - def _validate_operation_type(self, operation_type: str): + def _validate_operation_type(self, operation_type: Any): """ Validates if the operation type is well formed (a string) and if it has been implemented.""" diff --git a/decoimpact/data/parsers/parser_filter_extremes_rule.py b/decoimpact/data/parsers/parser_filter_extremes_rule.py new file mode 100644 index 00000000..8ec75020 --- /dev/null +++ b/decoimpact/data/parsers/parser_filter_extremes_rule.py @@ -0,0 +1,75 @@ +# This file is part of D-EcoImpact +# Copyright (C) 2022-2024 Stichting Deltares +# This program is free software distributed under the +# GNU Affero General Public License version 3.0 +# A copy of the GNU Affero General Public License can be found at +# https://github.com/Deltares/D-EcoImpact/blob/main/LICENSE.md +""" +Module for ParserFilterExtremesRule class + +Classes: + ParserFilterExtremesRule +""" +from typing import Any, Dict, List + +from decoimpact.crosscutting.i_logger import ILogger +from decoimpact.data.api.i_rule_data import IRuleData +from decoimpact.data.dictionary_utils import get_dict_element +from decoimpact.data.entities.filter_extremes_rule_data import FilterExtremesRuleData +from decoimpact.data.parsers.i_parser_rule_base import IParserRuleBase +from decoimpact.business.entities.rules.options.options_filter_extreme_rule import ( + ExtremeTypeOptions, +) + + +class ParserFilterExtremesRule(IParserRuleBase): + """Class for creating a ParserFilterExtremesRule""" + + @property + def rule_type_name(self) -> str: + """Type name for the rule""" + return "filter_extremes_rule" + + def parse_dict(self, dictionary: Dict[str, Any], logger: ILogger) -> IRuleData: + """Parses the provided dictionary to a IRuleData + Args: + dictionary (Dict[str, Any]): Dictionary holding the values + for making the rule + Returns: + RuleBase: Rule based on the provided data + """ + name: str = get_dict_element("name", dictionary) + input_variable_names: List[str] = [ + get_dict_element("input_variable", dictionary) + ] + output_variable_name: str = get_dict_element("output_variable", dictionary) + description: str = get_dict_element("description", dictionary, False) or "" + extreme_type: str = get_dict_element("extreme_type", dictionary) + self._validate_extreme_type(extreme_type) + distance: int = get_dict_element("distance", dictionary) or 0 + time_scale: str = get_dict_element("time_scale", dictionary) or "D" + + mask: bool = get_dict_element("mask", dictionary) or False + rule_data = FilterExtremesRuleData( + name, input_variable_names, extreme_type, distance, time_scale, mask + ) + + rule_data.output_variable = output_variable_name + rule_data.description = description + + return rule_data + + def _validate_extreme_type(self, extreme_type: Any): + """ + Validates if the extreme type is well formed (a string) + and has the correct values + """ + if not isinstance(extreme_type, str): + message = f"""Extreme_type must be a string, \ + received: {extreme_type}""" + raise ValueError(message) + if extreme_type.upper() not in dir(ExtremeTypeOptions): + message = ( + f"""Extreme_type must be one of: [{', '.join(ExtremeTypeOptions)}]""" + ) + raise ValueError(message) diff --git a/decoimpact/data/parsers/rule_parsers.py b/decoimpact/data/parsers/rule_parsers.py index 21af2d56..943b3dad 100644 --- a/decoimpact/data/parsers/rule_parsers.py +++ b/decoimpact/data/parsers/rule_parsers.py @@ -16,6 +16,7 @@ from decoimpact.data.parsers.parser_axis_filter_rule import ParserAxisFilterRule from decoimpact.data.parsers.parser_classification_rule import ParserClassificationRule from decoimpact.data.parsers.parser_combine_results_rule import ParserCombineResultsRule +from decoimpact.data.parsers.parser_filter_extremes_rule import ParserFilterExtremesRule from decoimpact.data.parsers.parser_formula_rule import ParserFormulaRule from decoimpact.data.parsers.parser_layer_filter_rule import ParserLayerFilterRule from decoimpact.data.parsers.parser_multiply_rule import ParserMultiplyRule @@ -43,3 +44,4 @@ def rule_parsers() -> Iterator[IParserRuleBase]: yield ParserClassificationRule() yield ParserAxisFilterRule() yield ParserDepthAverageRule() + yield ParserFilterExtremesRule() diff --git a/docs/assets/images/3_result_filter_extremes.png b/docs/assets/images/3_result_filter_extremes.png new file mode 100644 index 00000000..026809c1 Binary files /dev/null and b/docs/assets/images/3_result_filter_extremes.png differ diff --git a/docs/manual/input.md b/docs/manual/input.md index ade420d0..77b3b993 100644 --- a/docs/manual/input.md +++ b/docs/manual/input.md @@ -107,6 +107,7 @@ The output of the following functionalities has been shown for a section of the {% include-markdown "./rules/rolling_statistics_rule.md" %} {% include-markdown "./rules/axis_filter_rule.md" %} {% include-markdown "./rules/depth_average_rule.md" %} +{% include-markdown "./rules/filter_extremes_rule.md" %} ## Including data from another YAML file diff --git a/docs/manual/rules/filter_extremes_rule.md b/docs/manual/rules/filter_extremes_rule.md new file mode 100644 index 00000000..96044a67 --- /dev/null +++ b/docs/manual/rules/filter_extremes_rule.md @@ -0,0 +1,35 @@ +### Filter extremes rule + +``` +FORMAT +- filter_extremes_rule: + name: + description: + input_variable: + output_variable: + extreme_type: troughs or peaks + distance: + time_scale: second, hour, day, month or year + mask: +``` + + +The filter extremes rule allows for temporal filtering of extremes in a dataset, i.e. peaks (local maxima) and troughs (local minima). The input variable can be any dimension, as long as it has a time dimension. If the variable mask = False, the output is a variable with the same shape as the input, but only values where the peaks occur and NaN values where no peak occur. If mask = True the output is a same sized variable with 1 (True) at the peak values and NaN elsewhere. Furthermore the user can add a distance (with timescale) as input to define the minimum distance between two peaks/troughs. This mask can be applied to another layer with the combine rule (operation: multiply). + +Below an example of an input file to use the filter_extremes_rule. + +``` +#EXAMPLE : Determine the peak waterlevel values + - depth_average_rule: + name: test filter extremes + description: test filter extremes + input_variable: water_level + output_variable: water_level_mask + extreme_type: peaks + distance: 12 + time_scale: hour + mask: True +``` +The input above is part of a simple test to calculate the salinity at the peaks and troughs of the waterlevel. The extreme filter rule is first used to get the locations of the peaks and throughs of the water level (mask = True) and then with the combine rule the values of the salinity at these points are calculated. The figure below shows these results, the salinity (blue line) and water level are plotted (orange line). The calculated peaks and troughs are shown in purple and green respectively. This example can be reproduced with an iPython notebook (in D-EcoImpact/scripts/test_extreme_filter.ipynb), in this file is also the input_file.yaml included that is used for the calculation. + +![Example filter extremes rule](../../assets/images/3_result_filter_extremes.png "Example on the result of a filter extremes rule in one cell.") diff --git a/scripts/test_extreme_filter.ipynb b/scripts/test_extreme_filter.ipynb new file mode 100644 index 00000000..b9733c07 --- /dev/null +++ b/scripts/test_extreme_filter.ipynb @@ -0,0 +1,225 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize filter extremes rule\n", + "Small scripting to visualize the result of the filter extremes rule. In this exammple the peaks and troughs of the water level were calculated and used to find the values of the salinity at that moment.\n", + "\n", + "The input_file.yaml that was used for this visualization: \n", + "\n", + "version: 0.3.14\n", + "\n", + "input-data:\n", + " - dataset:\n", + " filename: tests_acceptance/input_nc_files/delft3dfmflow_output_example_DWSM-FM_200m_0004_map.nc\n", + " variable_mapping:\n", + " mesh2d_sa1: \"salinity\"\n", + " mesh2d_s1: \"water_level\"\n", + "\n", + "rules:\n", + " - filter_extremes_rule:\n", + " name: Test filter extremes rule\n", + " description: Testing..\n", + " input_variable: water_level\n", + " output_variable: water_level_peaks_mask\n", + " extreme_type: peaks\n", + " distance: 11\n", + " time_scale: hour\n", + " mask: True\n", + "\n", + " - filter_extremes_rule:\n", + " name: Test filter extremes rule\n", + " description: Testing..\n", + " input_variable: water_level\n", + " output_variable: water_level_peaks\n", + " extreme_type: peaks\n", + " distance: 11\n", + " time_scale: hour\n", + " mask: False\n", + "\n", + " - filter_extremes_rule:\n", + " name: Test filter extremes rule\n", + " description: Testing..\n", + " input_variable: water_level\n", + " output_variable: water_level_troughs\n", + " extreme_type: troughs\n", + " distance: 11\n", + " time_scale: hour\n", + " mask: False\n", + "\n", + " - filter_extremes_rule:\n", + " name: Test filter extremes rule\n", + " description: Testing..\n", + " input_variable: water_level\n", + " output_variable: water_level_troughs_mask\n", + " extreme_type: troughs\n", + " distance: 11\n", + " time_scale: hour\n", + " mask: True\n", + "\n", + " - layer_filter_rule:\n", + " name: Get 8th layer of salinity\n", + " description: get 8th layer of model\n", + " layer_number: 8\n", + " input_variable: salinity\n", + " output_variable: salinity_8\n", + "\n", + " - combine_results_rule:\n", + " name: test combining\n", + " operation: multiply\n", + " input_variables: [\"water_level_peaks_mask\", \"salinity_8\"]\n", + " output_variable: salinity_peaks\n", + "\n", + " - combine_results_rule:\n", + " name: test combining\n", + " operation: multiply\n", + " input_variables: [\"water_level_troughs_mask\", \"salinity_8\"]\n", + " output_variable: salinity_troughs\n", + "\n", + "output-data:\n", + " filename: test_ecotope_calculation.nc\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib\n", + "import xarray as xr\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "ds = xr.open_dataset(\"../data/test_ecotope_calculation.nc\")" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "face = 10\n", + "sal = ds.salinity_8.isel(mesh2d_nFaces=face)\n", + "wl = ds.water_level.isel(mesh2d_nFaces=face)\n", + "sal_peaks = ds.salinity_peaks.isel(mesh2d_nFaces=face)\n", + "sal_troughs = ds.salinity_troughs.isel(mesh2d_nFaces=face)\n", + "wl_peaks = ds.water_level_peaks.isel(mesh2d_nFaces=face)\n", + "wl_troughs = ds.water_level_troughs.isel(mesh2d_nFaces=face)" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "sal.plot(color=\"red\")\n", + "wl.plot(color=\"blue\")\n", + "sal_peaks.plot.line(color=\"purple\", marker=\".\")\n", + "wl_peaks.plot.line(color=\"purple\", marker=\".\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "size = 200\n", + "sal[:size].plot()\n", + "wl[:size].plot()\n", + "sal_peaks[:size].plot.line(color=\"purple\", marker=\".\")\n", + "wl_peaks[:size].plot.line(color=\"purple\", marker=\".\")\n", + "sal_troughs[:size].plot.line(color=\"green\", marker=\".\")\n", + "wl_troughs[:size].plot.line(color=\"green\", marker=\".\")\n", + "plt.vlines(sal_peaks[:size].dropna(dim=\"time\").time, -5, 35, color=\"purple\", alpha=0.2)\n", + "plt.vlines(sal_troughs[:size].dropna(dim=\"time\").time, -5, 35, color=\"green\", alpha=0.2)\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ecoimp", + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/template_input.yaml b/template_input.yaml index 92ff2b80..4e2281ad 100644 --- a/template_input.yaml +++ b/template_input.yaml @@ -68,5 +68,15 @@ rules: input_variable: output_variable: + - filter_extremes_rule: + name: + description: + input_variable: + output_variable: + extreme_type: + distance: + time_scale: + mask: True + output-data: filename: diff --git a/tests/business/entities/rules/test_combine_results_rule.py b/tests/business/entities/rules/test_combine_results_rule.py index 236d93fe..178408be 100644 --- a/tests/business/entities/rules/test_combine_results_rule.py +++ b/tests/business/entities/rules/test_combine_results_rule.py @@ -16,7 +16,7 @@ import xarray as _xr from decoimpact.business.entities.rules.combine_results_rule import CombineResultsRule -from decoimpact.business.entities.rules.multi_array_operation_type import ( +from decoimpact.business.entities.rules.options.multi_array_operation_type import ( MultiArrayOperationType, ) from decoimpact.crosscutting.i_logger import ILogger diff --git a/tests/business/entities/rules/test_filter_extremes_rule.py b/tests/business/entities/rules/test_filter_extremes_rule.py new file mode 100644 index 00000000..351592b0 --- /dev/null +++ b/tests/business/entities/rules/test_filter_extremes_rule.py @@ -0,0 +1,361 @@ +# This file is part of D-EcoImpact +# Copyright (C) 2022-2024 Stichting Deltares +# This program is free software distributed under the +# GNU Affero General Public License version 3.0 +# A copy of the GNU Affero General Public License can be found at +# https://github.com/Deltares/D-EcoImpact/blob/main/LICENSE.md +""" +Tests for RuleBase class +""" + +from typing import List +from unittest.mock import Mock + +import numpy as np +import pytest +import xarray as _xr + +from decoimpact.business.entities.rules.filter_extremes_rule import FilterExtremesRule +from decoimpact.crosscutting.i_logger import ILogger + + +def test_create_filter_extremes_rule_with_defaults(): + """Test creating a filter extremes rule with defaults""" + + # Arrange & Act + rule = FilterExtremesRule("test_rule_name", ["input_var"], "peaks", 5, "hour", True) + + # Assert + assert isinstance(rule, FilterExtremesRule) + assert rule.name == "test_rule_name" + assert rule.description == "" + assert rule.input_variable_names == ["input_var"] + assert rule.extreme_type == "peaks" + assert rule.distance == 5 + assert rule.settings.time_scale == "hour" + assert rule.mask + + +def test_validation_when_not_valid(): + """ + Test an incorrect filter extremes rule validates with error + time_scale is not in TimeOperationSettings + """ + logger = Mock(ILogger) + rule = FilterExtremesRule("test_rule_name", ["input_var"], "peaks", 5, "h", True) + + valid = rule.validate(logger) + assert valid is False + + +def test_validation_when_valid(): + """ + Test a correct filter extremes rule validates without error + time_scale is in TimeOperationSettings + """ + logger = Mock(ILogger) + rule = FilterExtremesRule("test_rule_name", ["input_var"], "peaks", 5, "hour", True) + + valid = rule.validate(logger) + assert valid + + +@pytest.mark.parametrize( + "data_variable, result_data, time_data, mask, distance, time_scale, extreme_type", + [ + # Test 1: check for multiple dimensions! + ( + [ + [ + [1, 0], + [0, 3], + [-1, 0], + [0, 4], + [1, 0], + [2, 5], + [1, 0], + [0, 6], + [-3, 0], + [-4, 7], + [-2, 0], + [-1, 8], + [-3, 0], + [-5, 9], + ] + ], + [ + [ + [np.nan, np.nan], + [np.nan, 3], + [np.nan, np.nan], + [np.nan, 4], + [np.nan, np.nan], + [2, 5], + [np.nan, np.nan], + [np.nan, 6], + [np.nan, np.nan], + [np.nan, 7], + [np.nan, np.nan], + [-1, 8], + [np.nan, np.nan], + [np.nan, np.nan], + ] + ], + [ + np.datetime64("2005-02-25T01:30"), + np.datetime64("2005-02-25T02:30"), + np.datetime64("2005-02-25T03:30"), + np.datetime64("2005-02-25T04:30"), + np.datetime64("2005-02-25T05:30"), + np.datetime64("2005-02-25T06:30"), + np.datetime64("2005-02-25T07:30"), + np.datetime64("2005-02-25T08:30"), + np.datetime64("2005-02-25T09:30"), + np.datetime64("2005-02-25T10:30"), + np.datetime64("2005-02-25T11:30"), + np.datetime64("2005-02-25T12:30"), + np.datetime64("2005-02-25T13:30"), + np.datetime64("2005-02-25T14:30"), + ], + False, + 1, + "hour", + "peaks", + ), + # Test 2: multiple times + ( + [ + [ + [0, 0], + [5, 3], + [0, 5], + [6, 4], + [0, 4], + ], + [ + [0, 0], + [5, 6], + [0, 5], + [0, 7], + [0, 4], + ], + ], + [ + [ + [np.nan, np.nan], + [5, np.nan], + [np.nan, 5], + [6, np.nan], + [np.nan, np.nan], + ], + [ + [np.nan, np.nan], + [5, 6], + [np.nan, np.nan], + [np.nan, 7], + [np.nan, np.nan], + ], + ], + [ + np.datetime64("2005-02-25T01:30"), + np.datetime64("2005-02-25T02:30"), + np.datetime64("2005-02-25T03:30"), + np.datetime64("2005-02-25T04:30"), + np.datetime64("2005-02-25T05:30"), + ], + False, + 1, + "hour", + "peaks", + ), + # Test 3: Maks true + ( + [ + [ + [0, 0], + [5, 3], + [0, 5], + [6, 4], + [0, 4], + ] + ], + [ + [ + [np.nan, np.nan], + [1.0, np.nan], + [np.nan, 1.0], + [1.0, np.nan], + [np.nan, np.nan], + ], + ], + [ + np.datetime64("2005-02-25T01:30"), + np.datetime64("2005-02-25T02:30"), + np.datetime64("2005-02-25T03:30"), + np.datetime64("2005-02-25T04:30"), + np.datetime64("2005-02-25T05:30"), + ], + True, + 1, + "hour", + "peaks", + ), + # Test 4: Different time dimension + ( + [ + [ + [1, 0], + [0, 3], + [-1, 0], + [0, 4], + [1, 0], + [2, 5], + [1, 0], + [0, 6], + [-3, 0], + [-4, 7], + [-2, 0], + [-1, 8], + [-3, 0], + [-5, 9], + ] + ], + [ + [ + [np.nan, np.nan], + [np.nan, np.nan], + [np.nan, np.nan], + [np.nan, 4], + [np.nan, np.nan], + [2, np.nan], + [np.nan, np.nan], + [np.nan, 6], + [np.nan, np.nan], + [np.nan, np.nan], + [np.nan, np.nan], + [-1, 8], + [np.nan, np.nan], + [np.nan, np.nan], + ] + ], + [ + np.datetime64("2005-02-25T01:30"), + np.datetime64("2005-02-25T02:30"), + np.datetime64("2005-02-25T03:30"), + np.datetime64("2005-02-25T04:30"), + np.datetime64("2005-02-25T05:30"), + np.datetime64("2005-02-25T06:30"), + np.datetime64("2005-02-25T07:30"), + np.datetime64("2005-02-25T08:30"), + np.datetime64("2005-02-25T09:30"), + np.datetime64("2005-02-25T10:30"), + np.datetime64("2005-02-25T11:30"), + np.datetime64("2005-02-25T12:30"), + np.datetime64("2005-02-25T13:30"), + np.datetime64("2005-02-25T14:30"), + ], + False, + 3, + "hour", + "peaks", + ), + # Test 5: Test troughs + ( + [ + [ + [1, 0], + [0, 3], + [-1, 0], + [0, 4], + [1, 0], + [2, 5], + [1, 0], + [0, 6], + [-3, 0], + [-4, 7], + [-2, 0], + [-1, 8], + [-3, 0], + [-5, 9], + ] + ], + [ + [ + [np.nan, np.nan], + [np.nan, np.nan], + [-1, 0], + [np.nan, np.nan], + [np.nan, 0], + [np.nan, np.nan], + [np.nan, 0], + [np.nan, np.nan], + [np.nan, 0], + [-4, np.nan], + [np.nan, 0], + [np.nan, np.nan], + [np.nan, 0], + [np.nan, np.nan], + ] + ], + [ + np.datetime64("2005-02-25T01:30"), + np.datetime64("2005-02-25T02:30"), + np.datetime64("2005-02-25T03:30"), + np.datetime64("2005-02-25T04:30"), + np.datetime64("2005-02-25T05:30"), + np.datetime64("2005-02-25T06:30"), + np.datetime64("2005-02-25T07:30"), + np.datetime64("2005-02-25T08:30"), + np.datetime64("2005-02-25T09:30"), + np.datetime64("2005-02-25T10:30"), + np.datetime64("2005-02-25T11:30"), + np.datetime64("2005-02-25T12:30"), + np.datetime64("2005-02-25T13:30"), + np.datetime64("2005-02-25T14:30"), + ], + False, + 1, + "hour", + "troughs", + ), + ], +) +def test_filter_extremes_rule( + data_variable: List[float], + result_data: List[float], + time_data: List[float], + mask: bool, + distance: int, + time_scale: str, + extreme_type: str, +): + """Make sure the calculation of the filter extremes is correct. Including + differing water and bed levels.""" + logger = Mock(ILogger) + rule = FilterExtremesRule( + "test", ["test_var"], extreme_type, distance, time_scale, mask + ) + assert isinstance(rule, FilterExtremesRule) + # Create dataset + ds = _xr.Dataset( + {"test_var": (["dim1", "time", "dim2"], data_variable)}, + coords={ + "time": time_data, + }, + ) + + value_array = ds["test_var"] + + filter_extremes = rule.execute(value_array, logger) + + result_array = _xr.DataArray( + result_data, + dims=["dim1", "time", "dim2"], + coords={ + "time": time_data, + }, + ) + + assert ( + _xr.testing.assert_allclose(filter_extremes, result_array, atol=1e-08) is None + ) diff --git a/tests/data/entities/test_filter_extremes_rule_data.py b/tests/data/entities/test_filter_extremes_rule_data.py new file mode 100644 index 00000000..fcbabc53 --- /dev/null +++ b/tests/data/entities/test_filter_extremes_rule_data.py @@ -0,0 +1,28 @@ +# This file is part of D-EcoImpact +# Copyright (C) 2022-2024 Stichting Deltares +# This program is free software distributed under the +# GNU Affero General Public License version 3.0 +# A copy of the GNU Affero General Public License can be found at +# https://github.com/Deltares/D-EcoImpact/blob/main/LICENSE.md +""" +Tests for FilterExtremesRuleData class +""" + + +from decoimpact.data.api.i_rule_data import IRuleData +from decoimpact.data.entities.filter_extremes_rule_data import FilterExtremesRuleData + + +def test_filter_extremes_rule_data_creation_logic(): + """The FilterExtremesRuleData should parse the provided dictionary + to correctly initialize itself during creation""" + + # Act + data = FilterExtremesRuleData("test_name", "input1", "peaks", 1, "hour", True) + + # Assert + assert isinstance(data, IRuleData) + assert data.input_variables == "input1" + assert data.distance == 1 + assert data.mask == True + assert data.time_scale == "hour" diff --git a/tests/data/parsers/test_parser_combine_results_rule.py b/tests/data/parsers/test_parser_combine_results_rule.py index 0c4d8f8e..57b24a11 100644 --- a/tests/data/parsers/test_parser_combine_results_rule.py +++ b/tests/data/parsers/test_parser_combine_results_rule.py @@ -13,7 +13,7 @@ import pytest from mock import Mock -from decoimpact.business.entities.rules.multi_array_operation_type import ( +from decoimpact.business.entities.rules.options.multi_array_operation_type import ( MultiArrayOperationType, ) from decoimpact.crosscutting.i_logger import ILogger diff --git a/tests/data/parsers/test_parser_filter_extremes_rule.py b/tests/data/parsers/test_parser_filter_extremes_rule.py new file mode 100644 index 00000000..e25e44f9 --- /dev/null +++ b/tests/data/parsers/test_parser_filter_extremes_rule.py @@ -0,0 +1,125 @@ +# This file is part of D-EcoImpact +# Copyright (C) 2022-2024 Stichting Deltares +# This program is free software distributed under the +# GNU Affero General Public License version 3.0 +# A copy of the GNU Affero General Public License can be found at +# https://github.com/Deltares/D-EcoImpact/blob/main/LICENSE.md +""" +Tests for ParserFilterExtremesRule class +""" + +from typing import Any, List +import pytest +from mock import Mock + +from decoimpact.crosscutting.i_logger import ILogger +from decoimpact.data.api.i_rule_data import IRuleData +from decoimpact.data.parsers.i_parser_rule_base import IParserRuleBase +from decoimpact.data.parsers.parser_filter_extremes_rule import ParserFilterExtremesRule + + +def test_parser_filter_extremes_rule_creation_logic(): + """The ParserFilterExtremesRule should parse the provided dictionary + to correctly initialize itself during creation""" + + # Act + data = ParserFilterExtremesRule() + + # Assert + + assert isinstance(data, IParserRuleBase) + assert data.rule_type_name == "filter_extremes_rule" + + +def test_parse_dict_to_rule_data_logic(): + """Test if a correct dictionary is parsed into a RuleData object""" + # Arrange + contents = dict( + { + "name": "testname", + "input_variable": "input", + "output_variable": "output", + "distance": 1, + "time_scale": "hour", + "mask": True, + "extreme_type": "peaks", + } + ) + logger = Mock(ILogger) + # Act + data = ParserFilterExtremesRule() + parsed_dict = data.parse_dict(contents, logger) + + assert isinstance(parsed_dict, IRuleData) + + +def test_parse_wrong_dict_to_rule_data_logic(): + """Test if an incorrect dictionary is not parsed""" + # Arrange + contents = dict( + { + "name": "testname", + "input_variable": "input", + "output_variable": "output", + "time_scale": "hour", + "mask": True, + "extreme_type": "peaks", + } + ) + logger = Mock(ILogger) + + # Act + data = ParserFilterExtremesRule() + + with pytest.raises(AttributeError) as exc_info: + data.parse_dict(contents, logger) + + exception_raised = exc_info.value + + # Assert + expected_message = "Missing element distance" + assert exception_raised.args[0] == expected_message + + +@pytest.mark.parametrize( + "extreme_type, expected_message", + [ + ("peaks", ""), + ("troughs", ""), + ("test", "Extreme_type must be one of: [peaks, troughs]"), + ( + 1, + "Extreme_type must be a string, \ + received: 1", + ), + ], +) +def test_validate_extreme_type(extreme_type: str, expected_message: str): + """Test if a correct dictionary is parsed into a RuleData object""" + # Arrange + contents = dict( + { + "name": "testname", + "input_variable": "input", + "output_variable": "output", + "distance": 1, + "time_scale": "hour", + "mask": True, + "extreme_type": extreme_type, + } + ) + logger = Mock(ILogger) + # Act + data = ParserFilterExtremesRule() + # Act + + if not expected_message: + parsed_dict = data.parse_dict(contents, logger) + assert isinstance(parsed_dict, IRuleData) + else: + with pytest.raises(ValueError) as exc_info: + data.parse_dict(contents, logger=Mock(ILogger)) + exception_raised = exc_info.value + + # Assert + assert exception_raised.args[0] == expected_message diff --git a/tests_acceptance/input_nc_files/delft3dfmflow_output_example_DWSM-FM_200m_0004_map.nc b/tests_acceptance/input_nc_files/delft3dfmflow_output_example_DWSM-FM_200m_0004_map.nc new file mode 100644 index 00000000..e6251fb6 Binary files /dev/null and b/tests_acceptance/input_nc_files/delft3dfmflow_output_example_DWSM-FM_200m_0004_map.nc differ diff --git a/tests_acceptance/input_yaml_files/test19_filter_extremes.yaml b/tests_acceptance/input_yaml_files/test19_filter_extremes.yaml new file mode 100644 index 00000000..a51c4831 --- /dev/null +++ b/tests_acceptance/input_yaml_files/test19_filter_extremes.yaml @@ -0,0 +1,70 @@ +version: 0.0.0 + +input-data: + - dataset: + filename: ./tests_acceptance/input_nc_files/delft3dfmflow_output_example_DWSM-FM_200m_0004_map.nc + variable_mapping: + mesh2d_sa1: "salinity" + +rules: + - filter_extremes_rule: + name: Test filter extremes rule + description: Testing.. + input_variable: mesh2d_s1 + output_variable: water_level_peaks_mask + extreme_type: peaks + distance: 11 + time_scale: hour + mask: True + + - filter_extremes_rule: + name: Test filter extremes rule + description: Testing.. + input_variable: mesh2d_s1 + output_variable: water_level_peaks + extreme_type: peaks + distance: 11 + time_scale: hour + mask: False + + - filter_extremes_rule: + name: Test filter extremes rule + description: Testing.. + input_variable: mesh2d_s1 + output_variable: water_level_troughs + extreme_type: troughs + distance: 11 + time_scale: hour + mask: False + + - filter_extremes_rule: + name: Test filter extremes rule + description: Testing.. + input_variable: mesh2d_s1 + output_variable: water_level_troughs_mask + extreme_type: troughs + distance: 11 + time_scale: hour + mask: True + + - layer_filter_rule: + name: Get 8th layer of salinity + description: get 8th layer of model + layer_number: 8 + input_variable: salinity + output_variable: salinity_8 + + - combine_results_rule: + name: test combining + operation: multiply + input_variables: ["water_level_peaks_mask", "salinity_8"] + output_variable: salinity_peaks + + - combine_results_rule: + name: test combining + operation: multiply + input_variables: ["water_level_troughs_mask", "salinity_8"] + output_variable: salinity_troughs + +output-data: + filename: ./tests_acceptance/output_nc_files/test19_filter_extremes.nc diff --git a/tests_acceptance/reference_nc_files/test19_filter_extremes.nc b/tests_acceptance/reference_nc_files/test19_filter_extremes.nc new file mode 100644 index 00000000..ed4f4798 Binary files /dev/null and b/tests_acceptance/reference_nc_files/test19_filter_extremes.nc differ