HydPy 6.2.dev1__cp313-cp313-win_amd64.whl

hydpy/cythons/autogen/c_exch.pyx

@@ -0,0 +1,462 @@
+#!python
+# distutils: define_macros=NPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION
+# cython: language_level=3
+# cython: cpow=True
+# cython: boundscheck=False
+# cython: wraparound=False
+# cython: initializedcheck=False
+# cython: cdivision=True
+from typing import Optional
+import numpy
+cimport numpy
+from libc.math cimport exp, fabs, log, sin, cos, tan, tanh, asin, acos, atan, isnan, isinf
+from libc.math cimport NAN as nan
+from libc.math cimport INFINITY as inf
+import cython
+from cpython.mem cimport PyMem_Malloc
+from cpython.mem cimport PyMem_Realloc
+from cpython.mem cimport PyMem_Free
+from hydpy.cythons.autogen cimport configutils
+from hydpy.cythons.autogen cimport interfaceutils
+from hydpy.cythons.autogen cimport interputils
+from hydpy.cythons.autogen import pointerutils
+from hydpy.cythons.autogen cimport pointerutils
+from hydpy.cythons.autogen cimport quadutils
+from hydpy.cythons.autogen cimport rootutils
+from hydpy.cythons.autogen cimport smoothutils
+from hydpy.cythons.autogen cimport masterinterface
+
+
+cdef void do_nothing(Model model)  noexcept nogil:
+    pass
+
+cpdef get_wrapper():
+    cdef CallbackWrapper wrapper = CallbackWrapper()
+    wrapper.callback = do_nothing
+    return wrapper
+
+@cython.final
+cdef class Parameters:
+    pass
+@cython.final
+cdef class ControlParameters:
+    pass
+@cython.final
+cdef class DerivedParameters:
+    pass
+@cython.final
+cdef class Sequences:
+    pass
+@cython.final
+cdef class InletSequences:
+    cpdef inline alloc(self, name, numpy.int64_t length):
+        if name == "total":
+            self._total_length_0 = length
+            self._total_ready = numpy.full(length, 0, dtype=numpy.int64)
+            self.total = <double**> PyMem_Malloc(length * sizeof(double*))
+    cpdef inline dealloc(self, name):
+        if name == "total":
+            PyMem_Free(self.total)
+    cpdef inline set_pointer1d(self, str name, pointerutils.Double value, numpy.int64_t idx):
+        cdef pointerutils.PDouble pointer = pointerutils.PDouble(value)
+        if name == "total":
+            self.total[idx] = pointer.p_value
+            self._total_ready[idx] = 1
+    cpdef get_value(self, str name):
+        cdef numpy.int64_t idx
+        if name == "total":
+            values = numpy.empty(self.len_total)
+            for idx in range(self.len_total):
+                pointerutils.check0(self._total_length_0)
+                if self._total_ready[idx] == 0:
+                    pointerutils.check1(self._total_length_0, idx)
+                    pointerutils.check2(self._total_ready, idx)
+                values[idx] = self.total[idx][0]
+            return values
+    cpdef set_value(self, str name, value):
+        if name == "total":
+            for idx in range(self.len_total):
+                pointerutils.check0(self._total_length_0)
+                if self._total_ready[idx] == 0:
+                    pointerutils.check1(self._total_length_0, idx)
+                    pointerutils.check2(self._total_ready, idx)
+                self.total[idx][0] = value[idx]
+@cython.final
+cdef class ReceiverSequences:
+    cpdef inline set_pointer0d(self, str name, pointerutils.Double value):
+        cdef pointerutils.PDouble pointer = pointerutils.PDouble(value)
+        if name == "waterlevel":
+            self.waterlevel = pointer.p_value
+    cpdef inline alloc(self, name, numpy.int64_t length):
+        if name == "waterlevels":
+            self._waterlevels_length_0 = length
+            self._waterlevels_ready = numpy.full(length, 0, dtype=numpy.int64)
+            self.waterlevels = <double**> PyMem_Malloc(length * sizeof(double*))
+    cpdef inline dealloc(self, name):
+        if name == "waterlevels":
+            PyMem_Free(self.waterlevels)
+    cpdef inline set_pointer1d(self, str name, pointerutils.Double value, numpy.int64_t idx):
+        cdef pointerutils.PDouble pointer = pointerutils.PDouble(value)
+        if name == "waterlevels":
+            self.waterlevels[idx] = pointer.p_value
+            self._waterlevels_ready[idx] = 1
+    cpdef get_value(self, str name):
+        cdef numpy.int64_t idx
+        if name == "waterlevel":
+            return self.waterlevel[0]
+        if name == "waterlevels":
+            values = numpy.empty(self.len_waterlevels)
+            for idx in range(self.len_waterlevels):
+                pointerutils.check0(self._waterlevels_length_0)
+                if self._waterlevels_ready[idx] == 0:
+                    pointerutils.check1(self._waterlevels_length_0, idx)
+                    pointerutils.check2(self._waterlevels_ready, idx)
+                values[idx] = self.waterlevels[idx][0]
+            return values
+    cpdef set_value(self, str name, value):
+        if name == "waterlevel":
+            self.waterlevel[0] = value
+        if name == "waterlevels":
+            for idx in range(self.len_waterlevels):
+                pointerutils.check0(self._waterlevels_length_0)
+                if self._waterlevels_ready[idx] == 0:
+                    pointerutils.check1(self._waterlevels_length_0, idx)
+                    pointerutils.check2(self._waterlevels_ready, idx)
+                self.waterlevels[idx][0] = value[idx]
+@cython.final
+cdef class FactorSequences:
+    cpdef inline void load_data(self, numpy.int64_t idx)  noexcept nogil:
+        cdef numpy.int64_t jdx0
+        cdef numpy.int64_t k
+        if self._waterlevels_diskflag_reading:
+            k = 0
+            for jdx0 in range(self._waterlevels_length_0):
+                self.waterlevels[jdx0] = self._waterlevels_ncarray[k]
+                k += 1
+        elif self._waterlevels_ramflag:
+            for jdx0 in range(self._waterlevels_length_0):
+                self.waterlevels[jdx0] = self._waterlevels_array[idx, jdx0]
+        if self._deltawaterlevel_diskflag_reading:
+            self.deltawaterlevel = self._deltawaterlevel_ncarray[0]
+        elif self._deltawaterlevel_ramflag:
+            self.deltawaterlevel = self._deltawaterlevel_array[idx]
+    cpdef inline void save_data(self, numpy.int64_t idx)  noexcept nogil:
+        cdef numpy.int64_t jdx0
+        cdef numpy.int64_t k
+        if self._waterlevels_diskflag_writing:
+            k = 0
+            for jdx0 in range(self._waterlevels_length_0):
+                self._waterlevels_ncarray[k] = self.waterlevels[jdx0]
+                k += 1
+        if self._waterlevels_ramflag:
+            for jdx0 in range(self._waterlevels_length_0):
+                self._waterlevels_array[idx, jdx0] = self.waterlevels[jdx0]
+        if self._deltawaterlevel_diskflag_writing:
+            self._deltawaterlevel_ncarray[0] = self.deltawaterlevel
+        if self._deltawaterlevel_ramflag:
+            self._deltawaterlevel_array[idx] = self.deltawaterlevel
+    cpdef inline set_pointeroutput(self, str name, pointerutils.PDouble value):
+        if name == "deltawaterlevel":
+            self._deltawaterlevel_outputpointer = value.p_value
+    cpdef inline void update_outputs(self) noexcept nogil:
+        if self._deltawaterlevel_outputflag:
+            self._deltawaterlevel_outputpointer[0] = self.deltawaterlevel
+@cython.final
+cdef class FluxSequences:
+    cpdef inline void load_data(self, numpy.int64_t idx)  noexcept nogil:
+        cdef numpy.int64_t jdx0
+        cdef numpy.int64_t k
+        if self._potentialexchange_diskflag_reading:
+            self.potentialexchange = self._potentialexchange_ncarray[0]
+        elif self._potentialexchange_ramflag:
+            self.potentialexchange = self._potentialexchange_array[idx]
+        if self._actualexchange_diskflag_reading:
+            self.actualexchange = self._actualexchange_ncarray[0]
+        elif self._actualexchange_ramflag:
+            self.actualexchange = self._actualexchange_array[idx]
+        if self._originalinput_diskflag_reading:
+            self.originalinput = self._originalinput_ncarray[0]
+        elif self._originalinput_ramflag:
+            self.originalinput = self._originalinput_array[idx]
+        if self._adjustedinput_diskflag_reading:
+            self.adjustedinput = self._adjustedinput_ncarray[0]
+        elif self._adjustedinput_ramflag:
+            self.adjustedinput = self._adjustedinput_array[idx]
+        if self._outputs_diskflag_reading:
+            k = 0
+            for jdx0 in range(self._outputs_length_0):
+                self.outputs[jdx0] = self._outputs_ncarray[k]
+                k += 1
+        elif self._outputs_ramflag:
+            for jdx0 in range(self._outputs_length_0):
+                self.outputs[jdx0] = self._outputs_array[idx, jdx0]
+    cpdef inline void save_data(self, numpy.int64_t idx)  noexcept nogil:
+        cdef numpy.int64_t jdx0
+        cdef numpy.int64_t k
+        if self._potentialexchange_diskflag_writing:
+            self._potentialexchange_ncarray[0] = self.potentialexchange
+        if self._potentialexchange_ramflag:
+            self._potentialexchange_array[idx] = self.potentialexchange
+        if self._actualexchange_diskflag_writing:
+            self._actualexchange_ncarray[0] = self.actualexchange
+        if self._actualexchange_ramflag:
+            self._actualexchange_array[idx] = self.actualexchange
+        if self._originalinput_diskflag_writing:
+            self._originalinput_ncarray[0] = self.originalinput
+        if self._originalinput_ramflag:
+            self._originalinput_array[idx] = self.originalinput
+        if self._adjustedinput_diskflag_writing:
+            self._adjustedinput_ncarray[0] = self.adjustedinput
+        if self._adjustedinput_ramflag:
+            self._adjustedinput_array[idx] = self.adjustedinput
+        if self._outputs_diskflag_writing:
+            k = 0
+            for jdx0 in range(self._outputs_length_0):
+                self._outputs_ncarray[k] = self.outputs[jdx0]
+                k += 1
+        if self._outputs_ramflag:
+            for jdx0 in range(self._outputs_length_0):
+                self._outputs_array[idx, jdx0] = self.outputs[jdx0]
+    cpdef inline set_pointeroutput(self, str name, pointerutils.PDouble value):
+        if name == "potentialexchange":
+            self._potentialexchange_outputpointer = value.p_value
+        if name == "actualexchange":
+            self._actualexchange_outputpointer = value.p_value
+        if name == "originalinput":
+            self._originalinput_outputpointer = value.p_value
+        if name == "adjustedinput":
+            self._adjustedinput_outputpointer = value.p_value
+    cpdef inline void update_outputs(self) noexcept nogil:
+        if self._potentialexchange_outputflag:
+            self._potentialexchange_outputpointer[0] = self.potentialexchange
+        if self._actualexchange_outputflag:
+            self._actualexchange_outputpointer[0] = self.actualexchange
+        if self._originalinput_outputflag:
+            self._originalinput_outputpointer[0] = self.originalinput
+        if self._adjustedinput_outputflag:
+            self._adjustedinput_outputpointer[0] = self.adjustedinput
+@cython.final
+cdef class LogSequences:
+    pass
+@cython.final
+cdef class OutletSequences:
+    cpdef inline alloc(self, name, numpy.int64_t length):
+        if name == "exchange":
+            self._exchange_length_0 = length
+            self._exchange_ready = numpy.full(length, 0, dtype=numpy.int64)
+            self.exchange = <double**> PyMem_Malloc(length * sizeof(double*))
+        if name == "branched":
+            self._branched_length_0 = length
+            self._branched_ready = numpy.full(length, 0, dtype=numpy.int64)
+            self.branched = <double**> PyMem_Malloc(length * sizeof(double*))
+    cpdef inline dealloc(self, name):
+        if name == "exchange":
+            PyMem_Free(self.exchange)
+        if name == "branched":
+            PyMem_Free(self.branched)
+    cpdef inline set_pointer1d(self, str name, pointerutils.Double value, numpy.int64_t idx):
+        cdef pointerutils.PDouble pointer = pointerutils.PDouble(value)
+        if name == "exchange":
+            self.exchange[idx] = pointer.p_value
+            self._exchange_ready[idx] = 1
+        if name == "branched":
+            self.branched[idx] = pointer.p_value
+            self._branched_ready[idx] = 1
+    cpdef get_value(self, str name):
+        cdef numpy.int64_t idx
+        if name == "exchange":
+            values = numpy.empty(self.len_exchange)
+            for idx in range(self.len_exchange):
+                pointerutils.check0(self._exchange_length_0)
+                if self._exchange_ready[idx] == 0:
+                    pointerutils.check1(self._exchange_length_0, idx)
+                    pointerutils.check2(self._exchange_ready, idx)
+                values[idx] = self.exchange[idx][0]
+            return values
+        if name == "branched":
+            values = numpy.empty(self.len_branched)
+            for idx in range(self.len_branched):
+                pointerutils.check0(self._branched_length_0)
+                if self._branched_ready[idx] == 0:
+                    pointerutils.check1(self._branched_length_0, idx)
+                    pointerutils.check2(self._branched_ready, idx)
+                values[idx] = self.branched[idx][0]
+            return values
+    cpdef set_value(self, str name, value):
+        if name == "exchange":
+            for idx in range(self.len_exchange):
+                pointerutils.check0(self._exchange_length_0)
+                if self._exchange_ready[idx] == 0:
+                    pointerutils.check1(self._exchange_length_0, idx)
+                    pointerutils.check2(self._exchange_ready, idx)
+                self.exchange[idx][0] = value[idx]
+        if name == "branched":
+            for idx in range(self.len_branched):
+                pointerutils.check0(self._branched_length_0)
+                if self._branched_ready[idx] == 0:
+                    pointerutils.check1(self._branched_length_0, idx)
+                    pointerutils.check2(self._branched_ready, idx)
+                self.branched[idx][0] = value[idx]
+@cython.final
+cdef class Model:
+    cpdef inline void simulate(self, numpy.int64_t idx)  noexcept nogil:
+        self.idx_sim = idx
+        self.update_inlets()
+        self.run()
+        self.update_outlets()
+        self.update_outputs()
+    cpdef void reset_reuseflags(self) noexcept nogil:
+        pass
+    cpdef void save_data(self, numpy.int64_t idx) noexcept nogil:
+        self.idx_sim = idx
+        self.sequences.factors.save_data(idx)
+        self.sequences.fluxes.save_data(idx)
+    cpdef inline void run(self) noexcept nogil:
+        self.update_waterlevels_v1()
+        self.calc_deltawaterlevel_v1()
+        self.calc_potentialexchange_v1()
+        self.calc_actualexchange_v1()
+        self.calc_adjustedinput_v1()
+        self.calc_outputs_v1()
+    cpdef inline void update_inlets(self) noexcept nogil:
+        self.pick_originalinput_v1()
+    cpdef inline void update_outlets(self) noexcept nogil:
+        self.pass_actualexchange_v1()
+        self.pass_outputs_v1()
+    cpdef inline void update_receivers(self, numpy.int64_t idx) noexcept nogil:
+        self.idx_sim = idx
+        self.pic_loggedwaterlevels_v1()
+    cpdef inline void update_senders(self, numpy.int64_t idx) noexcept nogil:
+        self.idx_sim = idx
+        pass
+    cpdef inline void update_outputs(self) noexcept nogil:
+        self.sequences.factors.update_outputs()
+        self.sequences.fluxes.update_outputs()
+    cpdef inline void pic_loggedwaterlevels_v1(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        for idx in range(2):
+            self.sequences.logs.loggedwaterlevels[idx] = self.sequences.receivers.waterlevels[idx][0]
+    cpdef inline void pick_originalinput_v1(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        self.sequences.fluxes.originalinput = 0.0
+        for idx in range(self.sequences.inlets.len_total):
+            self.sequences.fluxes.originalinput = self.sequences.fluxes.originalinput + (self.sequences.inlets.total[idx][0])
+    cpdef inline void update_waterlevels_v1(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        for idx in range(2):
+            self.sequences.factors.waterlevels[idx] = self.sequences.logs.loggedwaterlevels[idx]
+    cpdef inline void calc_deltawaterlevel_v1(self) noexcept nogil:
+        cdef double d_wl1
+        cdef double d_wl0
+        d_wl0 = max(self.sequences.factors.waterlevels[0], self.parameters.control.crestheight)
+        d_wl1 = max(self.sequences.factors.waterlevels[1], self.parameters.control.crestheight)
+        self.sequences.factors.deltawaterlevel = d_wl0 - d_wl1
+    cpdef inline void calc_potentialexchange_v1(self) noexcept nogil:
+        cdef double d_sig
+        cdef double d_dwl
+        if self.sequences.factors.deltawaterlevel >= 0.0:
+            d_dwl = self.sequences.factors.deltawaterlevel
+            d_sig = 1.0
+        else:
+            d_dwl = -self.sequences.factors.deltawaterlevel
+            d_sig = -1.0
+        self.sequences.fluxes.potentialexchange = d_sig * (            self.parameters.control.flowcoefficient * self.parameters.control.crestwidth * d_dwl**self.parameters.control.flowexponent        )
+    cpdef inline void calc_actualexchange_v1(self) noexcept nogil:
+        if self.sequences.fluxes.potentialexchange >= 0.0:
+            self.sequences.fluxes.actualexchange = min(self.sequences.fluxes.potentialexchange, self.parameters.control.allowedexchange)
+        else:
+            self.sequences.fluxes.actualexchange = max(self.sequences.fluxes.potentialexchange, -self.parameters.control.allowedexchange)
+    cpdef inline void calc_adjustedinput_v1(self) noexcept nogil:
+        self.sequences.fluxes.adjustedinput = self.sequences.fluxes.originalinput + self.parameters.control.delta[self.parameters.derived.moy[self.idx_sim]]
+        self.sequences.fluxes.adjustedinput = max(self.sequences.fluxes.adjustedinput, self.parameters.control.minimum)
+    cpdef inline void calc_outputs_v1(self) noexcept nogil:
+        cdef double d_dy
+        cdef double d_y0
+        cdef double d_dx
+        cdef double d_x0
+        cdef numpy.int64_t bdx
+        cdef double d_x
+        cdef numpy.int64_t pdx
+        for pdx in range(1, self.parameters.derived.nmbpoints):
+            if self.parameters.control.xpoints[pdx] > self.sequences.fluxes.adjustedinput:
+                break
+        d_x = self.sequences.fluxes.adjustedinput
+        for bdx in range(self.parameters.derived.nmbbranches):
+            d_x0 = self.parameters.control.xpoints[pdx - 1]
+            d_dx = self.parameters.control.xpoints[pdx] - d_x0
+            d_y0 = self.parameters.control.ypoints[bdx, pdx - 1]
+            d_dy = self.parameters.control.ypoints[bdx, pdx] - d_y0
+            self.sequences.fluxes.outputs[bdx] = (d_x - d_x0) * d_dy / d_dx + d_y0
+    cpdef double get_waterlevel_v1(self) noexcept nogil:
+        return self.sequences.receivers.waterlevel[0]
+    cpdef inline void pass_actualexchange_v1(self) noexcept nogil:
+        self.sequences.outlets.exchange[0][0] = self.sequences.outlets.exchange[0][0] - (self.sequences.fluxes.actualexchange)
+        self.sequences.outlets.exchange[1][0] = self.sequences.outlets.exchange[1][0] + (self.sequences.fluxes.actualexchange)
+    cpdef inline void pass_outputs_v1(self) noexcept nogil:
+        cdef numpy.int64_t bdx
+        for bdx in range(self.parameters.derived.nmbbranches):
+            self.sequences.outlets.branched[bdx][0] = self.sequences.outlets.branched[bdx][0] + (self.sequences.fluxes.outputs[bdx])
+    cpdef inline void pic_loggedwaterlevels(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        for idx in range(2):
+            self.sequences.logs.loggedwaterlevels[idx] = self.sequences.receivers.waterlevels[idx][0]
+    cpdef inline void pick_originalinput(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        self.sequences.fluxes.originalinput = 0.0
+        for idx in range(self.sequences.inlets.len_total):
+            self.sequences.fluxes.originalinput = self.sequences.fluxes.originalinput + (self.sequences.inlets.total[idx][0])
+    cpdef inline void update_waterlevels(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        for idx in range(2):
+            self.sequences.factors.waterlevels[idx] = self.sequences.logs.loggedwaterlevels[idx]
+    cpdef inline void calc_deltawaterlevel(self) noexcept nogil:
+        cdef double d_wl1
+        cdef double d_wl0
+        d_wl0 = max(self.sequences.factors.waterlevels[0], self.parameters.control.crestheight)
+        d_wl1 = max(self.sequences.factors.waterlevels[1], self.parameters.control.crestheight)
+        self.sequences.factors.deltawaterlevel = d_wl0 - d_wl1
+    cpdef inline void calc_potentialexchange(self) noexcept nogil:
+        cdef double d_sig
+        cdef double d_dwl
+        if self.sequences.factors.deltawaterlevel >= 0.0:
+            d_dwl = self.sequences.factors.deltawaterlevel
+            d_sig = 1.0
+        else:
+            d_dwl = -self.sequences.factors.deltawaterlevel
+            d_sig = -1.0
+        self.sequences.fluxes.potentialexchange = d_sig * (            self.parameters.control.flowcoefficient * self.parameters.control.crestwidth * d_dwl**self.parameters.control.flowexponent        )
+    cpdef inline void calc_actualexchange(self) noexcept nogil:
+        if self.sequences.fluxes.potentialexchange >= 0.0:
+            self.sequences.fluxes.actualexchange = min(self.sequences.fluxes.potentialexchange, self.parameters.control.allowedexchange)
+        else:
+            self.sequences.fluxes.actualexchange = max(self.sequences.fluxes.potentialexchange, -self.parameters.control.allowedexchange)
+    cpdef inline void calc_adjustedinput(self) noexcept nogil:
+        self.sequences.fluxes.adjustedinput = self.sequences.fluxes.originalinput + self.parameters.control.delta[self.parameters.derived.moy[self.idx_sim]]
+        self.sequences.fluxes.adjustedinput = max(self.sequences.fluxes.adjustedinput, self.parameters.control.minimum)
+    cpdef inline void calc_outputs(self) noexcept nogil:
+        cdef double d_dy
+        cdef double d_y0
+        cdef double d_dx
+        cdef double d_x0
+        cdef numpy.int64_t bdx
+        cdef double d_x
+        cdef numpy.int64_t pdx
+        for pdx in range(1, self.parameters.derived.nmbpoints):
+            if self.parameters.control.xpoints[pdx] > self.sequences.fluxes.adjustedinput:
+                break
+        d_x = self.sequences.fluxes.adjustedinput
+        for bdx in range(self.parameters.derived.nmbbranches):
+            d_x0 = self.parameters.control.xpoints[pdx - 1]
+            d_dx = self.parameters.control.xpoints[pdx] - d_x0
+            d_y0 = self.parameters.control.ypoints[bdx, pdx - 1]
+            d_dy = self.parameters.control.ypoints[bdx, pdx] - d_y0
+            self.sequences.fluxes.outputs[bdx] = (d_x - d_x0) * d_dy / d_dx + d_y0
+    cpdef double get_waterlevel(self) noexcept nogil:
+        return self.sequences.receivers.waterlevel[0]
+    cpdef inline void pass_actualexchange(self) noexcept nogil:
+        self.sequences.outlets.exchange[0][0] = self.sequences.outlets.exchange[0][0] - (self.sequences.fluxes.actualexchange)
+        self.sequences.outlets.exchange[1][0] = self.sequences.outlets.exchange[1][0] + (self.sequences.fluxes.actualexchange)
+    cpdef inline void pass_outputs(self) noexcept nogil:
+        cdef numpy.int64_t bdx
+        for bdx in range(self.parameters.derived.nmbbranches):
+            self.sequences.outlets.branched[bdx][0] = self.sequences.outlets.branched[bdx][0] + (self.sequences.fluxes.outputs[bdx])

hydpy/cythons/autogen/c_exch_branch_hbv96.pxd

@@ -0,0 +1,134 @@
+#!python
+# distutils: define_macros=NPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION
+# cython: language_level=3
+# cython: cpow=True
+# cython: boundscheck=False
+# cython: wraparound=False
+# cython: initializedcheck=False
+# cython: cdivision=True
+from typing import Optional
+import numpy
+cimport numpy
+from libc.math cimport exp, fabs, log, sin, cos, tan, tanh, asin, acos, atan, isnan, isinf
+from libc.math cimport NAN as nan
+from libc.math cimport INFINITY as inf
+import cython
+from cpython.mem cimport PyMem_Malloc
+from cpython.mem cimport PyMem_Realloc
+from cpython.mem cimport PyMem_Free
+from hydpy.cythons.autogen cimport configutils
+from hydpy.cythons.autogen cimport interfaceutils
+from hydpy.cythons.autogen cimport interputils
+from hydpy.cythons.autogen import pointerutils
+from hydpy.cythons.autogen cimport pointerutils
+from hydpy.cythons.autogen cimport quadutils
+from hydpy.cythons.autogen cimport rootutils
+from hydpy.cythons.autogen cimport smoothutils
+from hydpy.cythons.autogen cimport masterinterface
+ctypedef void (*CallbackType) (Model)  noexcept nogil
+cdef class CallbackWrapper:
+    cdef CallbackType callback
+@cython.final
+cdef class Parameters:
+    cdef public ControlParameters control
+    cdef public DerivedParameters derived
+@cython.final
+cdef class ControlParameters:
+    cdef public double[:] delta
+    cdef public numpy.int64_t _delta_entrymin
+    cdef public double minimum
+    cdef public double[:] xpoints
+    cdef public double[:,:] ypoints
+@cython.final
+cdef class DerivedParameters:
+    cdef public numpy.int64_t[:] moy
+    cdef public numpy.int64_t nmbbranches
+    cdef public numpy.int64_t nmbpoints
+@cython.final
+cdef class Sequences:
+    cdef public InletSequences inlets
+    cdef public FluxSequences fluxes
+    cdef public OutletSequences outlets
+@cython.final
+cdef class InletSequences:
+    cdef double **total
+    cdef public numpy.int64_t len_total
+    cdef public numpy.int64_t[:] _total_ready
+    cdef public numpy.int64_t _total_ndim
+    cdef public numpy.int64_t _total_length
+    cdef public numpy.int64_t _total_length_0
+    cpdef inline alloc(self, name, numpy.int64_t length)
+    cpdef inline dealloc(self, name)
+    cpdef inline set_pointer1d(self, str name, pointerutils.Double value, numpy.int64_t idx)
+    cpdef get_value(self, str name)
+    cpdef set_value(self, str name, value)
+@cython.final
+cdef class FluxSequences:
+    cdef public double originalinput
+    cdef public numpy.int64_t _originalinput_ndim
+    cdef public numpy.int64_t _originalinput_length
+    cdef public bint _originalinput_ramflag
+    cdef public double[:] _originalinput_array
+    cdef public bint _originalinput_diskflag_reading
+    cdef public bint _originalinput_diskflag_writing
+    cdef public double[:] _originalinput_ncarray
+    cdef public bint _originalinput_outputflag
+    cdef double *_originalinput_outputpointer
+    cdef public double adjustedinput
+    cdef public numpy.int64_t _adjustedinput_ndim
+    cdef public numpy.int64_t _adjustedinput_length
+    cdef public bint _adjustedinput_ramflag
+    cdef public double[:] _adjustedinput_array
+    cdef public bint _adjustedinput_diskflag_reading
+    cdef public bint _adjustedinput_diskflag_writing
+    cdef public double[:] _adjustedinput_ncarray
+    cdef public bint _adjustedinput_outputflag
+    cdef double *_adjustedinput_outputpointer
+    cdef public double[:] outputs
+    cdef public numpy.int64_t _outputs_ndim
+    cdef public numpy.int64_t _outputs_length
+    cdef public numpy.int64_t _outputs_length_0
+    cdef public bint _outputs_ramflag
+    cdef public double[:,:] _outputs_array
+    cdef public bint _outputs_diskflag_reading
+    cdef public bint _outputs_diskflag_writing
+    cdef public double[:] _outputs_ncarray
+    cpdef inline void load_data(self, numpy.int64_t idx)  noexcept nogil
+    cpdef inline void save_data(self, numpy.int64_t idx)  noexcept nogil
+    cpdef inline set_pointeroutput(self, str name, pointerutils.PDouble value)
+    cpdef inline void update_outputs(self) noexcept nogil
+@cython.final
+cdef class OutletSequences:
+    cdef double **branched
+    cdef public numpy.int64_t len_branched
+    cdef public numpy.int64_t[:] _branched_ready
+    cdef public numpy.int64_t _branched_ndim
+    cdef public numpy.int64_t _branched_length
+    cdef public numpy.int64_t _branched_length_0
+    cpdef inline alloc(self, name, numpy.int64_t length)
+    cpdef inline dealloc(self, name)
+    cpdef inline set_pointer1d(self, str name, pointerutils.Double value, numpy.int64_t idx)
+    cpdef get_value(self, str name)
+    cpdef set_value(self, str name, value)
+@cython.final
+cdef class Model:
+    cdef public numpy.int64_t idx_sim
+    cdef public Parameters parameters
+    cdef public Sequences sequences
+    cpdef inline void simulate(self, numpy.int64_t idx)  noexcept nogil
+    cpdef void reset_reuseflags(self) noexcept nogil
+    cpdef void save_data(self, numpy.int64_t idx) noexcept nogil
+    cpdef inline void run(self) noexcept nogil
+    cpdef inline void update_inlets(self) noexcept nogil
+    cpdef inline void update_outlets(self) noexcept nogil
+    cpdef inline void update_receivers(self, numpy.int64_t idx) noexcept nogil
+    cpdef inline void update_senders(self, numpy.int64_t idx) noexcept nogil
+    cpdef inline void update_outputs(self) noexcept nogil
+    cpdef inline void pick_originalinput_v1(self) noexcept nogil
+    cpdef inline void calc_adjustedinput_v1(self) noexcept nogil
+    cpdef inline void calc_outputs_v1(self) noexcept nogil
+    cpdef inline void pass_outputs_v1(self) noexcept nogil
+    cpdef inline void pick_originalinput(self) noexcept nogil
+    cpdef inline void calc_adjustedinput(self) noexcept nogil
+    cpdef inline void calc_outputs(self) noexcept nogil
+    cpdef inline void pass_outputs(self) noexcept nogil