Prototype fields factory

model/common/src/icon4py/model/common/decomposition/definitions.py

@@ -201,7 +201,7 @@ def get_runtype(with_mpi: bool = False) -> RunType:
 
 
 @functools.singledispatch
-def get_processor_properties(runtime) -> ProcessProperties:
+def get_processor_properties(runtime: RunType) -> ProcessProperties:
     raise TypeError(f"Cannot define ProcessProperties for ({type(runtime)})")
 
 

model/common/src/icon4py/model/common/exceptions.py

@@ -11,9 +11,14 @@ class InvalidConfigError(Exception):
     pass
 
 
+class IncompleteSetupError(Exception):
+    def __init__(self, msg):
+        super().__init__(f"{msg}")
+
+
 class IncompleteStateError(Exception):
     def __init__(self, field_name):
-        super().__init__(f"Field '{field_name}' is missing in state.")
+        super().__init__(f"Field '{field_name}' is missing.")
 
 
 class IconGridError(RuntimeError):

model/common/src/icon4py/model/common/grid/icon.py

@@ -168,7 +168,7 @@ def n_shift(self):
     def lvert_nest(self):
         return True if self.config.lvertnest else False
 
-    def start_index(self, domain: h_grid.Domain):
+    def start_index(self, domain: h_grid.Domain) -> gtx.int32:
         """
         Use to specify lower end of domains of a field for field_operators.
 
@@ -177,10 +177,11 @@ def start_index(self, domain: h_grid.Domain):
         """
         if domain.local:
             # special treatment because this value is not set properly in the underlying data.
-            return 0
-        return self._start_indices[domain.dim][domain()].item()
+            return gtx.int32(0)
+        # ndarray.item() does not respect the dtype of the array, returns a copy of the value _as the default python type_
+        return gtx.int32(self._start_indices[domain.dim][domain()])
 
-    def end_index(self, domain: h_grid.Domain):
+    def end_index(self, domain: h_grid.Domain) -> gtx.int32:
         """
         Use to specify upper end of domains of a field for field_operators.
 
@@ -189,5 +190,6 @@ def end_index(self, domain: h_grid.Domain):
         """
         if domain.zone == h_grid.Zone.INTERIOR and not self.limited_area:
             # special treatment because this value is not set properly in the underlying data, for a global grid
-            return self.size[domain.dim]
-        return self._end_indices[domain.dim][domain()].item()
+            return gtx.int32(self.size[domain.dim])
+        # ndarray.item() does not respect the dtype of the array, returns a copy of the value _as the default python builtin type_
+        return gtx.int32(self._end_indices[domain.dim][domain()].item())

model/common/src/icon4py/model/common/grid/vertical.py

@@ -16,6 +16,7 @@
 
 import gt4py.next as gtx
 
+import icon4py.model.common.states.metadata as data
 from icon4py.model.common import dimension as dims, exceptions, field_type_aliases as fa
 from icon4py.model.common.settings import xp
 
@@ -58,6 +59,14 @@ def _validate(self):
             ), f"{self.marker} needs to be combined with positive offest, but offset = {self.offset}"
 
 
+def domain(dim: gtx.Dimension):
+    def _domain(marker: Zone):
+        assert dim.kind == gtx.DimensionKind.VERTICAL, "Only vertical dimensions are supported"
+        return Domain(dim, marker)
+
+    return _domain
+
+
 @dataclasses.dataclass(frozen=True)
 class VerticalGridConfig:
     """
@@ -159,19 +168,17 @@ def __str__(self) -> str:
         return "\n".join(vertical_params_properties)
 
     @property
-    def metadata_interface_physical_height(self) -> dict:
-        return dict(
-            standard_name="model_interface_height",
-            long_name="height value of half levels without topography",
-            units="m",
-            positive="up",
-            icon_var_name="vct_a",
-        )
+    def metadata_interface_physical_height(self):
+        return data.attrs["model_interface_height"]
+
+    @property
+    def num_levels(self):
+        return self.config.num_levels
 
     def index(self, domain: Domain) -> gtx.int32:
         match domain.marker:
             case Zone.TOP:
-                index = gtx.int32(0)
+                index = 0
             case Zone.BOTTOM:
                 index = self._bottom_level(domain)
             case Zone.MOIST:
@@ -187,10 +194,10 @@ def index(self, domain: Domain) -> gtx.int32:
         assert (
             0 <= index <= self._bottom_level(domain)
         ), f"vertical index {index} outside of grid levels for {domain.dim}"
-        return index
+        return gtx.int32(index)
 
-    def _bottom_level(self, domain: Domain) -> gtx.int32:
-        return gtx.int32(self.size(domain.dim))
+    def _bottom_level(self, domain: Domain) -> int:
+        return self.size(domain.dim)
 
     @property
     def interface_physical_height(self) -> fa.KField[float]:

model/common/src/icon4py/model/common/metrics/compute_wgtfacq.py

@@ -6,22 +6,22 @@
 # Please, refer to the LICENSE file in the root directory.
 # SPDX-License-Identifier: BSD-3-Clause
 
-import numpy as np
+from icon4py.model.common.settings import xp
 
 
 def _compute_z1_z2_z3(
-    z_ifc: np.ndarray, i1: int, i2: int, i3: int, i4: int
-) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    z_ifc: xp.ndarray, i1: int, i2: int, i3: int, i4: int
+) -> tuple[xp.ndarray, xp.ndarray, xp.ndarray]:
     z1 = 0.5 * (z_ifc[:, i2] - z_ifc[:, i1])
     z2 = 0.5 * (z_ifc[:, i2] + z_ifc[:, i3]) - z_ifc[:, i1]
     z3 = 0.5 * (z_ifc[:, i3] + z_ifc[:, i4]) - z_ifc[:, i1]
     return z1, z2, z3
 
 
 def compute_wgtfacq_c_dsl(
-    z_ifc: np.ndarray,
+    z_ifc: xp.ndarray,
     nlev: int,
-) -> np.ndarray:
+) -> xp.ndarray:
     """
     Compute weighting factor for quadratic interpolation to surface.
 
@@ -31,8 +31,8 @@ def compute_wgtfacq_c_dsl(
     Returns:
     Field[CellDim, KDim] (full levels)
     """
-    wgtfacq_c = np.zeros((z_ifc.shape[0], nlev + 1))
-    wgtfacq_c_dsl = np.zeros((z_ifc.shape[0], nlev))
+    wgtfacq_c = xp.zeros((z_ifc.shape[0], nlev + 1))
+    wgtfacq_c_dsl = xp.zeros((z_ifc.shape[0], nlev))
     z1, z2, z3 = _compute_z1_z2_z3(z_ifc, nlev, nlev - 1, nlev - 2, nlev - 3)
 
     wgtfacq_c[:, 2] = z1 * z2 / (z2 - z3) / (z1 - z3)
@@ -47,10 +47,10 @@ def compute_wgtfacq_c_dsl(
 
 
 def compute_wgtfacq_e_dsl(
-    e2c,
-    z_ifc: np.ndarray,
-    c_lin_e: np.ndarray,
-    wgtfacq_c_dsl: np.ndarray,
+    e2c: xp.ndarray,
+    z_ifc: xp.ndarray,
+    c_lin_e: xp.ndarray,
+    wgtfacq_c_dsl: xp.ndarray,
     n_edges: int,
     nlev: int,
 ):
@@ -67,8 +67,8 @@ def compute_wgtfacq_e_dsl(
     Returns:
     Field[EdgeDim, KDim] (full levels)
     """
-    wgtfacq_e_dsl = np.zeros(shape=(n_edges, nlev + 1))
-    z_aux_c = np.zeros((z_ifc.shape[0], 6))
+    wgtfacq_e_dsl = xp.zeros(shape=(n_edges, nlev + 1))
+    z_aux_c = xp.zeros((z_ifc.shape[0], 6))
     z1, z2, z3 = _compute_z1_z2_z3(z_ifc, nlev, nlev - 1, nlev - 2, nlev - 3)
     z_aux_c[:, 2] = z1 * z2 / (z2 - z3) / (z1 - z3)
     z_aux_c[:, 1] = (z1 - wgtfacq_c_dsl[:, nlev - 3] * (z1 - z3)) / (z1 - z2)
@@ -79,8 +79,8 @@ def compute_wgtfacq_e_dsl(
     z_aux_c[:, 4] = (z1 - z_aux_c[:, 5] * (z1 - z3)) / (z1 - z2)
     z_aux_c[:, 3] = 1.0 - (z_aux_c[:, 4] + z_aux_c[:, 5])
 
-    c_lin_e = c_lin_e[:, :, np.newaxis]
-    z_aux_e = np.sum(c_lin_e * z_aux_c[e2c], axis=1)
+    c_lin_e = c_lin_e[:, :, xp.newaxis]
+    z_aux_e = xp.sum(c_lin_e * z_aux_c[e2c], axis=1)
 
     wgtfacq_e_dsl[:, nlev] = z_aux_e[:, 0]
     wgtfacq_e_dsl[:, nlev - 1] = z_aux_e[:, 1]

model/common/src/icon4py/model/common/metrics/metric_fields.py

@@ -28,7 +28,7 @@
     where,
 )
 
-from icon4py.model.common import dimension as dims, field_type_aliases as fa
+from icon4py.model.common import dimension as dims, field_type_aliases as fa, settings
 from icon4py.model.common.dimension import (
     C2E,
     C2E2C,
@@ -61,7 +61,7 @@ class MetricsConfig:
     exner_expol: Final[wpfloat] = 0.3333333333333
 
 
-@program(grid_type=GridType.UNSTRUCTURED)
+@program(grid_type=GridType.UNSTRUCTURED, backend=settings.backend)
 def compute_z_mc(
     z_ifc: fa.CellKField[wpfloat],
     z_mc: fa.CellKField[wpfloat],
@@ -109,7 +109,7 @@ def _compute_ddqz_z_half(
     return ddqz_z_half
 
 
-@program(grid_type=GridType.UNSTRUCTURED, backend=None)
+@program(grid_type=GridType.UNSTRUCTURED, backend=settings.backend)
 def compute_ddqz_z_half(
     z_ifc: fa.CellKField[wpfloat],
     z_mc: fa.CellKField[wpfloat],

model/common/src/icon4py/model/common/metrics/metrics_factory.py

@@ -0,0 +1,68 @@
+# ICON4Py - ICON inspired code in Python and GT4Py
+#
+# Copyright (c) 2022-2024, ETH Zurich and MeteoSwiss
+# All rights reserved.
+#
+# Please, refer to the LICENSE file in the root directory.
+# SPDX-License-Identifier: BSD-3-Clause
+
+import pathlib
+
+import icon4py.model.common.states.factory as factory
+from icon4py.model.common import dimension as dims
+from icon4py.model.common.decomposition import definitions as decomposition
+from icon4py.model.common.grid import horizontal
+from icon4py.model.common.metrics import metric_fields as mf
+from icon4py.model.common.test_utils import datatest_utils as dt_utils, serialbox_utils as sb
+
+
+# we need to register a couple of fields from the serializer. Those should get replaced one by one.
+
+dt_utils.TEST_DATA_ROOT = pathlib.Path(__file__).parent / "testdata"
+properties = decomposition.get_processor_properties(decomposition.get_runtype(with_mpi=False))
+path = dt_utils.get_ranked_data_path(dt_utils.SERIALIZED_DATA_PATH, properties)
+
+data_provider = sb.IconSerialDataProvider(
+    "icon_pydycore", str(path.absolute()), False, mpi_rank=properties.rank
+)
+
+# z_ifc (computable from vertical grid for model without topography)
+metrics_savepoint = data_provider.from_metrics_savepoint()
+
+# interpolation fields also for now passing as precomputed fields
+interpolation_savepoint = data_provider.from_interpolation_savepoint()
+# can get geometry fields as pre computed fields from the grid_savepoint
+grid_savepoint = data_provider.from_savepoint_grid()
+#######
+
+# start build up factory:
+
+
+interface_model_height = metrics_savepoint.z_ifc()
+c_lin_e = interpolation_savepoint.c_lin_e()
+
+fields_factory = factory.FieldsFactory()
+
+# used for vertical domain below: should go away once vertical grid provids start_index and end_index like interface
+grid = grid_savepoint.global_grid_params
+
+fields_factory.register_provider(
+    factory.PrecomputedFieldProvider(
+        {
+            "height_on_interface_levels": interface_model_height,
+            "cell_to_edge_interpolation_coefficient": c_lin_e,
+        }
+    )
+)
+height_provider = factory.ProgramFieldProvider(
+    func=mf.compute_z_mc,
+    domain={
+        dims.CellDim: (
+            horizontal.HorizontalMarkerIndex.local(dims.CellDim),
+            horizontal.HorizontalMarkerIndex.end(dims.CellDim),
+        ),
+        dims.KDim: (0, grid.num_levels),
+    },
+    fields={"z_mc": "height"},
+    deps={"z_ifc": "height_on_interface_levels"},
+)