HydPy 6.2.dev1__cp313-cp313-win_amd64.whl

hydpy/cythons/autogen/c_dam_v004.pyx

@@ -0,0 +1,891 @@
+#!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 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
+    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]
+@cython.final
+cdef class ReceiverSequences:
+    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 get_value(self, str name):
+        cdef numpy.int64_t idx
+        if name == "s":
+            return self.s[0]
+        if name == "r":
+            return self.r[0]
+    cpdef set_value(self, str name, value):
+        if name == "s":
+            self.s[0] = value
+        if name == "r":
+            self.r[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._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._possibleremoterelief_diskflag_reading:
+            self.possibleremoterelief = self._possibleremoterelief_ncarray[0]
+        elif self._possibleremoterelief_ramflag:
+            self.possibleremoterelief = self._possibleremoterelief_array[idx]
+        if self._actualremoterelief_diskflag_reading:
+            self.actualremoterelief = self._actualremoterelief_ncarray[0]
+        elif self._actualremoterelief_ramflag:
+            self.actualremoterelief = self._actualremoterelief_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._actualremoterelease_diskflag_reading:
+            self.actualremoterelease = self._actualremoterelease_ncarray[0]
+        elif self._actualremoterelease_ramflag:
+            self.actualremoterelease = self._actualremoterelease_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._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._possibleremoterelief_diskflag_writing:
+            self._possibleremoterelief_ncarray[0] = self.possibleremoterelief
+        if self._possibleremoterelief_ramflag:
+            self._possibleremoterelief_array[idx] = self.possibleremoterelief
+        if self._actualremoterelief_diskflag_writing:
+            self._actualremoterelief_ncarray[0] = self.actualremoterelief
+        if self._actualremoterelief_ramflag:
+            self._actualremoterelief_array[idx] = self.actualremoterelief
+        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._actualremoterelease_diskflag_writing:
+            self._actualremoterelease_ncarray[0] = self.actualremoterelease
+        if self._actualremoterelease_ramflag:
+            self._actualremoterelease_array[idx] = self.actualremoterelease
+        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 == "requiredremoterelease":
+            self._requiredremoterelease_outputpointer = value.p_value
+        if name == "allowedremoterelief":
+            self._allowedremoterelief_outputpointer = value.p_value
+        if name == "possibleremoterelief":
+            self._possibleremoterelief_outputpointer = value.p_value
+        if name == "actualremoterelief":
+            self._actualremoterelief_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 == "actualremoterelease":
+            self._actualremoterelease_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._requiredremoterelease_outputflag:
+            self._requiredremoterelease_outputpointer[0] = self.requiredremoterelease
+        if self._allowedremoterelief_outputflag:
+            self._allowedremoterelief_outputpointer[0] = self.allowedremoterelief
+        if self._possibleremoterelief_outputflag:
+            self._possibleremoterelief_outputpointer[0] = self.possibleremoterelief
+        if self._actualremoterelief_outputflag:
+            self._actualremoterelief_outputpointer[0] = self.actualremoterelief
+        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._actualremoterelease_outputflag:
+            self._actualremoterelease_outputpointer[0] = self.actualremoterelease
+        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
+        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 == "q":
+            return self.q[0]
+        if name == "s":
+            return self.s[0]
+        if name == "r":
+            return self.r[0]
+    cpdef set_value(self, str name, value):
+        if name == "q":
+            self.q[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_v1()
+        self.calc_requiredremoterelease_v2()
+        self.calc_allowedremoterelief_v1()
+        self.calc_requiredrelease_v2()
+        self.calc_targetedrelease_v1()
+    cpdef inline void update_outlets(self) noexcept nogil:
+        self.calc_waterlevel_v1()
+        self.pass_outflow_v1()
+        self.pass_actualremoterelease_v1()
+        self.pass_actualremoterelief_v1()
+    cpdef inline void update_receivers(self, numpy.int64_t idx) noexcept nogil:
+        self.idx_sim = idx
+        self.pic_loggedrequiredremoterelease_v2()
+        self.pic_loggedallowedremoterelief_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()
+        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_v1()
+        self.calc_waterlevel_v1()
+        self.calc_actualevaporation_v1()
+        self.calc_actualrelease_v1()
+        self.calc_possibleremoterelief_v1()
+        self.calc_actualremoterelief_v1()
+        self.calc_actualremoterelease_v1()
+        self.update_actualremoterelease_v1()
+        self.update_actualremoterelief_v1()
+        self.calc_flooddischarge_v1()
+        self.calc_outflow_v1()
+    cpdef inline void calculate_full_terms(self) noexcept nogil:
+        self.update_watervolume_v3()
+    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.possibleremoterelief = self.sequences.fluxes._possibleremoterelief_sum
+        self.sequences.fluxes.actualremoterelief = self.sequences.fluxes._actualremoterelief_sum
+        self.sequences.fluxes.actualrelease = self.sequences.fluxes._actualrelease_sum
+        self.sequences.fluxes.actualremoterelease = self.sequences.fluxes._actualremoterelease_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._possibleremoterelief_points[self.numvars.idx_stage] = self.sequences.fluxes.possibleremoterelief
+        self.sequences.fluxes._actualremoterelief_points[self.numvars.idx_stage] = self.sequences.fluxes.actualremoterelief
+        self.sequences.fluxes._actualrelease_points[self.numvars.idx_stage] = self.sequences.fluxes.actualrelease
+        self.sequences.fluxes._actualremoterelease_points[self.numvars.idx_stage] = self.sequences.fluxes.actualremoterelease
+        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._possibleremoterelief_results[self.numvars.idx_method] = self.sequences.fluxes.possibleremoterelief
+        self.sequences.fluxes._actualremoterelief_results[self.numvars.idx_method] = self.sequences.fluxes.actualremoterelief
+        self.sequences.fluxes._actualrelease_results[self.numvars.idx_method] = self.sequences.fluxes.actualrelease
+        self.sequences.fluxes._actualremoterelease_results[self.numvars.idx_method] = self.sequences.fluxes.actualremoterelease
+        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.possibleremoterelief = 0.
+        for jdx in range(self.numvars.idx_method):
+            self.sequences.fluxes.possibleremoterelief = self.sequences.fluxes.possibleremoterelief +self.numvars.dt * self.numconsts.a_coefs[self.numvars.idx_method-1, self.numvars.idx_stage, jdx]*self.sequences.fluxes._possibleremoterelief_points[jdx]
+        self.sequences.fluxes.actualremoterelief = 0.
+        for jdx in range(self.numvars.idx_method):
+            self.sequences.fluxes.actualremoterelief = self.sequences.fluxes.actualremoterelief +self.numvars.dt * self.numconsts.a_coefs[self.numvars.idx_method-1, self.numvars.idx_stage, jdx]*self.sequences.fluxes._actualremoterelief_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.actualremoterelease = 0.
+        for jdx in range(self.numvars.idx_method):
+            self.sequences.fluxes.actualremoterelease = self.sequences.fluxes.actualremoterelease +self.numvars.dt * self.numconsts.a_coefs[self.numvars.idx_method-1, self.numvars.idx_stage, jdx]*self.sequences.fluxes._actualremoterelease_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._possibleremoterelief_sum = 0.
+        self.sequences.fluxes._actualremoterelief_sum = 0.
+        self.sequences.fluxes._actualrelease_sum = 0.
+        self.sequences.fluxes._actualremoterelease_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._possibleremoterelief_sum = self.sequences.fluxes._possibleremoterelief_sum + self.sequences.fluxes.possibleremoterelief
+        self.sequences.fluxes._actualremoterelief_sum = self.sequences.fluxes._actualremoterelief_sum + self.sequences.fluxes.actualremoterelief
+        self.sequences.fluxes._actualrelease_sum = self.sequences.fluxes._actualrelease_sum + self.sequences.fluxes.actualrelease
+        self.sequences.fluxes._actualremoterelease_sum = self.sequences.fluxes._actualremoterelease_sum + self.sequences.fluxes.actualremoterelease
+        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._possibleremoterelief_results[self.numvars.idx_method]-self.sequences.fluxes._possibleremoterelief_results[self.numvars.idx_method-1])
+        self.numvars.abserror = max(self.numvars.abserror, abserror)
+        if self.numvars.use_relerror:
+            if self.sequences.fluxes._possibleremoterelief_results[self.numvars.idx_method] == 0.:
+                self.numvars.relerror = inf
+            else:
+                self.numvars.relerror = max(self.numvars.relerror, fabs(abserror/self.sequences.fluxes._possibleremoterelief_results[self.numvars.idx_method]))
+        abserror = fabs(self.sequences.fluxes._actualremoterelief_results[self.numvars.idx_method]-self.sequences.fluxes._actualremoterelief_results[self.numvars.idx_method-1])
+        self.numvars.abserror = max(self.numvars.abserror, abserror)
+        if self.numvars.use_relerror:
+            if self.sequences.fluxes._actualremoterelief_results[self.numvars.idx_method] == 0.:
+                self.numvars.relerror = inf
+            else:
+                self.numvars.relerror = max(self.numvars.relerror, fabs(abserror/self.sequences.fluxes._actualremoterelief_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._actualremoterelease_results[self.numvars.idx_method]-self.sequences.fluxes._actualremoterelease_results[self.numvars.idx_method-1])
+        self.numvars.abserror = max(self.numvars.abserror, abserror)
+        if self.numvars.use_relerror:
+            if self.sequences.fluxes._actualremoterelease_results[self.numvars.idx_method] == 0.:
+                self.numvars.relerror = inf
+            else:
+                self.numvars.relerror = max(self.numvars.relerror, fabs(abserror/self.sequences.fluxes._actualremoterelease_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_loggedrequiredremoterelease_v2(self) noexcept nogil:
+        self.sequences.logs.loggedrequiredremoterelease[0] = self.sequences.receivers.s[0]
+    cpdef inline void pic_loggedallowedremoterelief_v1(self) noexcept nogil:
+        self.sequences.logs.loggedallowedremoterelief[0] = self.sequences.receivers.r[0]
+    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_v1(self) noexcept nogil:
+        cdef numpy.int64_t idx
+        self.sequences.fluxes.inflow = 0.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_requiredremoterelease_v2(self) noexcept nogil:
+        self.sequences.fluxes.requiredremoterelease = self.sequences.logs.loggedrequiredremoterelease[0]
+    cpdef inline void calc_allowedremoterelief_v1(self) noexcept nogil:
+        self.sequences.fluxes.allowedremoterelief = self.sequences.logs.loggedallowedremoterelief[0]
+    cpdef inline void calc_requiredrelease_v2(self) noexcept nogil:
+        self.sequences.fluxes.requiredrelease = self.parameters.control.neardischargeminimumthreshold[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_possibleremoterelief_v1(self) noexcept nogil:
+        self.parameters.control.waterlevel2possibleremoterelief.inputs[0] = self.sequences.factors.waterlevel
+        self.parameters.control.waterlevel2possibleremoterelief.calculate_values()
+        self.sequences.fluxes.possibleremoterelief = self.parameters.control.waterlevel2possibleremoterelief.outputs[0]
+    cpdef inline void calc_actualremoterelief_v1(self) noexcept nogil:
+        self.sequences.fluxes.actualremoterelief = self.fix_min1_v1(            self.sequences.fluxes.possibleremoterelief,            self.sequences.fluxes.allowedremoterelief,            self.parameters.control.remoterelieftolerance,            True,        )
+    cpdef inline void calc_actualremoterelease_v1(self) noexcept nogil:
+        self.sequences.fluxes.actualremoterelease = (            self.sequences.fluxes.requiredremoterelease            * smoothutils.smooth_logistic1(                self.sequences.factors.waterlevel - self.parameters.control.waterlevelminimumremotethreshold,                self.parameters.derived.waterlevelminimumremotesmoothpar,            )        )
+    cpdef inline void update_actualremoterelease_v1(self) noexcept nogil:
+        self.sequences.fluxes.actualremoterelease = self.fix_min1_v1(            self.sequences.fluxes.actualremoterelease,            self.parameters.control.highestremotedischarge - self.sequences.fluxes.actualremoterelief,            self.parameters.derived.highestremotesmoothpar,            False,        )
+    cpdef inline void update_actualremoterelief_v1(self) noexcept nogil:
+        self.sequences.fluxes.actualremoterelief = self.fix_min1_v1(            self.sequences.fluxes.actualremoterelief,            self.parameters.control.highestremotedischarge,            self.parameters.derived.highestremotesmoothpar,            False,        )
+    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_v3(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            - self.sequences.fluxes.actualremoterelease            - self.sequences.fluxes.actualremoterelief        )
+    cpdef inline double fix_min1_v1(self, double input_, double threshold, double smoothpar, numpy.npy_bool relative) noexcept nogil:
+        cdef numpy.int64_t _
+        cdef double d_result
+        if relative:
+            smoothpar = smoothpar * (threshold)
+        d_result = smoothutils.smooth_min1(input_, threshold, smoothpar)
+        for _ in range(5):
+            smoothpar = smoothpar / (5.0)
+            d_result = smoothutils.smooth_max1(d_result, 0.0, smoothpar)
+            smoothpar = smoothpar / (5.0)
+            if relative:
+                d_result = smoothutils.smooth_min1(d_result, input_, smoothpar)
+            else:
+                d_result = smoothutils.smooth_min1(d_result, threshold, smoothpar)
+        return max(min(d_result, input_, threshold), 0.0)
+    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 pass_actualremoterelease_v1(self) noexcept nogil:
+        self.sequences.outlets.s[0] = self.sequences.outlets.s[0] + (self.sequences.fluxes.actualremoterelease)
+    cpdef inline void pass_actualremoterelief_v1(self) noexcept nogil:
+        self.sequences.outlets.r[0] = self.sequences.outlets.r[0] + (self.sequences.fluxes.actualremoterelief)
+    cpdef inline void pic_loggedrequiredremoterelease(self) noexcept nogil:
+        self.sequences.logs.loggedrequiredremoterelease[0] = self.sequences.receivers.s[0]
+    cpdef inline void pic_loggedallowedremoterelief(self) noexcept nogil:
+        self.sequences.logs.loggedallowedremoterelief[0] = self.sequences.receivers.r[0]
+    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 = 0.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_requiredremoterelease(self) noexcept nogil:
+        self.sequences.fluxes.requiredremoterelease = self.sequences.logs.loggedrequiredremoterelease[0]
+    cpdef inline void calc_allowedremoterelief(self) noexcept nogil:
+        self.sequences.fluxes.allowedremoterelief = self.sequences.logs.loggedallowedremoterelief[0]
+    cpdef inline void calc_requiredrelease(self) noexcept nogil:
+        self.sequences.fluxes.requiredrelease = self.parameters.control.neardischargeminimumthreshold[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_possibleremoterelief(self) noexcept nogil:
+        self.parameters.control.waterlevel2possibleremoterelief.inputs[0] = self.sequences.factors.waterlevel
+        self.parameters.control.waterlevel2possibleremoterelief.calculate_values()
+        self.sequences.fluxes.possibleremoterelief = self.parameters.control.waterlevel2possibleremoterelief.outputs[0]
+    cpdef inline void calc_actualremoterelief(self) noexcept nogil:
+        self.sequences.fluxes.actualremoterelief = self.fix_min1_v1(            self.sequences.fluxes.possibleremoterelief,            self.sequences.fluxes.allowedremoterelief,            self.parameters.control.remoterelieftolerance,            True,        )
+    cpdef inline void calc_actualremoterelease(self) noexcept nogil:
+        self.sequences.fluxes.actualremoterelease = (            self.sequences.fluxes.requiredremoterelease            * smoothutils.smooth_logistic1(                self.sequences.factors.waterlevel - self.parameters.control.waterlevelminimumremotethreshold,                self.parameters.derived.waterlevelminimumremotesmoothpar,            )        )
+    cpdef inline void update_actualremoterelease(self) noexcept nogil:
+        self.sequences.fluxes.actualremoterelease = self.fix_min1_v1(            self.sequences.fluxes.actualremoterelease,            self.parameters.control.highestremotedischarge - self.sequences.fluxes.actualremoterelief,            self.parameters.derived.highestremotesmoothpar,            False,        )
+    cpdef inline void update_actualremoterelief(self) noexcept nogil:
+        self.sequences.fluxes.actualremoterelief = self.fix_min1_v1(            self.sequences.fluxes.actualremoterelief,            self.parameters.control.highestremotedischarge,            self.parameters.derived.highestremotesmoothpar,            False,        )
+    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            - self.sequences.fluxes.actualremoterelease            - self.sequences.fluxes.actualremoterelief        )
+    cpdef inline double fix_min1(self, double input_, double threshold, double smoothpar, numpy.npy_bool relative) noexcept nogil:
+        cdef numpy.int64_t _
+        cdef double d_result
+        if relative:
+            smoothpar = smoothpar * (threshold)
+        d_result = smoothutils.smooth_min1(input_, threshold, smoothpar)
+        for _ in range(5):
+            smoothpar = smoothpar / (5.0)
+            d_result = smoothutils.smooth_max1(d_result, 0.0, smoothpar)
+            smoothpar = smoothpar / (5.0)
+            if relative:
+                d_result = smoothutils.smooth_min1(d_result, input_, smoothpar)
+            else:
+                d_result = smoothutils.smooth_min1(d_result, threshold, smoothpar)
+        return max(min(d_result, input_, threshold), 0.0)
+    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 pass_actualremoterelease(self) noexcept nogil:
+        self.sequences.outlets.s[0] = self.sequences.outlets.s[0] + (self.sequences.fluxes.actualremoterelease)
+    cpdef inline void pass_actualremoterelief(self) noexcept nogil:
+        self.sequences.outlets.r[0] = self.sequences.outlets.r[0] + (self.sequences.fluxes.actualremoterelief)