HydPy 6.2.dev1__cp313-cp313-win_amd64.whl

hydpy/cythons/autogen/c_dam_v005.pyx

@@ -0,0 +1,928 @@
+#!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 SolverParameters:
+    pass
+@cython.final
+cdef class Sequences:
+    pass
+@cython.final
+cdef class InletSequences:
+    cpdef inline set_pointer0d(self, str name, pointerutils.Double value):
+        cdef pointerutils.PDouble pointer = pointerutils.PDouble(value)
+        if name == "s":
+            self.s = pointer.p_value
+        if name == "r":
+            self.r = pointer.p_value
+    cpdef inline alloc(self, name, numpy.int64_t length):
+        if name == "q":
+            self._q_length_0 = length
+            self._q_ready = numpy.full(length, 0, dtype=numpy.int64)
+            self.q = <double**> PyMem_Malloc(length * sizeof(double*))
+    cpdef inline dealloc(self, name):
+        if name == "q":
+            PyMem_Free(self.q)
+    cpdef inline set_pointer1d(self, str name, pointerutils.Double value, numpy.int64_t idx):
+        cdef pointerutils.PDouble pointer = pointerutils.PDouble(value)
+        if name == "q":
+            self.q[idx] = pointer.p_value
+            self._q_ready[idx] = 1
+    cpdef get_value(self, str name):
+        cdef numpy.int64_t idx
+        if name == "q":
+            values = numpy.empty(self.len_q)
+            for idx in range(self.len_q):
+                pointerutils.check0(self._q_length_0)
+                if self._q_ready[idx] == 0:
+                    pointerutils.check1(self._q_length_0, idx)
+                    pointerutils.check2(self._q_ready, idx)
+                values[idx] = self.q[idx][0]
+            return values
+        if name == "s":
+            return self.s[0]
+        if name == "r":
+            return self.r[0]
+    cpdef set_value(self, str name, value):
+        if name == "q":
+            for idx in range(self.len_q):
+                pointerutils.check0(self._q_length_0)
+                if self._q_ready[idx] == 0:
+                    pointerutils.check1(self._q_length_0, idx)
+                    pointerutils.check2(self._q_ready, idx)
+                self.q[idx][0] = value[idx]
+        if name == "s":
+            self.s[0] = value
+        if name == "r":
+            self.r[0] = value
+@cython.final
+cdef class ReceiverSequences:
+    cpdef inline set_pointer0d(self, str name, pointerutils.Double value):
+        cdef pointerutils.PDouble pointer = pointerutils.PDouble(value)
+        if name == "q":
+            self.q = pointer.p_value
+    cpdef get_value(self, str name):
+        cdef numpy.int64_t idx
+        if name == "q":
+            return self.q[0]
+    cpdef set_value(self, str name, value):
+        if name == "q":
+            self.q[0] = value
+@cython.final
+cdef class FactorSequences:
+    cpdef inline void load_data(self, numpy.int64_t idx)  noexcept nogil:
+        cdef numpy.int64_t k
+        if self._waterlevel_diskflag_reading:
+            self.waterlevel = self._waterlevel_ncarray[0]
+        elif self._waterlevel_ramflag:
+            self.waterlevel = self._waterlevel_array[idx]
+    cpdef inline void save_data(self, numpy.int64_t idx)  noexcept nogil:
+        cdef numpy.int64_t k
+        if self._waterlevel_diskflag_writing:
+            self._waterlevel_ncarray[0] = self.waterlevel
+        if self._waterlevel_ramflag:
+            self._waterlevel_array[idx] = self.waterlevel
+    cpdef inline set_pointeroutput(self, str name, pointerutils.PDouble value):
+        if name == "waterlevel":
+            self._waterlevel_outputpointer = value.p_value
+    cpdef inline void update_outputs(self) noexcept nogil:
+        if self._waterlevel_outputflag:
+            self._waterlevel_outputpointer[0] = self.waterlevel
+@cython.final
+cdef class FluxSequences:
+    cpdef inline void load_data(self, numpy.int64_t idx)  noexcept nogil:
+        cdef numpy.int64_t k
+        if self._precipitation_diskflag_reading:
+            self.precipitation = self._precipitation_ncarray[0]
+        elif self._precipitation_ramflag:
+            self.precipitation = self._precipitation_array[idx]
+        if self._adjustedprecipitation_diskflag_reading:
+            self.adjustedprecipitation = self._adjustedprecipitation_ncarray[0]
+        elif self._adjustedprecipitation_ramflag:
+            self.adjustedprecipitation = self._adjustedprecipitation_array[idx]
+        if self._potentialevaporation_diskflag_reading:
+            self.potentialevaporation = self._potentialevaporation_ncarray[0]
+        elif self._potentialevaporation_ramflag:
+            self.potentialevaporation = self._potentialevaporation_array[idx]
+        if self._adjustedevaporation_diskflag_reading:
+            self.adjustedevaporation = self._adjustedevaporation_ncarray[0]
+        elif self._adjustedevaporation_ramflag:
+            self.adjustedevaporation = self._adjustedevaporation_array[idx]
+        if self._actualevaporation_diskflag_reading:
+            self.actualevaporation = self._actualevaporation_ncarray[0]
+        elif self._actualevaporation_ramflag:
+            self.actualevaporation = self._actualevaporation_array[idx]
+        if self._inflow_diskflag_reading:
+            self.inflow = self._inflow_ncarray[0]
+        elif self._inflow_ramflag:
+            self.inflow = self._inflow_array[idx]
+        if self._totalremotedischarge_diskflag_reading:
+            self.totalremotedischarge = self._totalremotedischarge_ncarray[0]
+        elif self._totalremotedischarge_ramflag:
+            self.totalremotedischarge = self._totalremotedischarge_array[idx]
+        if self._naturalremotedischarge_diskflag_reading:
+            self.naturalremotedischarge = self._naturalremotedischarge_ncarray[0]
+        elif self._naturalremotedischarge_ramflag:
+            self.naturalremotedischarge = self._naturalremotedischarge_array[idx]
+        if self._remotedemand_diskflag_reading:
+            self.remotedemand = self._remotedemand_ncarray[0]
+        elif self._remotedemand_ramflag:
+            self.remotedemand = self._remotedemand_array[idx]
+        if self._remotefailure_diskflag_reading:
+            self.remotefailure = self._remotefailure_ncarray[0]
+        elif self._remotefailure_ramflag:
+            self.remotefailure = self._remotefailure_array[idx]
+        if self._requiredremoterelease_diskflag_reading:
+            self.requiredremoterelease = self._requiredremoterelease_ncarray[0]
+        elif self._requiredremoterelease_ramflag:
+            self.requiredremoterelease = self._requiredremoterelease_array[idx]
+        if self._allowedremoterelief_diskflag_reading:
+            self.allowedremoterelief = self._allowedremoterelief_ncarray[0]
+        elif self._allowedremoterelief_ramflag:
+            self.allowedremoterelief = self._allowedremoterelief_array[idx]
+        if self._requiredremotesupply_diskflag_reading:
+            self.requiredremotesupply = self._requiredremotesupply_ncarray[0]
+        elif self._requiredremotesupply_ramflag:
+            self.requiredremotesupply = self._requiredremotesupply_array[idx]
+        if self._requiredrelease_diskflag_reading:
+            self.requiredrelease = self._requiredrelease_ncarray[0]
+        elif self._requiredrelease_ramflag:
+            self.requiredrelease = self._requiredrelease_array[idx]
+        if self._targetedrelease_diskflag_reading:
+            self.targetedrelease = self._targetedrelease_ncarray[0]
+        elif self._targetedrelease_ramflag:
+            self.targetedrelease = self._targetedrelease_array[idx]
+        if self._actualrelease_diskflag_reading:
+            self.actualrelease = self._actualrelease_ncarray[0]
+        elif self._actualrelease_ramflag:
+            self.actualrelease = self._actualrelease_array[idx]
+        if self._missingremoterelease_diskflag_reading:
+            self.missingremoterelease = self._missingremoterelease_ncarray[0]
+        elif self._missingremoterelease_ramflag:
+            self.missingremoterelease = self._missingremoterelease_array[idx]
+        if self._flooddischarge_diskflag_reading:
+            self.flooddischarge = self._flooddischarge_ncarray[0]
+        elif self._flooddischarge_ramflag:
+            self.flooddischarge = self._flooddischarge_array[idx]
+        if self._outflow_diskflag_reading:
+            self.outflow = self._outflow_ncarray[0]
+        elif self._outflow_ramflag:
+            self.outflow = self._outflow_array[idx]
+    cpdef inline void save_data(self, numpy.int64_t idx)  noexcept nogil:
+        cdef numpy.int64_t k
+        if self._precipitation_diskflag_writing:
+            self._precipitation_ncarray[0] = self.precipitation
+        if self._precipitation_ramflag:
+            self._precipitation_array[idx] = self.precipitation
+        if self._adjustedprecipitation_diskflag_writing:
+            self._adjustedprecipitation_ncarray[0] = self.adjustedprecipitation
+        if self._adjustedprecipitation_ramflag:
+            self._adjustedprecipitation_array[idx] = self.adjustedprecipitation
+        if self._potentialevaporation_diskflag_writing:
+            self._potentialevaporation_ncarray[0] = self.potentialevaporation
+        if self._potentialevaporation_ramflag:
+            self._potentialevaporation_array[idx] = self.potentialevaporation
+        if self._adjustedevaporation_diskflag_writing:
+            self._adjustedevaporation_ncarray[0] = self.adjustedevaporation
+        if self._adjustedevaporation_ramflag:
+            self._adjustedevaporation_array[idx] = self.adjustedevaporation
+        if self._actualevaporation_diskflag_writing:
+            self._actualevaporation_ncarray[0] = self.actualevaporation
+        if self._actualevaporation_ramflag:
+            self._actualevaporation_array[idx] = self.actualevaporation
+        if self._inflow_diskflag_writing:
+            self._inflow_ncarray[0] = self.inflow
+        if self._inflow_ramflag:
+            self._inflow_array[idx] = self.inflow
+        if self._totalremotedischarge_diskflag_writing:
+            self._totalremotedischarge_ncarray[0] = self.totalremotedischarge
+        if self._totalremotedischarge_ramflag:
+            self._totalremotedischarge_array[idx] = self.totalremotedischarge
+        if self._naturalremotedischarge_diskflag_writing:
+            self._naturalremotedischarge_ncarray[0] = self.naturalremotedischarge
+        if self._naturalremotedischarge_ramflag:
+            self._naturalremotedischarge_array[idx] = self.naturalremotedischarge
+        if self._remotedemand_diskflag_writing:
+            self._remotedemand_ncarray[0] = self.remotedemand
+        if self._remotedemand_ramflag:
+            self._remotedemand_array[idx] = self.remotedemand
+        if self._remotefailure_diskflag_writing:
+            self._remotefailure_ncarray[0] = self.remotefailure
+        if self._remotefailure_ramflag:
+            self._remotefailure_array[idx] = self.remotefailure
+        if self._requiredremoterelease_diskflag_writing:
+            self._requiredremoterelease_ncarray[0] = self.requiredremoterelease
+        if self._requiredremoterelease_ramflag:
+            self._requiredremoterelease_array[idx] = self.requiredremoterelease
+        if self._allowedremoterelief_diskflag_writing:
+            self._allowedremoterelief_ncarray[0] = self.allowedremoterelief
+        if self._allowedremoterelief_ramflag:
+            self._allowedremoterelief_array[idx] = self.allowedremoterelief
+        if self._requiredremotesupply_diskflag_writing:
+            self._requiredremotesupply_ncarray[0] = self.requiredremotesupply
+        if self._requiredremotesupply_ramflag:
+            self._requiredremotesupply_array[idx] = self.requiredremotesupply
+        if self._requiredrelease_diskflag_writing:
+            self._requiredrelease_ncarray[0] = self.requiredrelease
+        if self._requiredrelease_ramflag:
+            self._requiredrelease_array[idx] = self.requiredrelease
+        if self._targetedrelease_diskflag_writing:
+            self._targetedrelease_ncarray[0] = self.targetedrelease
+        if self._targetedrelease_ramflag:
+            self._targetedrelease_array[idx] = self.targetedrelease
+        if self._actualrelease_diskflag_writing:
+            self._actualrelease_ncarray[0] = self.actualrelease
+        if self._actualrelease_ramflag:
+            self._actualrelease_array[idx] = self.actualrelease
+        if self._missingremoterelease_diskflag_writing:
+            self._missingremoterelease_ncarray[0] = self.missingremoterelease
+        if self._missingremoterelease_ramflag:
+            self._missingremoterelease_array[idx] = self.missingremoterelease
+        if self._flooddischarge_diskflag_writing:
+            self._flooddischarge_ncarray[0] = self.flooddischarge
+        if self._flooddischarge_ramflag:
+            self._flooddischarge_array[idx] = self.flooddischarge
+        if self._outflow_diskflag_writing:
+            self._outflow_ncarray[0] = self.outflow
+        if self._outflow_ramflag:
+            self._outflow_array[idx] = self.outflow
+    cpdef inline set_pointeroutput(self, str name, pointerutils.PDouble value):
+        if name == "precipitation":
+            self._precipitation_outputpointer = value.p_value
+        if name == "adjustedprecipitation":
+            self._adjustedprecipitation_outputpointer = value.p_value
+        if name == "potentialevaporation":
+            self._potentialevaporation_outputpointer = value.p_value
+        if name == "adjustedevaporation":
+            self._adjustedevaporation_outputpointer = value.p_value
+        if name == "actualevaporation":
+            self._actualevaporation_outputpointer = value.p_value
+        if name == "inflow":
+            self._inflow_outputpointer = value.p_value
+        if name == "totalremotedischarge":
+            self._totalremotedischarge_outputpointer = value.p_value
+        if name == "naturalremotedischarge":
+            self._naturalremotedischarge_outputpointer = value.p_value
+        if name == "remotedemand":
+            self._remotedemand_outputpointer = value.p_value
+        if name == "remotefailure":
+            self._remotefailure_outputpointer = value.p_value
+        if name == "requiredremoterelease":
+            self._requiredremoterelease_outputpointer = value.p_value
+        if name == "allowedremoterelief":
+            self._allowedremoterelief_outputpointer = value.p_value
+        if name == "requiredremotesupply":
+            self._requiredremotesupply_outputpointer = value.p_value
+        if name == "requiredrelease":
+            self._requiredrelease_outputpointer = value.p_value
+        if name == "targetedrelease":
+            self._targetedrelease_outputpointer = value.p_value
+        if name == "actualrelease":
+            self._actualrelease_outputpointer = value.p_value
+        if name == "missingremoterelease":
+            self._missingremoterelease_outputpointer = value.p_value
+        if name == "flooddischarge":
+            self._flooddischarge_outputpointer = value.p_value
+        if name == "outflow":
+            self._outflow_outputpointer = value.p_value
+    cpdef inline void update_outputs(self) noexcept nogil:
+        if self._precipitation_outputflag:
+            self._precipitation_outputpointer[0] = self.precipitation
+        if self._adjustedprecipitation_outputflag:
+            self._adjustedprecipitation_outputpointer[0] = self.adjustedprecipitation
+        if self._potentialevaporation_outputflag:
+            self._potentialevaporation_outputpointer[0] = self.potentialevaporation
+        if self._adjustedevaporation_outputflag:
+            self._adjustedevaporation_outputpointer[0] = self.adjustedevaporation
+        if self._actualevaporation_outputflag:
+            self._actualevaporation_outputpointer[0] = self.actualevaporation
+        if self._inflow_outputflag:
+            self._inflow_outputpointer[0] = self.inflow
+        if self._totalremotedischarge_outputflag:
+            self._totalremotedischarge_outputpointer[0] = self.totalremotedischarge
+        if self._naturalremotedischarge_outputflag:
+            self._naturalremotedischarge_outputpointer[0] = self.naturalremotedischarge
+        if self._remotedemand_outputflag:
+            self._remotedemand_outputpointer[0] = self.remotedemand
+        if self._remotefailure_outputflag:
+            self._remotefailure_outputpointer[0] = self.remotefailure
+        if self._requiredremoterelease_outputflag:
+            self._requiredremoterelease_outputpointer[0] = self.requiredremoterelease
+        if self._allowedremoterelief_outputflag:
+            self._allowedremoterelief_outputpointer[0] = self.allowedremoterelief
+        if self._requiredremotesupply_outputflag:
+            self._requiredremotesupply_outputpointer[0] = self.requiredremotesupply
+        if self._requiredrelease_outputflag:
+            self._requiredrelease_outputpointer[0] = self.requiredrelease
+        if self._targetedrelease_outputflag:
+            self._targetedrelease_outputpointer[0] = self.targetedrelease
+        if self._actualrelease_outputflag:
+            self._actualrelease_outputpointer[0] = self.actualrelease
+        if self._missingremoterelease_outputflag:
+            self._missingremoterelease_outputpointer[0] = self.missingremoterelease
+        if self._flooddischarge_outputflag:
+            self._flooddischarge_outputpointer[0] = self.flooddischarge
+        if self._outflow_outputflag:
+            self._outflow_outputpointer[0] = self.outflow
+@cython.final
+cdef class StateSequences:
+    cpdef inline void load_data(self, numpy.int64_t idx)  noexcept nogil:
+        cdef numpy.int64_t k
+        if self._watervolume_diskflag_reading:
+            self.watervolume = self._watervolume_ncarray[0]
+        elif self._watervolume_ramflag:
+            self.watervolume = self._watervolume_array[idx]
+    cpdef inline void save_data(self, numpy.int64_t idx)  noexcept nogil:
+        cdef numpy.int64_t k
+        if self._watervolume_diskflag_writing:
+            self._watervolume_ncarray[0] = self.watervolume
+        if self._watervolume_ramflag:
+            self._watervolume_array[idx] = self.watervolume
+    cpdef inline set_pointeroutput(self, str name, pointerutils.PDouble value):
+        if name == "watervolume":
+            self._watervolume_outputpointer = value.p_value
+    cpdef inline void update_outputs(self) noexcept nogil:
+        if self._watervolume_outputflag:
+            self._watervolume_outputpointer[0] = self.watervolume
+@cython.final
+cdef class LogSequences:
+    pass
+@cython.final
+cdef class OutletSequences:
+    cpdef inline set_pointer0d(self, str name, pointerutils.Double value):
+        cdef pointerutils.PDouble pointer = pointerutils.PDouble(value)
+        if name == "q":
+            self.q = pointer.p_value
+    cpdef get_value(self, str name):
+        cdef numpy.int64_t idx
+        if name == "q":
+            return self.q[0]
+    cpdef set_value(self, str name, value):
+        if name == "q":
+            self.q[0] = value
+@cython.final
+cdef class SenderSequences:
+    cpdef inline set_pointer0d(self, str name, pointerutils.Double value):
+        cdef pointerutils.PDouble pointer = pointerutils.PDouble(value)
+        if name == "d":
+            self.d = pointer.p_value
+        if name == "s":
+            self.s = pointer.p_value
+        if name == "r":
+            self.r = pointer.p_value
+    cpdef get_value(self, str name):
+        cdef numpy.int64_t idx
+        if name == "d":
+            return self.d[0]
+        if name == "s":
+            return self.s[0]
+        if name == "r":
+            return self.r[0]
+    cpdef set_value(self, str name, value):
+        if name == "d":
+            self.d[0] = value
+        if name == "s":
+            self.s[0] = value
+        if name == "r":
+            self.r[0] = value
+@cython.final
+cdef class NumConsts:
+    pass
+@cython.final
+cdef class NumVars:
+    pass
+@cython.final
+cdef class Model:
+    def __init__(self):
+        super().__init__()
+        self.pemodel = None
+        self.pemodel_is_mainmodel = False
+        self.precipmodel = None
+        self.precipmodel_is_mainmodel = False
+    def get_pemodel(self) -> masterinterface.MasterInterface | None:
+        return self.pemodel
+    def set_pemodel(self, pemodel: masterinterface.MasterInterface | None) -> None:
+        self.pemodel = pemodel
+    def get_precipmodel(self) -> masterinterface.MasterInterface | None:
+        return self.precipmodel
+    def set_precipmodel(self, precipmodel: masterinterface.MasterInterface | None) -> None:
+        self.precipmodel = precipmodel
+    cpdef inline void simulate(self, numpy.int64_t idx)  noexcept nogil:
+        self.idx_sim = idx
+        self.reset_reuseflags()
+        self.load_data(idx)
+        self.update_inlets()
+        self.solve()
+        self.update_outlets()
+        self.update_outputs()
+    cpdef void reset_reuseflags(self) noexcept nogil:
+        if (self.pemodel is not None) and not self.pemodel_is_mainmodel:
+            self.pemodel.reset_reuseflags()
+        if (self.precipmodel is not None) and not self.precipmodel_is_mainmodel:
+            self.precipmodel.reset_reuseflags()
+    cpdef void load_data(self, numpy.int64_t idx) noexcept nogil:
+        self.idx_sim = idx
+        if (self.pemodel is not None) and not self.pemodel_is_mainmodel:
+            self.pemodel.load_data(idx)
+        if (self.precipmodel is not None) and not self.precipmodel_is_mainmodel:
+            self.precipmodel.load_data(idx)
+    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)
+        self.sequences.states.save_data(idx)
+        if (self.pemodel is not None) and not self.pemodel_is_mainmodel:
+            self.pemodel.save_data(idx)
+        if (self.precipmodel is not None) and not self.precipmodel_is_mainmodel:
+            self.precipmodel.save_data(idx)
+    cpdef void new2old(self) noexcept nogil:
+        self.sequences.old_states.watervolume = self.sequences.new_states.watervolume
+        if (self.pemodel is not None) and not self.pemodel_is_mainmodel:
+            self.pemodel.new2old()
+        if (self.precipmodel is not None) and not self.precipmodel_is_mainmodel:
+            self.precipmodel.new2old()
+    cpdef inline void update_inlets(self) noexcept nogil:
+        self.calc_precipitation_v1()
+        self.calc_potentialevaporation_v1()
+        self.calc_adjustedevaporation_v1()
+        self.pic_inflow_v2()
+        self.calc_naturalremotedischarge_v1()
+        self.calc_remotedemand_v1()
+        self.calc_remotefailure_v1()
+        self.calc_requiredremoterelease_v1()
+        self.calc_requiredrelease_v1()
+        self.calc_targetedrelease_v1()
+    cpdef inline void update_outlets(self) noexcept nogil:
+        self.calc_waterlevel_v1()
+        self.pass_outflow_v1()
+        self.update_loggedoutflow_v1()
+    cpdef inline void update_receivers(self, numpy.int64_t idx) noexcept nogil:
+        self.idx_sim = idx
+        self.pic_totalremotedischarge_v1()
+        self.update_loggedtotalremotedischarge_v1()
+    cpdef inline void update_senders(self, numpy.int64_t idx) noexcept nogil:
+        self.idx_sim = idx
+        self.calc_missingremoterelease_v1()
+        self.pass_missingremoterelease_v1()
+        self.calc_allowedremoterelief_v2()
+        self.pass_allowedremoterelief_v1()
+        self.calc_requiredremotesupply_v1()
+        self.pass_requiredremotesupply_v1()
+    cpdef inline void update_outputs(self) noexcept nogil:
+        self.sequences.factors.update_outputs()
+        self.sequences.fluxes.update_outputs()
+        self.sequences.states.update_outputs()
+    cpdef inline void solve(self) noexcept nogil:
+        cdef numpy.int64_t decrease_dt
+        self.numvars.use_relerror = not isnan(            self.parameters.solver.relerrormax        )
+        self.numvars.t0, self.numvars.t1 = 0.0, 1.0
+        self.numvars.dt_est = 1.0 * self.parameters.solver.reldtmax
+        self.numvars.f0_ready = False
+        self.reset_sum_fluxes()
+        while self.numvars.t0 < self.numvars.t1 - 1e-14:
+            self.numvars.last_abserror = inf
+            self.numvars.last_relerror = inf
+            self.numvars.dt = min(                self.numvars.t1 - self.numvars.t0,                1.0 * self.parameters.solver.reldtmax,                max(self.numvars.dt_est, self.parameters.solver.reldtmin),            )
+            if not self.numvars.f0_ready:
+                self.calculate_single_terms()
+                self.numvars.idx_method = 0
+                self.numvars.idx_stage = 0
+                self.set_point_fluxes()
+                self.set_point_states()
+                self.set_result_states()
+            for self.numvars.idx_method in range(1, self.numconsts.nmb_methods + 1):
+                for self.numvars.idx_stage in range(1, self.numvars.idx_method):
+                    self.get_point_states()
+                    self.calculate_single_terms()
+                    self.set_point_fluxes()
+                for self.numvars.idx_stage in range(1, self.numvars.idx_method + 1):
+                    self.integrate_fluxes()
+                    self.calculate_full_terms()
+                    self.set_point_states()
+                self.set_result_fluxes()
+                self.set_result_states()
+                self.calculate_error()
+                self.extrapolate_error()
+                if self.numvars.idx_method == 1:
+                    continue
+                if (self.numvars.abserror <= self.parameters.solver.abserrormax) or (                    self.numvars.relerror <= self.parameters.solver.relerrormax                ):
+                    self.numvars.dt_est = self.numconsts.dt_increase * self.numvars.dt
+                    self.numvars.f0_ready = False
+                    self.addup_fluxes()
+                    self.numvars.t0 = self.numvars.t0 + self.numvars.dt
+                    self.new2old()
+                    break
+                decrease_dt = self.numvars.dt > self.parameters.solver.reldtmin
+                decrease_dt = decrease_dt and (                    self.numvars.extrapolated_abserror                    > self.parameters.solver.abserrormax                )
+                if self.numvars.use_relerror:
+                    decrease_dt = decrease_dt and (                        self.numvars.extrapolated_relerror                        > self.parameters.solver.relerrormax                    )
+                if decrease_dt:
+                    self.numvars.f0_ready = True
+                    self.numvars.dt_est = self.numvars.dt / self.numconsts.dt_decrease
+                    break
+                self.numvars.last_abserror = self.numvars.abserror
+                self.numvars.last_relerror = self.numvars.relerror
+                self.numvars.f0_ready = True
+            else:
+                if self.numvars.dt <= self.parameters.solver.reldtmin:
+                    self.numvars.f0_ready = False
+                    self.addup_fluxes()
+                    self.numvars.t0 = self.numvars.t0 + self.numvars.dt
+                    self.new2old()
+                else:
+                    self.numvars.f0_ready = True
+                    self.numvars.dt_est = self.numvars.dt / self.numconsts.dt_decrease
+        self.get_sum_fluxes()
+    cpdef inline void calculate_single_terms(self) noexcept nogil:
+        self.numvars.nmb_calls = self.numvars.nmb_calls + 1
+        self.calc_adjustedprecipitation_v1()
+        self.pic_inflow_v2()
+        self.calc_waterlevel_v1()
+        self.calc_actualevaporation_v1()
+        self.calc_actualrelease_v1()
+        self.calc_flooddischarge_v1()
+        self.calc_outflow_v1()
+    cpdef inline void calculate_full_terms(self) noexcept nogil:
+        self.update_watervolume_v1()
+    cpdef inline void get_point_states(self) noexcept nogil:
+        self.sequences.states.watervolume = self.sequences.states._watervolume_points[self.numvars.idx_stage]
+    cpdef inline void set_point_states(self) noexcept nogil:
+        self.sequences.states._watervolume_points[self.numvars.idx_stage] = self.sequences.states.watervolume
+    cpdef inline void set_result_states(self) noexcept nogil:
+        self.sequences.states._watervolume_results[self.numvars.idx_method] = self.sequences.states.watervolume
+    cpdef inline void get_sum_fluxes(self) noexcept nogil:
+        self.sequences.fluxes.adjustedprecipitation = self.sequences.fluxes._adjustedprecipitation_sum
+        self.sequences.fluxes.actualevaporation = self.sequences.fluxes._actualevaporation_sum
+        self.sequences.fluxes.inflow = self.sequences.fluxes._inflow_sum
+        self.sequences.fluxes.actualrelease = self.sequences.fluxes._actualrelease_sum
+        self.sequences.fluxes.flooddischarge = self.sequences.fluxes._flooddischarge_sum
+        self.sequences.fluxes.outflow = self.sequences.fluxes._outflow_sum
+    cpdef inline void set_point_fluxes(self) noexcept nogil:
+        self.sequences.fluxes._adjustedprecipitation_points[self.numvars.idx_stage] = self.sequences.fluxes.adjustedprecipitation
+        self.sequences.fluxes._actualevaporation_points[self.numvars.idx_stage] = self.sequences.fluxes.actualevaporation
+        self.sequences.fluxes._inflow_points[self.numvars.idx_stage] = self.sequences.fluxes.inflow
+        self.sequences.fluxes._actualrelease_points[self.numvars.idx_stage] = self.sequences.fluxes.actualrelease
+        self.sequences.fluxes._flooddischarge_points[self.numvars.idx_stage] = self.sequences.fluxes.flooddischarge
+        self.sequences.fluxes._outflow_points[self.numvars.idx_stage] = self.sequences.fluxes.outflow
+    cpdef inline void set_result_fluxes(self) noexcept nogil:
+        self.sequences.fluxes._adjustedprecipitation_results[self.numvars.idx_method] = self.sequences.fluxes.adjustedprecipitation
+        self.sequences.fluxes._actualevaporation_results[self.numvars.idx_method] = self.sequences.fluxes.actualevaporation
+        self.sequences.fluxes._inflow_results[self.numvars.idx_method] = self.sequences.fluxes.inflow
+        self.sequences.fluxes._actualrelease_results[self.numvars.idx_method] = self.sequences.fluxes.actualrelease
+        self.sequences.fluxes._flooddischarge_results[self.numvars.idx_method] = self.sequences.fluxes.flooddischarge
+        self.sequences.fluxes._outflow_results[self.numvars.idx_method] = self.sequences.fluxes.outflow
+    cpdef inline void integrate_fluxes(self) noexcept nogil:
+        cdef numpy.int64_t jdx
+        self.sequences.fluxes.adjustedprecipitation = 0.
+        for jdx in range(self.numvars.idx_method):
+            self.sequences.fluxes.adjustedprecipitation = self.sequences.fluxes.adjustedprecipitation +self.numvars.dt * self.numconsts.a_coefs[self.numvars.idx_method-1, self.numvars.idx_stage, jdx]*self.sequences.fluxes._adjustedprecipitation_points[jdx]
+        self.sequences.fluxes.actualevaporation = 0.
+        for jdx in range(self.numvars.idx_method):
+            self.sequences.fluxes.actualevaporation = self.sequences.fluxes.actualevaporation +self.numvars.dt * self.numconsts.a_coefs[self.numvars.idx_method-1, self.numvars.idx_stage, jdx]*self.sequences.fluxes._actualevaporation_points[jdx]
+        self.sequences.fluxes.inflow = 0.
+        for jdx in range(self.numvars.idx_method):
+            self.sequences.fluxes.inflow = self.sequences.fluxes.inflow +self.numvars.dt * self.numconsts.a_coefs[self.numvars.idx_method-1, self.numvars.idx_stage, jdx]*self.sequences.fluxes._inflow_points[jdx]
+        self.sequences.fluxes.actualrelease = 0.
+        for jdx in range(self.numvars.idx_method):
+            self.sequences.fluxes.actualrelease = self.sequences.fluxes.actualrelease +self.numvars.dt * self.numconsts.a_coefs[self.numvars.idx_method-1, self.numvars.idx_stage, jdx]*self.sequences.fluxes._actualrelease_points[jdx]
+        self.sequences.fluxes.flooddischarge = 0.
+        for jdx in range(self.numvars.idx_method):
+            self.sequences.fluxes.flooddischarge = self.sequences.fluxes.flooddischarge +self.numvars.dt * self.numconsts.a_coefs[self.numvars.idx_method-1, self.numvars.idx_stage, jdx]*self.sequences.fluxes._flooddischarge_points[jdx]
+        self.sequences.fluxes.outflow = 0.
+        for jdx in range(self.numvars.idx_method):
+            self.sequences.fluxes.outflow = self.sequences.fluxes.outflow +self.numvars.dt * self.numconsts.a_coefs[self.numvars.idx_method-1, self.numvars.idx_stage, jdx]*self.sequences.fluxes._outflow_points[jdx]
+    cpdef inline void reset_sum_fluxes(self) noexcept nogil:
+        self.sequences.fluxes._adjustedprecipitation_sum = 0.
+        self.sequences.fluxes._actualevaporation_sum = 0.
+        self.sequences.fluxes._inflow_sum = 0.
+        self.sequences.fluxes._actualrelease_sum = 0.
+        self.sequences.fluxes._flooddischarge_sum = 0.
+        self.sequences.fluxes._outflow_sum = 0.
+    cpdef inline void addup_fluxes(self) noexcept nogil:
+        self.sequences.fluxes._adjustedprecipitation_sum = self.sequences.fluxes._adjustedprecipitation_sum + self.sequences.fluxes.adjustedprecipitation
+        self.sequences.fluxes._actualevaporation_sum = self.sequences.fluxes._actualevaporation_sum + self.sequences.fluxes.actualevaporation
+        self.sequences.fluxes._inflow_sum = self.sequences.fluxes._inflow_sum + self.sequences.fluxes.inflow
+        self.sequences.fluxes._actualrelease_sum = self.sequences.fluxes._actualrelease_sum + self.sequences.fluxes.actualrelease
+        self.sequences.fluxes._flooddischarge_sum = self.sequences.fluxes._flooddischarge_sum + self.sequences.fluxes.flooddischarge
+        self.sequences.fluxes._outflow_sum = self.sequences.fluxes._outflow_sum + self.sequences.fluxes.outflow
+    cpdef inline void calculate_error(self) noexcept nogil:
+        cdef double abserror
+        self.numvars.abserror = 0.
+        if self.numvars.use_relerror:
+            self.numvars.relerror = 0.
+        else:
+            self.numvars.relerror = inf
+        abserror = fabs(self.sequences.fluxes._adjustedprecipitation_results[self.numvars.idx_method]-self.sequences.fluxes._adjustedprecipitation_results[self.numvars.idx_method-1])
+        self.numvars.abserror = max(self.numvars.abserror, abserror)
+        if self.numvars.use_relerror:
+            if self.sequences.fluxes._adjustedprecipitation_results[self.numvars.idx_method] == 0.:
+                self.numvars.relerror = inf
+            else:
+                self.numvars.relerror = max(self.numvars.relerror, fabs(abserror/self.sequences.fluxes._adjustedprecipitation_results[self.numvars.idx_method]))
+        abserror = fabs(self.sequences.fluxes._actualevaporation_results[self.numvars.idx_method]-self.sequences.fluxes._actualevaporation_results[self.numvars.idx_method-1])
+        self.numvars.abserror = max(self.numvars.abserror, abserror)
+        if self.numvars.use_relerror:
+            if self.sequences.fluxes._actualevaporation_results[self.numvars.idx_method] == 0.:
+                self.numvars.relerror = inf
+            else:
+                self.numvars.relerror = max(self.numvars.relerror, fabs(abserror/self.sequences.fluxes._actualevaporation_results[self.numvars.idx_method]))
+        abserror = fabs(self.sequences.fluxes._inflow_results[self.numvars.idx_method]-self.sequences.fluxes._inflow_results[self.numvars.idx_method-1])
+        self.numvars.abserror = max(self.numvars.abserror, abserror)
+        if self.numvars.use_relerror:
+            if self.sequences.fluxes._inflow_results[self.numvars.idx_method] == 0.:
+                self.numvars.relerror = inf
+            else:
+                self.numvars.relerror = max(self.numvars.relerror, fabs(abserror/self.sequences.fluxes._inflow_results[self.numvars.idx_method]))
+        abserror = fabs(self.sequences.fluxes._actualrelease_results[self.numvars.idx_method]-self.sequences.fluxes._actualrelease_results[self.numvars.idx_method-1])
+        self.numvars.abserror = max(self.numvars.abserror, abserror)
+        if self.numvars.use_relerror:
+            if self.sequences.fluxes._actualrelease_results[self.numvars.idx_method] == 0.:
+                self.numvars.relerror = inf
+            else:
+                self.numvars.relerror = max(self.numvars.relerror, fabs(abserror/self.sequences.fluxes._actualrelease_results[self.numvars.idx_method]))
+        abserror = fabs(self.sequences.fluxes._flooddischarge_results[self.numvars.idx_method]-self.sequences.fluxes._flooddischarge_results[self.numvars.idx_method-1])
+        self.numvars.abserror = max(self.numvars.abserror, abserror)
+        if self.numvars.use_relerror:
+            if self.sequences.fluxes._flooddischarge_results[self.numvars.idx_method] == 0.:
+                self.numvars.relerror = inf
+            else:
+                self.numvars.relerror = max(self.numvars.relerror, fabs(abserror/self.sequences.fluxes._flooddischarge_results[self.numvars.idx_method]))
+        abserror = fabs(self.sequences.fluxes._outflow_results[self.numvars.idx_method]-self.sequences.fluxes._outflow_results[self.numvars.idx_method-1])
+        self.numvars.abserror = max(self.numvars.abserror, abserror)
+        if self.numvars.use_relerror:
+            if self.sequences.fluxes._outflow_results[self.numvars.idx_method] == 0.:
+                self.numvars.relerror = inf
+            else:
+                self.numvars.relerror = max(self.numvars.relerror, fabs(abserror/self.sequences.fluxes._outflow_results[self.numvars.idx_method]))
+    cpdef inline void extrapolate_error(self) noexcept nogil:
+        if self.numvars.abserror <= 0.0:
+            self.numvars.extrapolated_abserror = 0.0
+            self.numvars.extrapolated_relerror = 0.0
+        else:
+            if self.numvars.idx_method > 2:
+                self.numvars.extrapolated_abserror = exp(                    log(self.numvars.abserror)                    + (                        log(self.numvars.abserror)                        - log(self.numvars.last_abserror)                    )                    * (self.numconsts.nmb_methods - self.numvars.idx_method)                )
+            else:
+                self.numvars.extrapolated_abserror = -999.9
+            if self.numvars.use_relerror:
+                if self.numvars.idx_method > 2:
+                    if isinf(self.numvars.relerror):
+                        self.numvars.extrapolated_relerror = inf
+                    else:
+                        self.numvars.extrapolated_relerror = exp(                            log(self.numvars.relerror)                            + (                                log(self.numvars.relerror)                                - log(self.numvars.last_relerror)                            )                            * (self.numconsts.nmb_methods - self.numvars.idx_method)                        )
+                else:
+                    self.numvars.extrapolated_relerror = -999.9
+            else:
+                self.numvars.extrapolated_relerror = inf
+    cpdef inline void pic_totalremotedischarge_v1(self) noexcept nogil:
+        self.sequences.fluxes.totalremotedischarge = self.sequences.receivers.q[0]
+    cpdef inline void update_loggedtotalremotedischarge_v1(self) noexcept nogil:
+        cdef numpy.int64_t i
+        for i in range(self.parameters.control.nmblogentries - 1, 0, -1):
+            self.sequences.logs.loggedtotalremotedischarge[i] = self.sequences.logs.loggedtotalremotedischarge[i - 1]
+        self.sequences.logs.loggedtotalremotedischarge[0] = self.sequences.fluxes.totalremotedischarge
+    cpdef inline void calc_precipitation_v1(self) noexcept nogil:
+        if self.precipmodel is None:
+            self.sequences.fluxes.precipitation = 0.0
+        elif self.precipmodel_typeid == 2:
+            (<masterinterface.MasterInterface>self.precipmodel).determine_precipitation()
+            self.sequences.fluxes.precipitation = (<masterinterface.MasterInterface>self.precipmodel).get_precipitation(0)
+    cpdef inline void calc_potentialevaporation_v1(self) noexcept nogil:
+        if self.pemodel is None:
+            self.sequences.fluxes.potentialevaporation = 0.0
+        elif self.pemodel_typeid == 1:
+            (<masterinterface.MasterInterface>self.pemodel).determine_potentialevapotranspiration()
+            self.sequences.fluxes.potentialevaporation = (<masterinterface.MasterInterface>self.pemodel).get_potentialevapotranspiration(0)
+    cpdef inline void calc_adjustedevaporation_v1(self) noexcept nogil:
+        cdef double d_old
+        cdef double d_new
+        cdef double d_weight
+        d_weight = self.parameters.control.weightevaporation
+        d_new = self.parameters.derived.inputfactor * self.parameters.control.correctionevaporation * self.sequences.fluxes.potentialevaporation
+        d_old = self.sequences.logs.loggedadjustedevaporation[0]
+        self.sequences.fluxes.adjustedevaporation = d_weight * d_new + (1.0 - d_weight) * d_old
+        self.sequences.logs.loggedadjustedevaporation[0] = self.sequences.fluxes.adjustedevaporation
+    cpdef inline void pic_inflow_v2(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        self.sequences.fluxes.inflow = self.sequences.inlets.s[0] + self.sequences.inlets.r[0]
+        for idx in range(self.sequences.inlets.len_q):
+            self.sequences.fluxes.inflow = self.sequences.fluxes.inflow + (self.sequences.inlets.q[idx][0])
+    cpdef inline void calc_naturalremotedischarge_v1(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        self.sequences.fluxes.naturalremotedischarge = 0.0
+        for idx in range(self.parameters.control.nmblogentries):
+            self.sequences.fluxes.naturalremotedischarge = self.sequences.fluxes.naturalremotedischarge + ((                self.sequences.logs.loggedtotalremotedischarge[idx] - self.sequences.logs.loggedoutflow[idx]            ))
+        if self.sequences.fluxes.naturalremotedischarge > 0.0:
+            self.sequences.fluxes.naturalremotedischarge = self.sequences.fluxes.naturalremotedischarge / (self.parameters.control.nmblogentries)
+        else:
+            self.sequences.fluxes.naturalremotedischarge = 0.0
+    cpdef inline void calc_remotedemand_v1(self) noexcept nogil:
+        cdef double d_rdm
+        d_rdm = self.parameters.control.remotedischargeminimum[self.parameters.derived.toy[self.idx_sim]]
+        self.sequences.fluxes.remotedemand = max(d_rdm - self.sequences.fluxes.naturalremotedischarge, 0.0)
+    cpdef inline void calc_remotefailure_v1(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        self.sequences.fluxes.remotefailure = 0
+        for idx in range(self.parameters.control.nmblogentries):
+            self.sequences.fluxes.remotefailure = self.sequences.fluxes.remotefailure - (self.sequences.logs.loggedtotalremotedischarge[idx])
+        self.sequences.fluxes.remotefailure = self.sequences.fluxes.remotefailure / (self.parameters.control.nmblogentries)
+        self.sequences.fluxes.remotefailure = self.sequences.fluxes.remotefailure + (self.parameters.control.remotedischargeminimum[self.parameters.derived.toy[self.idx_sim]])
+    cpdef inline void calc_requiredremoterelease_v1(self) noexcept nogil:
+        self.sequences.fluxes.requiredremoterelease = self.sequences.fluxes.remotedemand + (            smoothutils.smooth_logistic1(                self.sequences.fluxes.remotefailure, self.parameters.derived.remotedischargesmoothpar[self.parameters.derived.toy[self.idx_sim]]            )            * self.parameters.control.remotedischargesafety[self.parameters.derived.toy[self.idx_sim]]        )
+    cpdef inline void calc_requiredrelease_v1(self) noexcept nogil:
+        self.sequences.fluxes.requiredrelease = self.parameters.control.neardischargeminimumthreshold[self.parameters.derived.toy[self.idx_sim]]
+        self.sequences.fluxes.requiredrelease = self.sequences.fluxes.requiredrelease + smoothutils.smooth_logistic2(            self.sequences.fluxes.requiredremoterelease - self.sequences.fluxes.requiredrelease,            self.parameters.derived.neardischargeminimumsmoothpar2[self.parameters.derived.toy[self.idx_sim]],        )
+    cpdef inline void calc_targetedrelease_v1(self) noexcept nogil:
+        if self.parameters.control.restricttargetedrelease:
+            self.sequences.fluxes.targetedrelease = smoothutils.smooth_logistic1(                self.sequences.fluxes.inflow - self.parameters.control.neardischargeminimumthreshold[self.parameters.derived.toy[self.idx_sim]],                self.parameters.derived.neardischargeminimumsmoothpar1[self.parameters.derived.toy[self.idx_sim]],            )
+            self.sequences.fluxes.targetedrelease = (                self.sequences.fluxes.targetedrelease * self.sequences.fluxes.requiredrelease                + (1.0 - self.sequences.fluxes.targetedrelease) * self.sequences.fluxes.inflow            )
+        else:
+            self.sequences.fluxes.targetedrelease = self.sequences.fluxes.requiredrelease
+    cpdef inline void calc_adjustedprecipitation_v1(self) noexcept nogil:
+        self.sequences.fluxes.adjustedprecipitation = (            self.parameters.derived.inputfactor * self.parameters.control.correctionprecipitation * self.sequences.fluxes.precipitation        )
+    cpdef inline void calc_waterlevel_v1(self) noexcept nogil:
+        self.parameters.control.watervolume2waterlevel.inputs[0] = self.sequences.new_states.watervolume
+        self.parameters.control.watervolume2waterlevel.calculate_values()
+        self.sequences.factors.waterlevel = self.parameters.control.watervolume2waterlevel.outputs[0]
+    cpdef inline void calc_actualevaporation_v1(self) noexcept nogil:
+        self.sequences.fluxes.actualevaporation = self.sequences.fluxes.adjustedevaporation * smoothutils.smooth_logistic1(            self.sequences.factors.waterlevel - self.parameters.control.thresholdevaporation, self.parameters.derived.smoothparevaporation        )
+    cpdef inline void calc_actualrelease_v1(self) noexcept nogil:
+        self.sequences.fluxes.actualrelease = self.sequences.fluxes.targetedrelease * smoothutils.smooth_logistic1(            self.sequences.factors.waterlevel - self.parameters.control.waterlevelminimumthreshold,            self.parameters.derived.waterlevelminimumsmoothpar,        )
+    cpdef inline void calc_flooddischarge_v1(self) noexcept nogil:
+        self.parameters.control.waterlevel2flooddischarge.inputs[0] = self.sequences.factors.waterlevel
+        self.parameters.control.waterlevel2flooddischarge.calculate_values(self.parameters.derived.toy[self.idx_sim])
+        self.sequences.fluxes.flooddischarge = self.parameters.control.waterlevel2flooddischarge.outputs[0]
+    cpdef inline void calc_outflow_v1(self) noexcept nogil:
+        self.sequences.fluxes.outflow = max(self.sequences.fluxes.actualrelease + self.sequences.fluxes.flooddischarge, 0.0)
+    cpdef inline void update_watervolume_v1(self) noexcept nogil:
+        self.sequences.new_states.watervolume = self.sequences.old_states.watervolume + self.parameters.derived.seconds / 1e6 * (            self.sequences.fluxes.adjustedprecipitation - self.sequences.fluxes.actualevaporation + self.sequences.fluxes.inflow - self.sequences.fluxes.outflow        )
+    cpdef inline void pass_outflow_v1(self) noexcept nogil:
+        self.sequences.outlets.q[0] = self.sequences.outlets.q[0] + (self.sequences.fluxes.outflow)
+    cpdef inline void update_loggedoutflow_v1(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        for idx in range(self.parameters.control.nmblogentries - 1, 0, -1):
+            self.sequences.logs.loggedoutflow[idx] = self.sequences.logs.loggedoutflow[idx - 1]
+        self.sequences.logs.loggedoutflow[0] = self.sequences.fluxes.outflow
+    cpdef inline void calc_missingremoterelease_v1(self) noexcept nogil:
+        self.sequences.fluxes.missingremoterelease = max(            self.sequences.fluxes.requiredremoterelease - self.sequences.fluxes.actualrelease, 0.0        )
+    cpdef inline void pass_missingremoterelease_v1(self) noexcept nogil:
+        self.sequences.senders.d[0] = self.sequences.senders.d[0] + (self.sequences.fluxes.missingremoterelease)
+    cpdef inline void calc_allowedremoterelief_v2(self) noexcept nogil:
+        cdef numpy.int64_t toy
+        toy = self.parameters.derived.toy[self.idx_sim]
+        self.sequences.fluxes.allowedremoterelief = (            smoothutils.smooth_logistic1(                self.parameters.control.waterlevelreliefthreshold[toy] - self.sequences.factors.waterlevel,                self.parameters.derived.waterlevelreliefsmoothpar[toy],            )            * self.parameters.control.highestremoterelief[toy]        )
+    cpdef inline void pass_allowedremoterelief_v1(self) noexcept nogil:
+        self.sequences.senders.r[0] = self.sequences.senders.r[0] + (self.sequences.fluxes.allowedremoterelief)
+    cpdef inline void calc_requiredremotesupply_v1(self) noexcept nogil:
+        cdef numpy.int64_t toy
+        toy = self.parameters.derived.toy[self.idx_sim]
+        self.sequences.fluxes.requiredremotesupply = (            smoothutils.smooth_logistic1(                self.parameters.control.waterlevelsupplythreshold[toy] - self.sequences.factors.waterlevel,                self.parameters.derived.waterlevelsupplysmoothpar[toy],            )            * self.parameters.control.highestremotesupply[toy]        )
+    cpdef inline void pass_requiredremotesupply_v1(self) noexcept nogil:
+        self.sequences.senders.s[0] = self.sequences.senders.s[0] + (self.sequences.fluxes.requiredremotesupply)
+    cpdef inline void pic_totalremotedischarge(self) noexcept nogil:
+        self.sequences.fluxes.totalremotedischarge = self.sequences.receivers.q[0]
+    cpdef inline void update_loggedtotalremotedischarge(self) noexcept nogil:
+        cdef numpy.int64_t i
+        for i in range(self.parameters.control.nmblogentries - 1, 0, -1):
+            self.sequences.logs.loggedtotalremotedischarge[i] = self.sequences.logs.loggedtotalremotedischarge[i - 1]
+        self.sequences.logs.loggedtotalremotedischarge[0] = self.sequences.fluxes.totalremotedischarge
+    cpdef inline void calc_precipitation(self) noexcept nogil:
+        if self.precipmodel is None:
+            self.sequences.fluxes.precipitation = 0.0
+        elif self.precipmodel_typeid == 2:
+            (<masterinterface.MasterInterface>self.precipmodel).determine_precipitation()
+            self.sequences.fluxes.precipitation = (<masterinterface.MasterInterface>self.precipmodel).get_precipitation(0)
+    cpdef inline void calc_potentialevaporation(self) noexcept nogil:
+        if self.pemodel is None:
+            self.sequences.fluxes.potentialevaporation = 0.0
+        elif self.pemodel_typeid == 1:
+            (<masterinterface.MasterInterface>self.pemodel).determine_potentialevapotranspiration()
+            self.sequences.fluxes.potentialevaporation = (<masterinterface.MasterInterface>self.pemodel).get_potentialevapotranspiration(0)
+    cpdef inline void calc_adjustedevaporation(self) noexcept nogil:
+        cdef double d_old
+        cdef double d_new
+        cdef double d_weight
+        d_weight = self.parameters.control.weightevaporation
+        d_new = self.parameters.derived.inputfactor * self.parameters.control.correctionevaporation * self.sequences.fluxes.potentialevaporation
+        d_old = self.sequences.logs.loggedadjustedevaporation[0]
+        self.sequences.fluxes.adjustedevaporation = d_weight * d_new + (1.0 - d_weight) * d_old
+        self.sequences.logs.loggedadjustedevaporation[0] = self.sequences.fluxes.adjustedevaporation
+    cpdef inline void pic_inflow(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        self.sequences.fluxes.inflow = self.sequences.inlets.s[0] + self.sequences.inlets.r[0]
+        for idx in range(self.sequences.inlets.len_q):
+            self.sequences.fluxes.inflow = self.sequences.fluxes.inflow + (self.sequences.inlets.q[idx][0])
+    cpdef inline void calc_naturalremotedischarge(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        self.sequences.fluxes.naturalremotedischarge = 0.0
+        for idx in range(self.parameters.control.nmblogentries):
+            self.sequences.fluxes.naturalremotedischarge = self.sequences.fluxes.naturalremotedischarge + ((                self.sequences.logs.loggedtotalremotedischarge[idx] - self.sequences.logs.loggedoutflow[idx]            ))
+        if self.sequences.fluxes.naturalremotedischarge > 0.0:
+            self.sequences.fluxes.naturalremotedischarge = self.sequences.fluxes.naturalremotedischarge / (self.parameters.control.nmblogentries)
+        else:
+            self.sequences.fluxes.naturalremotedischarge = 0.0
+    cpdef inline void calc_remotedemand(self) noexcept nogil:
+        cdef double d_rdm
+        d_rdm = self.parameters.control.remotedischargeminimum[self.parameters.derived.toy[self.idx_sim]]
+        self.sequences.fluxes.remotedemand = max(d_rdm - self.sequences.fluxes.naturalremotedischarge, 0.0)
+    cpdef inline void calc_remotefailure(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        self.sequences.fluxes.remotefailure = 0
+        for idx in range(self.parameters.control.nmblogentries):
+            self.sequences.fluxes.remotefailure = self.sequences.fluxes.remotefailure - (self.sequences.logs.loggedtotalremotedischarge[idx])
+        self.sequences.fluxes.remotefailure = self.sequences.fluxes.remotefailure / (self.parameters.control.nmblogentries)
+        self.sequences.fluxes.remotefailure = self.sequences.fluxes.remotefailure + (self.parameters.control.remotedischargeminimum[self.parameters.derived.toy[self.idx_sim]])
+    cpdef inline void calc_requiredremoterelease(self) noexcept nogil:
+        self.sequences.fluxes.requiredremoterelease = self.sequences.fluxes.remotedemand + (            smoothutils.smooth_logistic1(                self.sequences.fluxes.remotefailure, self.parameters.derived.remotedischargesmoothpar[self.parameters.derived.toy[self.idx_sim]]            )            * self.parameters.control.remotedischargesafety[self.parameters.derived.toy[self.idx_sim]]        )
+    cpdef inline void calc_requiredrelease(self) noexcept nogil:
+        self.sequences.fluxes.requiredrelease = self.parameters.control.neardischargeminimumthreshold[self.parameters.derived.toy[self.idx_sim]]
+        self.sequences.fluxes.requiredrelease = self.sequences.fluxes.requiredrelease + smoothutils.smooth_logistic2(            self.sequences.fluxes.requiredremoterelease - self.sequences.fluxes.requiredrelease,            self.parameters.derived.neardischargeminimumsmoothpar2[self.parameters.derived.toy[self.idx_sim]],        )
+    cpdef inline void calc_targetedrelease(self) noexcept nogil:
+        if self.parameters.control.restricttargetedrelease:
+            self.sequences.fluxes.targetedrelease = smoothutils.smooth_logistic1(                self.sequences.fluxes.inflow - self.parameters.control.neardischargeminimumthreshold[self.parameters.derived.toy[self.idx_sim]],                self.parameters.derived.neardischargeminimumsmoothpar1[self.parameters.derived.toy[self.idx_sim]],            )
+            self.sequences.fluxes.targetedrelease = (                self.sequences.fluxes.targetedrelease * self.sequences.fluxes.requiredrelease                + (1.0 - self.sequences.fluxes.targetedrelease) * self.sequences.fluxes.inflow            )
+        else:
+            self.sequences.fluxes.targetedrelease = self.sequences.fluxes.requiredrelease
+    cpdef inline void calc_adjustedprecipitation(self) noexcept nogil:
+        self.sequences.fluxes.adjustedprecipitation = (            self.parameters.derived.inputfactor * self.parameters.control.correctionprecipitation * self.sequences.fluxes.precipitation        )
+    cpdef inline void calc_waterlevel(self) noexcept nogil:
+        self.parameters.control.watervolume2waterlevel.inputs[0] = self.sequences.new_states.watervolume
+        self.parameters.control.watervolume2waterlevel.calculate_values()
+        self.sequences.factors.waterlevel = self.parameters.control.watervolume2waterlevel.outputs[0]
+    cpdef inline void calc_actualevaporation(self) noexcept nogil:
+        self.sequences.fluxes.actualevaporation = self.sequences.fluxes.adjustedevaporation * smoothutils.smooth_logistic1(            self.sequences.factors.waterlevel - self.parameters.control.thresholdevaporation, self.parameters.derived.smoothparevaporation        )
+    cpdef inline void calc_actualrelease(self) noexcept nogil:
+        self.sequences.fluxes.actualrelease = self.sequences.fluxes.targetedrelease * smoothutils.smooth_logistic1(            self.sequences.factors.waterlevel - self.parameters.control.waterlevelminimumthreshold,            self.parameters.derived.waterlevelminimumsmoothpar,        )
+    cpdef inline void calc_flooddischarge(self) noexcept nogil:
+        self.parameters.control.waterlevel2flooddischarge.inputs[0] = self.sequences.factors.waterlevel
+        self.parameters.control.waterlevel2flooddischarge.calculate_values(self.parameters.derived.toy[self.idx_sim])
+        self.sequences.fluxes.flooddischarge = self.parameters.control.waterlevel2flooddischarge.outputs[0]
+    cpdef inline void calc_outflow(self) noexcept nogil:
+        self.sequences.fluxes.outflow = max(self.sequences.fluxes.actualrelease + self.sequences.fluxes.flooddischarge, 0.0)
+    cpdef inline void update_watervolume(self) noexcept nogil:
+        self.sequences.new_states.watervolume = self.sequences.old_states.watervolume + self.parameters.derived.seconds / 1e6 * (            self.sequences.fluxes.adjustedprecipitation - self.sequences.fluxes.actualevaporation + self.sequences.fluxes.inflow - self.sequences.fluxes.outflow        )
+    cpdef inline void pass_outflow(self) noexcept nogil:
+        self.sequences.outlets.q[0] = self.sequences.outlets.q[0] + (self.sequences.fluxes.outflow)
+    cpdef inline void update_loggedoutflow(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        for idx in range(self.parameters.control.nmblogentries - 1, 0, -1):
+            self.sequences.logs.loggedoutflow[idx] = self.sequences.logs.loggedoutflow[idx - 1]
+        self.sequences.logs.loggedoutflow[0] = self.sequences.fluxes.outflow
+    cpdef inline void calc_missingremoterelease(self) noexcept nogil:
+        self.sequences.fluxes.missingremoterelease = max(            self.sequences.fluxes.requiredremoterelease - self.sequences.fluxes.actualrelease, 0.0        )
+    cpdef inline void pass_missingremoterelease(self) noexcept nogil:
+        self.sequences.senders.d[0] = self.sequences.senders.d[0] + (self.sequences.fluxes.missingremoterelease)
+    cpdef inline void calc_allowedremoterelief(self) noexcept nogil:
+        cdef numpy.int64_t toy
+        toy = self.parameters.derived.toy[self.idx_sim]
+        self.sequences.fluxes.allowedremoterelief = (            smoothutils.smooth_logistic1(                self.parameters.control.waterlevelreliefthreshold[toy] - self.sequences.factors.waterlevel,                self.parameters.derived.waterlevelreliefsmoothpar[toy],            )            * self.parameters.control.highestremoterelief[toy]        )
+    cpdef inline void pass_allowedremoterelief(self) noexcept nogil:
+        self.sequences.senders.r[0] = self.sequences.senders.r[0] + (self.sequences.fluxes.allowedremoterelief)
+    cpdef inline void calc_requiredremotesupply(self) noexcept nogil:
+        cdef numpy.int64_t toy
+        toy = self.parameters.derived.toy[self.idx_sim]
+        self.sequences.fluxes.requiredremotesupply = (            smoothutils.smooth_logistic1(                self.parameters.control.waterlevelsupplythreshold[toy] - self.sequences.factors.waterlevel,                self.parameters.derived.waterlevelsupplysmoothpar[toy],            )            * self.parameters.control.highestremotesupply[toy]        )
+    cpdef inline void pass_requiredremotesupply(self) noexcept nogil:
+        self.sequences.senders.s[0] = self.sequences.senders.s[0] + (self.sequences.fluxes.requiredremotesupply)