Feature/dei 229 depth averaged rules sigma models

decoimpact/business/entities/rule_based_model.py

@@ -103,6 +103,7 @@ def initialize(self, logger: ILogger) -> None:
         self._output_dataset = _du.create_composed_dataset(
             self._input_datasets, self._make_output_variables_list(), self._mappings
         )
+
         self._rule_processor = RuleProcessor(self._rules, self._output_dataset)
 
         if not self._rule_processor.initialize(logger):
@@ -139,10 +140,11 @@ def _make_output_variables_list(self) -> list:
 
         for dataset in self._input_datasets:
             var_list = _du.get_dummy_and_dependent_var_list(dataset)
+            dummy_variable = _du.get_dummy_variable_in_ugrid(dataset)
 
         mapping_keys = list((self._mappings or {}).keys())
         rule_names = [rule.name for rule in self._rules]
-        all_inputs = self._get_direct_rule_inputs(rule_names)
+        all_inputs = self._get_direct_rule_inputs(rule_names, dummy_variable[0])
         all_input_variables = _lu.flatten_list(list(all_inputs.values()))
 
         all_vars = var_list + mapping_keys + all_input_variables
@@ -191,7 +193,7 @@ def _validate_mappings(self, mappings: dict[str, str], logger: ILogger) -> bool:
 
         rule_names = [rule.name for rule in self._rules]
 
-        rule_inputs = self._get_direct_rule_inputs(rule_names)
+        rule_inputs = self._get_direct_rule_inputs(rule_names, "")
 
         # check for missing rule inputs
         for rule_name, rule_input in rule_inputs.items():
@@ -207,16 +209,20 @@ def _validate_mappings(self, mappings: dict[str, str], logger: ILogger) -> bool:
 
         return valid
 
-    def _get_direct_rule_inputs(self, rule_names) -> Dict[str, List[str]]:
+    def _get_direct_rule_inputs(self, rule_names, dummy_variable) -> Dict[str, List[str]]:
         """Gets the input variables directly needed by rules from
         input datasets.
 
+        Extend variable names specific for Delft3D based on dummy variable name.
+
         Returns:
             Dict[str, List[str]]
         """
         rule_input_vars = [rule.input_variable_names for rule in self._rules]
         rule_output_vars = [rule.output_variable_name for rule in self._rules]
 
+        rule_input_vars = [list(_du.extend_to_full_name(rule_input_vars[0], dummy_variable))]
+
         needed_input_per_rule = {}
         for index, inputs_per_rule in enumerate(rule_input_vars):
             needed_input_per_rule[rule_names[index]] = _lu.items_not_in(

decoimpact/business/entities/rule_processor.py

@@ -16,9 +16,9 @@
 
 import numpy as _np
 import xarray as _xr
+
 import decoimpact.business.utils.dataset_utils as _du
 import decoimpact.business.utils.list_utils as _lu
-
 from decoimpact.business.entities.rules.i_array_based_rule import IArrayBasedRule
 from decoimpact.business.entities.rules.i_cell_based_rule import ICellBasedRule
 from decoimpact.business.entities.rules.i_multi_array_based_rule import (
@@ -387,7 +387,7 @@ def _expand_dimensions_of_variable(
         str_dims_broadcasted = ",".join(dims_diff)
         logger.log_info(
             f"""Variable {var_orig.name} will be expanded to the following \
-dimensions: {str_dims_broadcasted} """
+            dimensions: {str_dims_broadcasted} """
         )
 
         # perform the broadcast

decoimpact/business/entities/rules/depth_average_rule.py

@@ -18,12 +18,13 @@
     IMultiArrayBasedRule,
 )
 from decoimpact.business.entities.rules.rule_base import RuleBase
-from decoimpact.crosscutting.i_logger import ILogger
+from decoimpact.business.utils.dataset_utils import get_dummy_variable_in_ugrid
 from decoimpact.crosscutting.delft3d_specific_data import (
-    INTERFACES_NAME,
-    BED_LEVEL_NAME,
-    WATER_LEVEL_NAME,
+    BED_LEVEL_SUFFIX,
+    INTERFACES_Z_SUFFIX,
+    WATER_LEVEL_SUFFIX,
 )
+from decoimpact.crosscutting.i_logger import ILogger
 
 
 class DepthAverageRule(RuleBase, IMultiArrayBasedRule):
@@ -46,10 +47,14 @@ def execute(
         # just used the first value.
         variables = next(iter(value_arrays.values()))
 
+        #dummy_var = get_dummy_variable_in_ugrid(self.dataset)
+        dummy_var = "mesh2d"
+        print("Q",dummy_var)
+
         # depths interfaces = borders of the layers in terms of depth
-        depths_interfaces = value_arrays[INTERFACES_NAME]
-        water_level_values = value_arrays[WATER_LEVEL_NAME]
-        bed_level_values = value_arrays[BED_LEVEL_NAME]
+        depths_interfaces = value_arrays[dummy_var + INTERFACES_Z_SUFFIX]
+        water_level_values = value_arrays[dummy_var + WATER_LEVEL_SUFFIX]
+        bed_level_values = value_arrays[dummy_var + BED_LEVEL_SUFFIX]
 
         # Get the dimension names for the interfaces and for the layers
         dim_interfaces_name = list(depths_interfaces.dims)[0]

decoimpact/business/entities/rules/rule_base.py

@@ -53,6 +53,11 @@ def input_variable_names(self) -> List[str]:
         """Name of the input variable"""
         return self._input_variable_names
 
+    @input_variable_names.setter
+    def input_variable_names(self, input_variable_names: str):
+        """Name of the input variables"""
+        self._input_variable_names = input_variable_names
+
     @property
     def output_variable_name(self) -> str:
         """Name of the output variable"""

decoimpact/business/utils/dataset_utils.py

@@ -11,6 +11,7 @@
 import xarray as _xr
 
 import decoimpact.business.utils.list_utils as _lu
+from decoimpact.crosscutting.delft3d_specific_data import delftd3_specific_names
 from decoimpact.crosscutting.i_logger import ILogger
 
 
@@ -283,7 +284,11 @@ def create_composed_dataset(
         _xr.Dataset: composed dataset (with selected variables)
     """
     merged_dataset = merge_list_of_datasets(input_datasets)
-
+    dummy_variable = get_dummy_variable_in_ugrid(merged_dataset)[0]
+    variables_to_use = extend_to_full_name(
+        variables_to_use,
+        dummy_variable
+    )
     cleaned_dataset = remove_all_variables_except(merged_dataset, variables_to_use)
 
     if mapping is None or len(mapping) == 0:
@@ -353,3 +358,24 @@ def reduce_dataset_for_writing(
 
     dataset = remove_all_variables_except(dataset, save_only_variables)
     return dataset
+
+
+def extend_to_full_name(
+        variables: List[str],
+        dummy_variable: str
+) -> list[str]:
+    """Extend suffix names to full variables names by prepending the dummy
+    variable name.
+
+    Args:
+        variables (list[str]): List of variable names
+        dummy_variable (str): name of dummy variable
+
+    Returns:
+        list[str]: list of the extended variable names
+    """
+    for i in range(0, len(variables)):
+        if variables[i] in delftd3_specific_names:
+            variables[i] = dummy_variable + variables[i]
+
+    return variables

decoimpact/crosscutting/delft3d_specific_data.py

@@ -8,6 +8,15 @@
 Configuration file for hardcoded delft3d variable names
 """
 
-INTERFACES_NAME = "mesh2d_interface_z"
-BED_LEVEL_NAME = "mesh2d_flowelem_bl"
-WATER_LEVEL_NAME = "mesh2d_s1"
+INTERFACES_Z_SUFFIX = "_interface_z"
+INTERFACES_SIGMA_SUFFIX = "_interface_sigma"
+BED_LEVEL_SUFFIX = "_flowelem_bl"
+WATER_LEVEL_SUFFIX = "_s1"
+
+
+delftd3_specific_names = [
+    INTERFACES_Z_SUFFIX,
+    INTERFACES_SIGMA_SUFFIX,
+    BED_LEVEL_SUFFIX,
+    WATER_LEVEL_SUFFIX
+    ]

decoimpact/data/parsers/parser_depth_average_rule.py

@@ -10,18 +10,20 @@
 Classes:
     ParserDepthAverageRule
 """
+from re import I
 from typing import Any, Dict, List
 
+from decoimpact.business.utils.dataset_utils import get_dummy_variable_in_ugrid
+from decoimpact.crosscutting.delft3d_specific_data import (
+    BED_LEVEL_SUFFIX,
+    INTERFACES_Z_SUFFIX,
+    WATER_LEVEL_SUFFIX,
+)
 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.depth_average_rule_data import DepthAverageRuleData
 from decoimpact.data.parsers.i_parser_rule_base import IParserRuleBase
-from decoimpact.crosscutting.delft3d_specific_data import (
-    INTERFACES_NAME,
-    BED_LEVEL_NAME,
-    WATER_LEVEL_NAME,
-)
 
 
 class ParserDepthAverageRule(IParserRuleBase):
@@ -43,10 +45,11 @@ def parse_dict(self, dictionary: Dict[str, Any], logger: ILogger) -> IRuleData:
         name: str = get_dict_element("name", dictionary)
         input_variable_names: List[str] = [
             get_dict_element("input_variable", dictionary),
-            INTERFACES_NAME,
-            WATER_LEVEL_NAME,
-            BED_LEVEL_NAME,
+            INTERFACES_Z_SUFFIX,
+            WATER_LEVEL_SUFFIX,
+            BED_LEVEL_SUFFIX,
         ]
+
         output_variable_name: str = get_dict_element("output_variable", dictionary)
         description: str = get_dict_element("description", dictionary, False) or ""