HydPy 6.2.dev1__cp313-cp313-win_amd64.whl

hydpy/cythons/autogen/c_sw1d_storage.pxd

@@ -0,0 +1,193 @@
+#!python
+# distutils: define_macros=NPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION
+# cython: language_level=3
+# cython: cpow=True
+# cython: boundscheck=False
+# cython: wraparound=False
+# cython: initializedcheck=False
+# cython: cdivision=True
+from typing import Optional
+import numpy
+cimport numpy
+from libc.math cimport exp, fabs, log, sin, cos, tan, tanh, asin, acos, atan, isnan, isinf
+from libc.math cimport NAN as nan
+from libc.math cimport INFINITY as inf
+import cython
+from cpython.mem cimport PyMem_Malloc
+from cpython.mem cimport PyMem_Realloc
+from cpython.mem cimport PyMem_Free
+from hydpy.cythons.autogen cimport configutils
+from hydpy.cythons.autogen cimport interfaceutils
+from hydpy.cythons.autogen cimport interputils
+from hydpy.cythons.autogen import pointerutils
+from hydpy.cythons.autogen cimport pointerutils
+from hydpy.cythons.autogen cimport quadutils
+from hydpy.cythons.autogen cimport rootutils
+from hydpy.cythons.autogen cimport smoothutils
+from hydpy.cythons.autogen cimport masterinterface
+ctypedef void (*CallbackType) (Model)  noexcept nogil
+cdef class CallbackWrapper:
+    cdef CallbackType callback
+@cython.final
+cdef class Parameters:
+    cdef public ControlParameters control
+@cython.final
+cdef class ControlParameters:
+    cdef public double length
+@cython.final
+cdef class Sequences:
+    cdef public InletSequences inlets
+    cdef public FactorSequences factors
+    cdef public FluxSequences fluxes
+    cdef public StateSequences states
+    cdef public SenderSequences senders
+    cdef public StateSequences old_states
+    cdef public StateSequences new_states
+@cython.final
+cdef class InletSequences:
+    cdef double **latq
+    cdef public numpy.int64_t len_latq
+    cdef public numpy.int64_t[:] _latq_ready
+    cdef public numpy.int64_t _latq_ndim
+    cdef public numpy.int64_t _latq_length
+    cdef public numpy.int64_t _latq_length_0
+    cpdef inline alloc(self, name, numpy.int64_t length)
+    cpdef inline dealloc(self, name)
+    cpdef inline set_pointer1d(self, str name, pointerutils.Double value, numpy.int64_t idx)
+    cpdef get_value(self, str name)
+    cpdef set_value(self, str name, value)
+@cython.final
+cdef class FactorSequences:
+    cdef public double timestep
+    cdef public numpy.int64_t _timestep_ndim
+    cdef public numpy.int64_t _timestep_length
+    cdef public bint _timestep_ramflag
+    cdef public double[:] _timestep_array
+    cdef public bint _timestep_diskflag_reading
+    cdef public bint _timestep_diskflag_writing
+    cdef public double[:] _timestep_ncarray
+    cdef public bint _timestep_outputflag
+    cdef double *_timestep_outputpointer
+    cdef public double waterdepth
+    cdef public numpy.int64_t _waterdepth_ndim
+    cdef public numpy.int64_t _waterdepth_length
+    cdef public bint _waterdepth_ramflag
+    cdef public double[:] _waterdepth_array
+    cdef public bint _waterdepth_diskflag_reading
+    cdef public bint _waterdepth_diskflag_writing
+    cdef public double[:] _waterdepth_ncarray
+    cdef public bint _waterdepth_outputflag
+    cdef double *_waterdepth_outputpointer
+    cdef public double waterlevel
+    cdef public numpy.int64_t _waterlevel_ndim
+    cdef public numpy.int64_t _waterlevel_length
+    cdef public bint _waterlevel_ramflag
+    cdef public double[:] _waterlevel_array
+    cdef public bint _waterlevel_diskflag_reading
+    cdef public bint _waterlevel_diskflag_writing
+    cdef public double[:] _waterlevel_ncarray
+    cdef public bint _waterlevel_outputflag
+    cdef double *_waterlevel_outputpointer
+    cpdef inline void load_data(self, numpy.int64_t idx)  noexcept nogil
+    cpdef inline void save_data(self, numpy.int64_t idx)  noexcept nogil
+    cpdef inline set_pointeroutput(self, str name, pointerutils.PDouble value)
+    cpdef inline void update_outputs(self) noexcept nogil
+@cython.final
+cdef class FluxSequences:
+    cdef public double lateralflow
+    cdef public numpy.int64_t _lateralflow_ndim
+    cdef public numpy.int64_t _lateralflow_length
+    cdef public bint _lateralflow_ramflag
+    cdef public double[:] _lateralflow_array
+    cdef public bint _lateralflow_diskflag_reading
+    cdef public bint _lateralflow_diskflag_writing
+    cdef public double[:] _lateralflow_ncarray
+    cdef public bint _lateralflow_outputflag
+    cdef double *_lateralflow_outputpointer
+    cdef public double netinflow
+    cdef public numpy.int64_t _netinflow_ndim
+    cdef public numpy.int64_t _netinflow_length
+    cdef public bint _netinflow_ramflag
+    cdef public double[:] _netinflow_array
+    cdef public bint _netinflow_diskflag_reading
+    cdef public bint _netinflow_diskflag_writing
+    cdef public double[:] _netinflow_ncarray
+    cdef public bint _netinflow_outputflag
+    cdef double *_netinflow_outputpointer
+    cpdef inline void load_data(self, numpy.int64_t idx)  noexcept nogil
+    cpdef inline void save_data(self, numpy.int64_t idx)  noexcept nogil
+    cpdef inline set_pointeroutput(self, str name, pointerutils.PDouble value)
+    cpdef inline void update_outputs(self) noexcept nogil
+@cython.final
+cdef class StateSequences:
+    cdef public double watervolume
+    cdef public numpy.int64_t _watervolume_ndim
+    cdef public numpy.int64_t _watervolume_length
+    cdef public bint _watervolume_ramflag
+    cdef public double[:] _watervolume_array
+    cdef public bint _watervolume_diskflag_reading
+    cdef public bint _watervolume_diskflag_writing
+    cdef public double[:] _watervolume_ncarray
+    cdef public bint _watervolume_outputflag
+    cdef double *_watervolume_outputpointer
+    cpdef inline void load_data(self, numpy.int64_t idx)  noexcept nogil
+    cpdef inline void save_data(self, numpy.int64_t idx)  noexcept nogil
+    cpdef inline set_pointeroutput(self, str name, pointerutils.PDouble value)
+    cpdef inline void update_outputs(self) noexcept nogil
+@cython.final
+cdef class SenderSequences:
+    cdef double **waterlevel
+    cdef public numpy.int64_t len_waterlevel
+    cdef public numpy.int64_t[:] _waterlevel_ready
+    cdef public numpy.int64_t _waterlevel_ndim
+    cdef public numpy.int64_t _waterlevel_length
+    cdef public numpy.int64_t _waterlevel_length_0
+    cpdef inline alloc(self, name, numpy.int64_t length)
+    cpdef inline dealloc(self, name)
+    cpdef inline set_pointer1d(self, str name, pointerutils.Double value, numpy.int64_t idx)
+    cpdef get_value(self, str name)
+    cpdef set_value(self, str name, value)
+@cython.final
+cdef class Model(masterinterface.MasterInterface):
+    cdef public Parameters parameters
+    cdef public Sequences sequences
+    cdef public masterinterface.MasterInterface crosssection
+    cdef public numpy.npy_bool crosssection_is_mainmodel
+    cdef public numpy.int64_t crosssection_typeid
+    cdef public interfaceutils.SubmodelsProperty routingmodelsdownstream
+    cdef public interfaceutils.SubmodelsProperty routingmodelsupstream
+    cpdef inline void simulate(self, numpy.int64_t idx)  noexcept nogil
+    cpdef void reset_reuseflags(self) noexcept nogil
+    cpdef void load_data(self, numpy.int64_t idx) noexcept nogil
+    cpdef void save_data(self, numpy.int64_t idx) noexcept nogil
+    cpdef void new2old(self) noexcept nogil
+    cpdef inline void run(self) noexcept nogil
+    cpdef inline void update_inlets(self) noexcept nogil
+    cpdef inline void update_outlets(self) noexcept nogil
+    cpdef inline void update_receivers(self, numpy.int64_t idx) noexcept nogil
+    cpdef inline void update_senders(self, numpy.int64_t idx) noexcept nogil
+    cpdef inline void update_outputs(self) noexcept nogil
+    cpdef double get_watervolume_v1(self) noexcept nogil
+    cpdef double get_waterlevel_v1(self) noexcept nogil
+    cpdef void set_timestep_v1(self, double timestep) noexcept nogil
+    cpdef inline void pick_lateralflow_v1(self) noexcept nogil
+    cpdef inline void calc_netinflow_v1(self) noexcept nogil
+    cpdef inline void update_watervolume_v1(self) noexcept nogil
+    cpdef inline void calc_waterdepth_waterlevel_v1(self) noexcept nogil
+    cpdef inline void calc_waterdepth_waterlevel_crosssectionmodel_v2(self, masterinterface.MasterInterface submodel) noexcept nogil
+    cpdef inline void pass_waterlevel_v1(self) noexcept nogil
+    cpdef double get_watervolume(self) noexcept nogil
+    cpdef double get_waterlevel(self) noexcept nogil
+    cpdef void set_timestep(self, double timestep) noexcept nogil
+    cpdef inline void pick_lateralflow(self) noexcept nogil
+    cpdef inline void calc_netinflow(self) noexcept nogil
+    cpdef inline void update_watervolume(self) noexcept nogil
+    cpdef inline void calc_waterdepth_waterlevel(self) noexcept nogil
+    cpdef inline void calc_waterdepth_waterlevel_crosssectionmodel(self, masterinterface.MasterInterface submodel) noexcept nogil
+    cpdef inline void pass_waterlevel(self) noexcept nogil
+    cpdef void perform_preprocessing_v3(self) noexcept nogil
+    cpdef void update_storage_v1(self) noexcept nogil
+    cpdef void perform_postprocessing_v3(self) noexcept nogil
+    cpdef void perform_preprocessing(self) noexcept nogil
+    cpdef void update_storage(self) noexcept nogil
+    cpdef void perform_postprocessing(self) noexcept nogil

hydpy/cythons/autogen/c_sw1d_storage.pyx

@@ -0,0 +1,349 @@
+#!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 Sequences:
+    pass
+@cython.final
+cdef class InletSequences:
+    cpdef inline alloc(self, name, numpy.int64_t length):
+        if name == "latq":
+            self._latq_length_0 = length
+            self._latq_ready = numpy.full(length, 0, dtype=numpy.int64)
+            self.latq = <double**> PyMem_Malloc(length * sizeof(double*))
+    cpdef inline dealloc(self, name):
+        if name == "latq":
+            PyMem_Free(self.latq)
+    cpdef inline set_pointer1d(self, str name, pointerutils.Double value, numpy.int64_t idx):
+        cdef pointerutils.PDouble pointer = pointerutils.PDouble(value)
+        if name == "latq":
+            self.latq[idx] = pointer.p_value
+            self._latq_ready[idx] = 1
+    cpdef get_value(self, str name):
+        cdef numpy.int64_t idx
+        if name == "latq":
+            values = numpy.empty(self.len_latq)
+            for idx in range(self.len_latq):
+                pointerutils.check0(self._latq_length_0)
+                if self._latq_ready[idx] == 0:
+                    pointerutils.check1(self._latq_length_0, idx)
+                    pointerutils.check2(self._latq_ready, idx)
+                values[idx] = self.latq[idx][0]
+            return values
+    cpdef set_value(self, str name, value):
+        if name == "latq":
+            for idx in range(self.len_latq):
+                pointerutils.check0(self._latq_length_0)
+                if self._latq_ready[idx] == 0:
+                    pointerutils.check1(self._latq_length_0, idx)
+                    pointerutils.check2(self._latq_ready, idx)
+                self.latq[idx][0] = value[idx]
+@cython.final
+cdef class FactorSequences:
+    cpdef inline void load_data(self, numpy.int64_t idx)  noexcept nogil:
+        cdef numpy.int64_t k
+        if self._timestep_diskflag_reading:
+            self.timestep = self._timestep_ncarray[0]
+        elif self._timestep_ramflag:
+            self.timestep = self._timestep_array[idx]
+        if self._waterdepth_diskflag_reading:
+            self.waterdepth = self._waterdepth_ncarray[0]
+        elif self._waterdepth_ramflag:
+            self.waterdepth = self._waterdepth_array[idx]
+        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._timestep_diskflag_writing:
+            self._timestep_ncarray[0] = self.timestep
+        if self._timestep_ramflag:
+            self._timestep_array[idx] = self.timestep
+        if self._waterdepth_diskflag_writing:
+            self._waterdepth_ncarray[0] = self.waterdepth
+        if self._waterdepth_ramflag:
+            self._waterdepth_array[idx] = self.waterdepth
+        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 == "timestep":
+            self._timestep_outputpointer = value.p_value
+        if name == "waterdepth":
+            self._waterdepth_outputpointer = value.p_value
+        if name == "waterlevel":
+            self._waterlevel_outputpointer = value.p_value
+    cpdef inline void update_outputs(self) noexcept nogil:
+        if self._timestep_outputflag:
+            self._timestep_outputpointer[0] = self.timestep
+        if self._waterdepth_outputflag:
+            self._waterdepth_outputpointer[0] = self.waterdepth
+        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._lateralflow_diskflag_reading:
+            self.lateralflow = self._lateralflow_ncarray[0]
+        elif self._lateralflow_ramflag:
+            self.lateralflow = self._lateralflow_array[idx]
+        if self._netinflow_diskflag_reading:
+            self.netinflow = self._netinflow_ncarray[0]
+        elif self._netinflow_ramflag:
+            self.netinflow = self._netinflow_array[idx]
+    cpdef inline void save_data(self, numpy.int64_t idx)  noexcept nogil:
+        cdef numpy.int64_t k
+        if self._lateralflow_diskflag_writing:
+            self._lateralflow_ncarray[0] = self.lateralflow
+        if self._lateralflow_ramflag:
+            self._lateralflow_array[idx] = self.lateralflow
+        if self._netinflow_diskflag_writing:
+            self._netinflow_ncarray[0] = self.netinflow
+        if self._netinflow_ramflag:
+            self._netinflow_array[idx] = self.netinflow
+    cpdef inline set_pointeroutput(self, str name, pointerutils.PDouble value):
+        if name == "lateralflow":
+            self._lateralflow_outputpointer = value.p_value
+        if name == "netinflow":
+            self._netinflow_outputpointer = value.p_value
+    cpdef inline void update_outputs(self) noexcept nogil:
+        if self._lateralflow_outputflag:
+            self._lateralflow_outputpointer[0] = self.lateralflow
+        if self._netinflow_outputflag:
+            self._netinflow_outputpointer[0] = self.netinflow
+@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 SenderSequences:
+    cpdef inline alloc(self, name, numpy.int64_t length):
+        if name == "waterlevel":
+            self._waterlevel_length_0 = length
+            self._waterlevel_ready = numpy.full(length, 0, dtype=numpy.int64)
+            self.waterlevel = <double**> PyMem_Malloc(length * sizeof(double*))
+    cpdef inline dealloc(self, name):
+        if name == "waterlevel":
+            PyMem_Free(self.waterlevel)
+    cpdef inline set_pointer1d(self, str name, pointerutils.Double value, numpy.int64_t idx):
+        cdef pointerutils.PDouble pointer = pointerutils.PDouble(value)
+        if name == "waterlevel":
+            self.waterlevel[idx] = pointer.p_value
+            self._waterlevel_ready[idx] = 1
+    cpdef get_value(self, str name):
+        cdef numpy.int64_t idx
+        if name == "waterlevel":
+            values = numpy.empty(self.len_waterlevel)
+            for idx in range(self.len_waterlevel):
+                pointerutils.check0(self._waterlevel_length_0)
+                if self._waterlevel_ready[idx] == 0:
+                    pointerutils.check1(self._waterlevel_length_0, idx)
+                    pointerutils.check2(self._waterlevel_ready, idx)
+                values[idx] = self.waterlevel[idx][0]
+            return values
+    cpdef set_value(self, str name, value):
+        if name == "waterlevel":
+            for idx in range(self.len_waterlevel):
+                pointerutils.check0(self._waterlevel_length_0)
+                if self._waterlevel_ready[idx] == 0:
+                    pointerutils.check1(self._waterlevel_length_0, idx)
+                    pointerutils.check2(self._waterlevel_ready, idx)
+                self.waterlevel[idx][0] = value[idx]
+@cython.final
+cdef class Model(masterinterface.MasterInterface):
+    def __init__(self):
+        super().__init__()
+        self.crosssection = None
+        self.crosssection_is_mainmodel = False
+        self.routingmodelsdownstream = interfaceutils.SubmodelsProperty()
+        self.routingmodelsupstream = interfaceutils.SubmodelsProperty()
+    def get_crosssection(self) -> masterinterface.MasterInterface | None:
+        return self.crosssection
+    def set_crosssection(self, crosssection: masterinterface.MasterInterface | None) -> None:
+        self.crosssection = crosssection
+    cpdef inline void simulate(self, numpy.int64_t idx)  noexcept nogil:
+        self.idx_sim = idx
+        self.reset_reuseflags()
+        self.load_data(idx)
+        self.run()
+        self.new2old()
+        self.update_outputs()
+    cpdef void reset_reuseflags(self) noexcept nogil:
+        if (self.crosssection is not None) and not self.crosssection_is_mainmodel:
+            self.crosssection.reset_reuseflags()
+    cpdef void load_data(self, numpy.int64_t idx) noexcept nogil:
+        self.idx_sim = idx
+        if (self.crosssection is not None) and not self.crosssection_is_mainmodel:
+            self.crosssection.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.crosssection is not None) and not self.crosssection_is_mainmodel:
+            self.crosssection.save_data(idx)
+    cpdef void new2old(self) noexcept nogil:
+        self.sequences.old_states.watervolume = self.sequences.new_states.watervolume
+        if (self.crosssection is not None) and not self.crosssection_is_mainmodel:
+            self.crosssection.new2old()
+    cpdef inline void run(self) noexcept nogil:
+        pass
+    cpdef inline void update_inlets(self) noexcept nogil:
+        pass
+    cpdef inline void update_outlets(self) noexcept nogil:
+        pass
+    cpdef inline void update_receivers(self, numpy.int64_t idx) noexcept nogil:
+        self.idx_sim = idx
+        pass
+    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 double get_watervolume_v1(self) noexcept nogil:
+        return self.sequences.states.watervolume
+    cpdef double get_waterlevel_v1(self) noexcept nogil:
+        return self.sequences.factors.waterlevel
+    cpdef void set_timestep_v1(self, double timestep) noexcept nogil:
+        self.sequences.factors.timestep = timestep
+    cpdef inline void pick_lateralflow_v1(self) noexcept nogil:
+        cdef numpy.int64_t i
+        self.sequences.fluxes.lateralflow = 0.0
+        for i in range(self.sequences.inlets.len_latq):
+            self.sequences.fluxes.lateralflow = self.sequences.fluxes.lateralflow + (self.sequences.inlets.latq[i][0])
+    cpdef inline void calc_netinflow_v1(self) noexcept nogil:
+        cdef numpy.int64_t i
+        self.sequences.fluxes.netinflow = self.sequences.fluxes.lateralflow
+        for i in range(self.routingmodelsupstream.number):
+            if self.routingmodelsupstream.typeids[i] in (1, 2):
+                self.sequences.fluxes.netinflow = self.sequences.fluxes.netinflow + ((<masterinterface.MasterInterface>self.routingmodelsupstream.submodels[i]).get_discharge())
+        for i in range(self.routingmodelsdownstream.number):
+            if self.routingmodelsdownstream.typeids[i] in (2, 3):
+                self.sequences.fluxes.netinflow = self.sequences.fluxes.netinflow - ((<masterinterface.MasterInterface>self.routingmodelsdownstream.submodels[i]).get_discharge())
+        self.sequences.fluxes.netinflow = self.sequences.fluxes.netinflow * (self.sequences.factors.timestep / 1e3)
+    cpdef inline void update_watervolume_v1(self) noexcept nogil:
+        self.sequences.states.watervolume = self.sequences.states.watervolume + (self.sequences.fluxes.netinflow)
+    cpdef inline void calc_waterdepth_waterlevel_v1(self) noexcept nogil:
+        if self.crosssection_typeid == 2:
+            self.calc_waterdepth_waterlevel_crosssectionmodel_v2(                (<masterinterface.MasterInterface>self.crosssection)            )
+    cpdef inline void calc_waterdepth_waterlevel_crosssectionmodel_v2(self, masterinterface.MasterInterface submodel) noexcept nogil:
+        submodel.use_wettedarea(self.sequences.states.watervolume / self.parameters.control.length)
+        self.sequences.factors.waterdepth = submodel.get_waterdepth()
+        self.sequences.factors.waterlevel = submodel.get_waterlevel()
+    cpdef inline void pass_waterlevel_v1(self) noexcept nogil:
+        cdef numpy.int64_t i
+        for i in range(self.sequences.senders.len_waterlevel):
+            self.sequences.senders.waterlevel[i][0] = self.sequences.factors.waterlevel
+    cpdef double get_watervolume(self) noexcept nogil:
+        return self.sequences.states.watervolume
+    cpdef double get_waterlevel(self) noexcept nogil:
+        return self.sequences.factors.waterlevel
+    cpdef void set_timestep(self, double timestep) noexcept nogil:
+        self.sequences.factors.timestep = timestep
+    cpdef inline void pick_lateralflow(self) noexcept nogil:
+        cdef numpy.int64_t i
+        self.sequences.fluxes.lateralflow = 0.0
+        for i in range(self.sequences.inlets.len_latq):
+            self.sequences.fluxes.lateralflow = self.sequences.fluxes.lateralflow + (self.sequences.inlets.latq[i][0])
+    cpdef inline void calc_netinflow(self) noexcept nogil:
+        cdef numpy.int64_t i
+        self.sequences.fluxes.netinflow = self.sequences.fluxes.lateralflow
+        for i in range(self.routingmodelsupstream.number):
+            if self.routingmodelsupstream.typeids[i] in (1, 2):
+                self.sequences.fluxes.netinflow = self.sequences.fluxes.netinflow + ((<masterinterface.MasterInterface>self.routingmodelsupstream.submodels[i]).get_discharge())
+        for i in range(self.routingmodelsdownstream.number):
+            if self.routingmodelsdownstream.typeids[i] in (2, 3):
+                self.sequences.fluxes.netinflow = self.sequences.fluxes.netinflow - ((<masterinterface.MasterInterface>self.routingmodelsdownstream.submodels[i]).get_discharge())
+        self.sequences.fluxes.netinflow = self.sequences.fluxes.netinflow * (self.sequences.factors.timestep / 1e3)
+    cpdef inline void update_watervolume(self) noexcept nogil:
+        self.sequences.states.watervolume = self.sequences.states.watervolume + (self.sequences.fluxes.netinflow)
+    cpdef inline void calc_waterdepth_waterlevel(self) noexcept nogil:
+        if self.crosssection_typeid == 2:
+            self.calc_waterdepth_waterlevel_crosssectionmodel_v2(                (<masterinterface.MasterInterface>self.crosssection)            )
+    cpdef inline void calc_waterdepth_waterlevel_crosssectionmodel(self, masterinterface.MasterInterface submodel) noexcept nogil:
+        submodel.use_wettedarea(self.sequences.states.watervolume / self.parameters.control.length)
+        self.sequences.factors.waterdepth = submodel.get_waterdepth()
+        self.sequences.factors.waterlevel = submodel.get_waterlevel()
+    cpdef inline void pass_waterlevel(self) noexcept nogil:
+        cdef numpy.int64_t i
+        for i in range(self.sequences.senders.len_waterlevel):
+            self.sequences.senders.waterlevel[i][0] = self.sequences.factors.waterlevel
+    cpdef void perform_preprocessing_v3(self) noexcept nogil:
+        self.pick_lateralflow_v1()
+        self.calc_waterdepth_waterlevel_v1()
+    cpdef void update_storage_v1(self) noexcept nogil:
+        self.calc_netinflow_v1()
+        self.update_watervolume_v1()
+        self.calc_waterdepth_waterlevel_v1()
+    cpdef void perform_postprocessing_v3(self) noexcept nogil:
+        self.pass_waterlevel_v1()
+    cpdef void perform_preprocessing(self) noexcept nogil:
+        self.pick_lateralflow_v1()
+        self.calc_waterdepth_waterlevel_v1()
+    cpdef void update_storage(self) noexcept nogil:
+        self.calc_netinflow_v1()
+        self.update_watervolume_v1()
+        self.calc_waterdepth_waterlevel_v1()
+    cpdef void perform_postprocessing(self) noexcept nogil:
+        self.pass_waterlevel_v1()