HydPy 6.2.dev1__cp313-cp313-win_amd64.whl

hydpy/cythons/configutils.pxd

@@ -0,0 +1,8 @@
+"""This module defines the Cython declarations related to module
+|configutils|.
+"""
+
+cdef class Config(object):
+
+    cdef public double _abs_error_max
+    cdef public double _rel_dt_min

hydpy/cythons/configutils.pyi

@@ -0,0 +1,5 @@
+# pylint: disable=missing-module-docstring, missing-class-docstring
+
+class Config:
+    _abs_error_max: float
+    _rel_dt_min: float

hydpy/cythons/configutils.pyx

@@ -0,0 +1,110 @@
+"""This Cython module implements global configuration data for numerical
+tool, which must be available at Cython speed during simulations.
+
+All configuration data is available via attribute `config` of module |pub|.
+
+Many numerical integration algorithms provide error estimates.  An
+integration result is only accepted, if the associated error estimate
+is lower than a given threshold value.
+
+The default value is:
+
+>>> from hydpy.cythons.configutils import Config
+>>> config = Config()
+>>> from hydpy import round_
+>>> round_(config.abs_error_max)
+0.01
+
+You can pass larger value, but note that too large tolerances as the
+following would possible lead to poor simulation results:
+
+>>> config.abs_error_max = 1e3
+>>> round_(config.abs_error_max)
+1000.0
+
+Tolerances lower than zero or equal zero cannot be met and are thus
+forbidden:
+
+>>> config.abs_error_max = 0.
+Traceback (most recent call last):
+...
+ValueError: The numerical tolerance value `abs_error_max` must be larger than zero, but the value `0.0` was given.
+
+Under some circumstances, numerical integration algorithms might not
+be able to achieve sufficient accuracy with reasonable effort.  To
+prevent model simulations from becoming too long, one can restrict
+the smallest time step, with which an outer time step is allowed to
+be solved...
+
+The default value is:
+
+>>> round_(config.rel_dt_min)
+0.001
+
+You can pass larger value, but note that too large step sizes as the
+following would possible result in poor simulation results:
+
+>>> config.rel_dt_min = 1.
+>>> round_(config.rel_dt_min)
+1.0
+
+On the other hand, too small step sizes might result in too long
+simulation times:
+
+>>> config.rel_dt_min = 0.
+>>> round_(config.rel_dt_min)
+0.0
+
+Tolerances lower than zero or larger than one do not make sense and
+are thus forbidden:
+
+>>> config.rel_dt_min = 1.1
+Traceback (most recent call last):
+...
+ValueError: The smallest integration time step `_rel_dt_min` must not be smaller than zero or larger than one, but the value `1.1` was given.
+
+"""
+
+import cython
+
+@cython.final
+cdef class Config(object):
+
+    def __init__(self):
+        self._abs_error_max = 1e-2
+        self._rel_dt_min = 1e-3
+
+    def _get_abs_error_max(self):
+        """Numerical error tolerance."""
+        return self._abs_error_max
+
+    def _set_abs_error_max(self, value):
+        value = float(value)
+        if value <= 0.:
+            raise ValueError(
+                f"The numerical tolerance value `abs_error_max` must be "
+                f"larger than zero, but the value `{value}` was given."
+            )
+        else:
+            self._abs_error_max = value
+
+    abs_error_max = property(_get_abs_error_max, _set_abs_error_max)
+
+
+    def _get_rel_dt_min(self):
+        """Smallest numerical step size."""
+        return self._rel_dt_min
+
+    def _set_rel_dt_min(self, value):
+        value = float(value)
+        if (value < 0.) or (value > 1.):
+            raise ValueError(
+                f"The smallest integration time step `_rel_dt_min` must not be smaller "
+                f"than zero or larger than one, but the value `{value}` was given."
+            )
+        else:
+            self._rel_dt_min = value
+
+    rel_dt_min = property(_get_rel_dt_min, _set_rel_dt_min)
+
+

hydpy/cythons/interfaceutils.pxd

@@ -0,0 +1,22 @@
+"""This module implements only the interface base class required to support casting to
+specific subclasses in Cython."""
+
+from cpython cimport PyObject
+cimport numpy
+
+
+cdef class BaseInterface:
+
+    cdef public int typeid
+    cdef public int idx_sim
+
+    cdef void reset_reuseflags(self) noexcept nogil
+    cdef void load_data(self, int idx) noexcept nogil
+    cdef void save_data(self, int idx) noexcept nogil
+
+
+cdef class SubmodelsProperty:
+
+    cdef int number
+    cdef int[:] typeids
+    cdef PyObject **submodels

hydpy/cythons/interfaceutils.pyi

@@ -0,0 +1,15 @@
+# pylint: disable=missing-docstring, unused-argument
+
+from hydpy.core.typingtools import *
+
+class BaseInterface:
+    def reset_reuseflags(self) -> None: ...
+    def load_data(self, idx: int) -> None: ...
+    def save_data(self, idx: int) -> None: ...
+
+class SubmodelsProperty:
+    def set_number(self, number: int) -> None: ...
+    def put_submodel(
+        self, submodel: CyModelProtocol | None, typeid: int, position: int
+    ) -> None: ...
+    def append_submodel(self, submodel: CyModelProtocol, typeid: int) -> None: ...

hydpy/cythons/interfaceutils.pyx

@@ -0,0 +1,73 @@
+"""This module implements only the interface base class required to support casting to
+specific subclasses in Cython."""
+
+import numpy
+
+from cpython cimport Py_DECREF
+from libc.stdlib cimport free, malloc, realloc
+cimport cython
+
+from hydpy import config
+
+
+cdef class BaseInterface:
+
+    cdef void reset_reuseflags(self) noexcept nogil:
+        pass
+
+    cdef void load_data(self, int idx) noexcept nogil:
+        pass
+
+    cdef void save_data(self, int idx) noexcept nogil:
+        pass
+
+
+cdef class SubmodelsProperty:
+
+    def __init__(self) -> None:
+        self.set_number(0)
+
+    def _get_number(self) -> int:
+        return self.number
+
+    def set_number(self, int number) -> None:
+        assert number >= 0
+        free(self.submodels)
+        self.number = number
+        self.typeids = numpy.zeros(number, dtype=config.NP_INT)
+        self.submodels = <PyObject **>malloc(
+            number * cython.sizeof(cython.pointer(PyObject))
+        )
+        for i in range(number):
+            self.submodels[i] = <PyObject*>None
+
+    def _get_typeid(self, int position) -> int:
+        assert 0 <= position < self.number
+        return self.typeids[position]
+
+    def _get_submodel(self, int position):
+        assert 0 <= position < self.number
+        submodel = <object>self.submodels[position]
+        Py_DECREF(submodel)
+        return submodel
+
+    def put_submodel(self, submodel, int typeid, int position) -> None:
+        assert 0 <= position < self.number
+        self.typeids[position] = typeid
+        self.submodels[position] = <PyObject*>submodel
+
+    def append_submodel(self, submodel, int typeid) -> None:
+        self.number += 1
+        if self.number > 1:
+            typeids = numpy.asarray(self.typeids).copy()
+        self.typeids = numpy.zeros(self.number, dtype=config.NP_INT)
+        for i in range(self.number - 1):
+            self.typeids[i] = typeids[i]
+        self.typeids[self.number - 1] = typeid
+        self.submodels = <PyObject **>realloc(
+            self.submodels, self.number * cython.sizeof(cython.pointer(PyObject))
+        )
+        self.submodels[self.number - 1] = <PyObject*>submodel
+
+    def __dealloc__(self) -> None:
+        free(self.submodels)

hydpy/cythons/interputils.pxd

@@ -0,0 +1,33 @@
+"""This module defines the Cython declarations related to module |interptools|."""
+
+from cpython cimport PyObject
+
+cimport numpy
+
+
+cdef class SimpleInterpolator:
+
+    cdef public int nmb_inputs
+    cdef public int nmb_outputs
+    cdef PyObject *algorithm
+    cdef public int algorithm_type
+    cdef public double[:] inputs
+    cdef public double[:] outputs
+    cdef public double[:] output_derivatives
+
+    cpdef inline void calculate_values(self) noexcept nogil
+    cpdef inline void calculate_derivatives(self, int idx_input) noexcept nogil
+
+
+cdef class SeasonalInterpolator(object):
+
+    cdef public int nmb_inputs
+    cdef public int nmb_outputs
+    cdef public int nmb_algorithms
+    cdef public int[:] algorithm_types
+    cdef PyObject **algorithms
+    cdef public double[:, :] ratios
+    cdef public double[:] inputs
+    cdef public double[:] outputs
+
+    cpdef inline void calculate_values(self, int idx_season) noexcept nogil

hydpy/cythons/interputils.pyi

@@ -0,0 +1,32 @@
+# pylint: disable=missing-docstring, unused-argument
+
+from hydpy.auxs.interptools import InterpAlgorithm
+from hydpy.core.typingtools import *
+
+if TYPE_CHECKING:
+    from hydpy.cythons.annutils import ANN
+    from hydpy.cythons.ppolyutils import PPoly
+else:
+    from hydpy.cythons.autogen.annutils import ANN
+    from hydpy.cythons.autogen.ppolyutils import PPoly
+
+class SimpleInterpolator:
+    nmb_inputs: int
+    nmb_outputs: int
+    algorithm: ANN | PPoly
+    inputs: VectorFloat
+    outputs: VectorFloat
+    def __init__(self, algorithm: InterpAlgorithm) -> None: ...
+    def calculate_values(self) -> None: ...
+    def calculate_derivatives(self, idx: int, /) -> None: ...
+
+class SeasonalInterpolator:
+    nmb_inputs: int
+    nmb_outputs: int
+    nmb_algorithms: int
+    algorithms: tuple[ANN | PPoly, ...]
+    ratios: MatrixFloat
+    inputs: VectorFloat
+    outputs: VectorFloat
+    def __init__(self, algorithms: Sequence[InterpAlgorithm]): ...
+    def calculate_values(self, idx: int, /) -> None: ...

hydpy/cythons/interputils.pyx

@@ -0,0 +1,109 @@
+"""This Cython module implements the performance-critical methods of the
+Python module |interptools|.
+"""
+
+import numpy
+
+cimport cython
+from libc.math cimport NAN as nan
+from libc.stdlib cimport malloc, free
+
+from hydpy import config
+from hydpy.cythons.autogen cimport annutils
+from hydpy.cythons.autogen cimport ppolyutils
+
+cdef int _ANN = 0
+cdef int _PPOLY = 1
+
+
+def _type2number():
+    from hydpy.auxs.anntools import ANN
+    from hydpy.auxs.ppolytools import PPoly
+    return {ANN: _ANN, PPoly: _PPOLY}
+
+
+@cython.final
+cdef class SimpleInterpolator:
+
+    def __init__(self, algorithm):
+        self.nmb_inputs = algorithm.nmb_inputs
+        self.nmb_outputs = algorithm.nmb_outputs
+        float_ = config.NP_FLOAT
+        self.inputs = numpy.zeros(self.nmb_inputs, dtype=float_)
+        self.outputs = numpy.zeros(self.nmb_outputs, dtype=float_)
+        self.output_derivatives = numpy.zeros(self.nmb_outputs, dtype=float_)
+        self.algorithm_type = _type2number()[type(algorithm)]
+        self.algorithm = <PyObject*>algorithm._calgorithm
+
+    cpdef inline void calculate_values(self) noexcept nogil:
+        cdef int idx
+        if self.algorithm_type == _ANN:
+            for idx in range(self.nmb_inputs):
+                 (<annutils.ANN>self.algorithm).inputs[idx] = self.inputs[idx]
+            (<annutils.ANN>self.algorithm).calculate_values()
+            for idx in range(self.nmb_outputs):
+                self.outputs[idx] = (<annutils.ANN>self.algorithm).outputs[idx]
+        elif self.algorithm_type == _PPOLY:
+            for idx in range(self.nmb_inputs):
+                 (<ppolyutils.PPoly>self.algorithm).inputs[idx] = self.inputs[idx]
+            (<ppolyutils.PPoly>self.algorithm).calculate_values()
+            for idx in range(self.nmb_outputs):
+                self.outputs[idx] = (<ppolyutils.PPoly>self.algorithm).outputs[idx]
+
+    cpdef inline void calculate_derivatives(self, int idx_input) noexcept nogil:
+        cdef int idx_output
+        if self.algorithm_type == _ANN:
+            (<annutils.ANN>self.algorithm).calculate_derivatives(idx_input)
+            for idx_output in range(self.nmb_outputs):
+                self.output_derivatives[idx_output] = (<annutils.ANN>self.algorithm).output_derivatives[idx_output]
+        elif self.algorithm_type == _PPOLY:
+            (<ppolyutils.PPoly>self.algorithm).calculate_derivatives(idx_input)
+            for idx_output in range(self.nmb_outputs):
+                self.output_derivatives[idx_output] = (<ppolyutils.PPoly>self.algorithm).output_derivatives[idx_output]
+
+
+@cython.final
+cdef class SeasonalInterpolator:
+
+    def __init__(self, algorithms):
+        self.nmb_inputs = len(algorithms[0].inputs)
+        self.nmb_outputs = len(algorithms[0].outputs)
+        self.nmb_algorithms = len(algorithms)
+        float_ = config.NP_FLOAT
+        self.inputs = numpy.zeros(self.nmb_inputs, dtype=float_)
+        self.outputs = numpy.zeros(self.nmb_outputs, dtype=float_)
+        t2n = _type2number()
+        self.algorithm_types = numpy.array(
+            [t2n[type(alg)] for alg in algorithms], dtype=config.NP_INT
+        )
+        self.algorithms = <PyObject **>malloc(
+            self.nmb_algorithms * cython.sizeof(cython.pointer(PyObject))
+        )
+        for idx, algorithm in enumerate(algorithms):
+            self.algorithms[idx] = <PyObject*>algorithm._calgorithm
+
+    def __dealloc__(self):
+        free(self.algorithms)
+
+    cpdef inline void calculate_values(self, int idx_season) noexcept nogil:
+        cdef int idx_algorithm, idx_input, idx_output
+        cdef double ratio, frac
+        for idx_output in range(self.nmb_outputs):
+            self.outputs[idx_output] = 0.0
+        for idx_algorithm in range(self.nmb_algorithms):
+            ratio = self.ratios[idx_season, idx_algorithm]
+            if ratio > 0.0:
+                if self.algorithm_types[idx_algorithm] == _ANN:
+                    for idx_input in range(self.nmb_inputs):
+                         (<annutils.ANN>self.algorithms[idx_algorithm]).inputs[idx_input] = self.inputs[idx_input]
+                    (<annutils.ANN>self.algorithms[idx_algorithm]).calculate_values()
+                    for idx_output in range(self.nmb_outputs):
+                        frac = ratio*(<annutils.ANN>self.algorithms[idx_algorithm]).outputs[idx_output]
+                        self.outputs[idx_output] += frac
+                if self.algorithm_types[idx_algorithm] == _PPOLY:
+                    for idx_input in range(self.nmb_inputs):
+                         (<ppolyutils.PPoly>self.algorithms[idx_algorithm]).inputs[idx_input] = self.inputs[idx_input]
+                    (<ppolyutils.PPoly>self.algorithms[idx_algorithm]).calculate_values()
+                    for idx_output in range(self.nmb_outputs):
+                        frac = ratio * (<ppolyutils.PPoly>self.algorithms[idx_algorithm]).outputs[idx_output]
+                        self.outputs[idx_output] += frac