lstream_v001

Version 1 of HydPy-L-Stream is a kinematic wave routing approach. Initially, we designed it to agree with the variable storage-coefficient procedure Williams (1969). After recognising some accuracy and stability issues, we reimplemented it in a more hydrodynamical fashion. It is now similar to the “DV/DQ FUER WILLIAMS” option of LARSIM, which is also a more hydrodynamical version of the pure “WILLIAMS” option.

While Williams (1969) uses precalculated tabulated data, both LARSIM and HydPy calculate the discharge dynamically based on the actualchannel storage or water stage. For this purpose, they apply the Gauckler-Manning-Strickler equation on a triple trapezoid profile of the following structure:

_images/HydPy-L-Stream_Version-1.png

A running lstream_v001 model consists of a several equally long channel-subsections, which one can understand as an array of nonlinear storages. This nonlinearity is computationally more demanding than using linear approaches (for example, the linear storage cascade, see arma_v1 and LinearStorageCascade). Still, it allows to model changes in velocity due to rising or falling water stages more easily.

lstream_v001 is not a fully dynamical 1D-approach considering all energy terms of the Saint-Venant equation. Instead, as all kinematic approaches, it takes only the local water stage into account explicitly and ignores changes in depth or velocity over the channel length. Hence, do not use lstream_v001 when you expect substantial backwater effects or other hydraulic complications.

While lstream_v001 is kinematic, it still allows for diffusion (or attenuation) of flood waves. You can control the strength of diffusivity via parameter GTS, which determines the number of channel-subsections. The more subsections, the smaller the numerical diffusivity: peak flows decrease less over the complete channel length. Contrary, when you set GTS to one, you get the highest possible flood attenuation. You can use method calculate_characteristiclength() to gain reasonable estimates for GTS.

Please note that a high number of channel-subsections does not only result in high peak-flows but often also in high computation times. This unfavourable aspect is due to increased stiffness, which the explicit integration method implemented in ELSModel cannot handle very efficiently. Usually, ELSModel still returns good results (more correctly: results meeting the acceptable numerical tolerance), but it may need to decrease the internal numerical integration step size considerably.

The default values of the numerical tolerance parameters (AbsErrorMax and RelErrorMax) should work well for most situations. However, you are always free to modify them to either gain more computational speed or numerical accuracy.

One implementation detail of lstream_v001 stems from the fact that the triple trapezoid profile depicted above introduces discontinuities into the relationships between water stage and some other variables. Generally, discontinuities decrease the speed and reliability of numerical integration algorithms. As a solution, we “smooth” the affected relationships or, put more concretely, we apply the function smooth_logistic2() to calculate different modified water stages for the locations around the individual discontinuities.

On the downside, this approach introduces one more control parameter that is not too easy to understand: HR. The higher the value of HR, the smoother the affected relationships. Hence, high HR values are beneficial for numerical reasons, but at some point, they caninfluence the calculated results notably. In our experience, 0.1 m serves as a good compromise value in most cases.

Integration tests

Note

When new to HydPy, consider reading section How to understand integration tests? first.

main channel flow

For our first test, we take up one of the examples given by Todini (2007), focussing on the routing of a unimodal flood wave through a 100 km long channel exhibiting the trapezoidal cross-section shown in figure 5.

>>> from hydpy.models.lstream_v001 import *
>>> parameterstep("1d")

The simulation period spans 96 hours; the simulation step is 30 minutes:

>>> from hydpy import pub, Nodes, Element
>>> pub.timegrids = "2000-01-01", "2000-01-05", "30m"

For testing purposes, the model retrieves its input data from two nodes (input1 and input2) and passes its output to node output. First, we define these nodes:

>>> nodes = Nodes("input1", "input2", "output")

Second, we define the element stream and build the connections between the prepared nodes and the lstream_v001 model instance:

>>> stream = Element("stream",
...                  inlets=["input1", "input2"],
...                  outlets="output")
>>> stream.model = model

Next, we prepare a test function object which sets the intial stage to 3.71783276 m, which results in an initial outflow of 100 m³/s:

>>> from hydpy.core.testtools import IntegrationTest
>>> IntegrationTest.plotting_options.activated = fluxes.qz, fluxes.qa
>>> test = IntegrationTest(stream, inits=[[states.h, 3.71783276]])

Now we define the geometry and roughness values for the main channel given by Todini (2007):

>>> laen(100.0)
>>> gef(0.00025)
>>> bm(15.0)
>>> bnm(5.0)
>>> skm(1.0/0.035)

To enforce that all water flows through the main channel only, we set its height to infinity:

>>> hm(inf)

Hence, the following values, describing the forelands and outer embankments, are irrelevant in this first example:

>>> bv(100.0)
>>> bbv(20.0)
>>> bnv(10.0)
>>> bnvr(100.0)
>>> skv(10.0)
>>> ekm(1.0)
>>> ekv(1.0)

The same holds for the value of parameter HR, which, for example, defines the degree of smoothness of the differential equations as soon as water leaves the main channel:

>>> hr(0.1)

Todini (2007) divides the channel into different numbers of subsections in his experiments. Here, we define eight subsections, which is in agreement with the characteristic length of the Kalinin-Milyukov method:

>>> gts(8)

As we do not change the default solver parameter values, the accuracy of the following results should be driven by the relative error estimates, which must be lower than the tolerance defined by parameter RelErrorMax:

>>> parameters.update()
>>> solver.relerrormax
relerrormax(0.001)

Node input1 supplies constant base flow and node input2 supplies the actual flood wave. The peak occurs after 24 hours and with a (total) height of 900 m³/s:

>>> import numpy
>>> q_base = 100.0
>>> q_peak = 900.0
>>> t_peak = 24.0
>>> β = 16.0
>>> ts = pub.timegrids.init.to_timepoints()
>>> nodes.input1.sequences.sim.series = q_base
>>> nodes.input2.sequences.sim.series = (
...     (q_peak-q_base)*((ts/t_peak)*numpy.exp(1.0-ts/t_peak))**β)

The following table and figure show all relevant input and output data as well as all relevant variables calculated internally. QG shows the typical storage cascade pattern with translation and retention increasing from subsection to subsection. lstream_v001 keeps the water balance with high accuracy. The height and timing of the calculated peak flow agree very well with the results of Todini (2007) (see figure 13):

>>> test("lstream_v001_main_channel_flow")
Click to see the table
Click to see the graph

overbank flow

In the above example, water flows in the main channel only. Next, we set the height of the main channel to 6 m:

>>> hm(6.0)
>>> parameters.update()

Now the calculated flood wave shows a considerable increase in translation and retention. Inspecting the time series of the stages reveals that this effect is actually due to the (originally discontinuous) transition from pure channel flow to a mixture of channel and overbank flow, where additional storage capacities come into play:

>>> test("lstream_v001_overbank_flow")
Click to see the table
Click to see the graph

negative water stages

Finally, we show that lstream_v001 allows for negative stages. Therefore, we reset HM to infinity, set the base flow provided by node input1 to zero, and set the initial water stage to -1.0 m:

>>> hm(inf)
>>> nodes.input1.sequences.sim.series = 0.0
>>> test.inits.h = -1.0

In usual simulations with reasonable smoothing parameterisations, one is unlikely to encounter negative stages. However, they are principally allowed for the sake of numerical robustness. Careful inspection of the stage (H) and the discharge (QG) of a cross-section at the beginning of the rising limb reveals that the first discharge occurs for stages slightly below zero (due to setting the regularisation parameter HR to 0.1 m):

>>> with pub.options.reprdigits(2):
...     test("lstream_v001_negative_water_stage")
Click to see the table
Click to see the graph

We printed the last test results with a lower precision than usual. Otherwise, there were some differences when performing the test in Python and in Cython mode and possibly also when working with different compilers, which indicates that lstream_v001 reaches limited numerical accuracy when negative water stages occur. In our real applications, we did not realise any problems stemming from this. However, we cannot guarantee that they will never occur. Any suggestions on solving this issue are welcome.

class hydpy.models.lstream_v001.Characteristics(waterstage: float, discharge: float, derivative: float, length_orig: float, nmb_subsections: int, length_adj: float)[source]

Bases: tuple

Data class for holding the results of method calculate_characteristiclength().

property waterstage

Alias for field number 0

property discharge

Alias for field number 1

property derivative

Alias for field number 2

property length_orig

Alias for field number 3

property nmb_subsections

Alias for field number 4

property length_adj

Alias for field number 5

class hydpy.models.lstream_v001.Model[source]

Bases: hydpy.models.lstream.lstream_model.Model, hydpy.models.lstream.lstream_model.ProfileMixin

Version 1 of HydPy-L-Stream.

The following “inlet update methods” are called in the given sequence at the beginning of each simulation step:

  • Pick_Q_V1 Query the current inflow from all inlet nodes.

The following methods define the relevant components of a system of ODE equations (e.g. direct runoff):

  • Calc_RHM_V1 Regularise the stage with respect to the channel bottom.

  • Calc_RHMDH_V1 Calculate the derivative of the stage regularised with respect to the channel bottom.

  • Calc_RHV_V1 Regularise the stage with respect to the transition from the main channel to both forelands.

  • Calc_RHVDH_V1 Calculate the derivative of the stage regularised with respect to the transition from the main channel to both forelands.

  • Calc_RHLVR_RHRVR_V1 Regularise the stage with respect to the transitions from the forelands to the outer embankments.

  • Calc_RHLVRDH_RHRVRDH_V1 Calculate the derivative of the stage regularised with respect to the transition from the forelands to the outer embankments.

  • Calc_AM_UM_V1 Calculate the wetted area and the wetted perimeter of the main channel.

  • Calc_ALV_ARV_ULV_URV_V1 Calculate the wetted area and wetted perimeter of both forelands.

  • Calc_ALVR_ARVR_ULVR_URVR_V1 Calculate the wetted area and perimeter of both outer embankments.

  • Calc_QM_V1 Calculate the discharge of the main channel after Manning-Strickler.

  • Calc_QLV_QRV_V1 Calculate the discharge of both forelands after Manning-Strickler.

  • Calc_QLVR_QRVR_V1 Calculate the discharge of both outer embankments after Manning-Strickler.

  • Calc_AG_V1 Calculate the through wetted of the total cross-sections.

  • Calc_QG_V1 Calculate the discharge of the total cross-section.

  • Calc_QA_V1 Query the actual outflow.

  • Calc_WBM_V1 Calculate the water table width above the main channel.

  • Calc_WBLV_WBRV_V1 Calculate the water table width above both forelands.

  • Calc_WBLVR_WBRVR_V1 Calculate the water table width above both outer embankments.

  • Calc_WBG_V1 Calculate the water level width of the total cross-section.

  • Calc_DH_V1 Determine the change in the stage.

The following methods define the complete equations of an ODE system (e.g. change in storage of fast water due to effective precipitation and direct runoff):
The following “outlet update methods” are called in the given sequence at the end of each simulation step:

  • Pass_Q_V1 Pass the outflow to the outlet node.

The following “additional methods” might be called by one or more of the other methods or are meant to be directly called by the user:

  • Return_QF_V1 Calculate and return the “error” between the actual discharge and the discharge corresponding to the given water stage.

  • Return_H_V1 Calculate and return the water stage corresponding to the current discharge value.

The following “submodels” might be called by one or more of the implemented methods or are meant to be directly called by the user:

  • PegasusH Pegasus iterator for finding the correct water stage.

calculate_characteristiclength(*, h: Optional[float] = None, q: Optional[float] = None, dx: float = 1e-06, lenmin: float = 0.1, nmbmax: int = 50) → hydpy.models.lstream_v001.Characteristics[source]

Approximate the characteristic length after the Kalinin-Milyukov method.

Method calculate_characteristiclength() determines the characteristic length based on a finite difference approach and returns it, accompanied by some intermediate results, within a Characteristics object. You need to pass in either the stage or the discharge (q) value of interest (h). Optionally, you can define alternative values for the finite-difference step size (dx), the smallest allowed subsection length (minlen) and the maximum number of cross-sections (nmbmax). The returned length_orig value is the initial approximation of the ideal characteristic length, and length_adj is its adjustment to the actual channel length. All length value must be given and are returned in kilometres.

We reuse the example given in the main documentation on module lstream_v001:

>>> from hydpy.models.lstream_v001 import *
>>> parameterstep("1d")
>>> simulationstep("30m")

>>> gts(1)
>>> laen(100.0)
>>> gef(0.00025)
>>> bm(15.0)
>>> bnm(5.0)
>>> skm(1.0/0.035)
>>> hm(inf)
>>> bv(100.0)
>>> bbv(20.0)
>>> bnv(10.0)
>>> bnvr(100.0)
>>> skv(10.0)
>>> ekm(1.0)
>>> ekv(1.0)
>>> hr(0.1)
>>> parameters.update()

When passing a water stage of 7.5 m, method calculate_characteristiclength() determines a characteristic length of 13 km and suggest to split the total channel length of 100 km length into eight subsections:

>>> model.calculate_characteristiclength(h=7.5)
Characteristics(
    waterstage=7.5,
    discharge=470.654321,
    derivative=0.006929,
    length_orig=13.044707,
    nmb_subsections=8,
    length_adj=12.5,
)

Passing the discharge value corresponding to the lastly defined water stage returns equal results (method calculate_characteristiclength() uses first method Return_H_V1 to calculate the water stage and then precedes as usual):

>>> model.calculate_characteristiclength(q=470.654321)
Characteristics(
    waterstage=7.5,
    discharge=470.654321,
    derivative=0.006929,
    length_orig=13.044707,
    nmb_subsections=8,
    length_adj=12.5,
)

The relevant discharge value must be greater than zero:

>>> model.calculate_characteristiclength(q=0.0)
Traceback (most recent call last):
...
ValueError: While trying to calculate the characteristic length for the river channel of `lstream_v001` of element `?`, the following error occurred: The given values result in a mean discharge of 0.0 m³/s and a discharge gradient of 0.0 m³/s/m.

The same holds for the discharge gradient:

>>> model.calculate_characteristiclength(q=100.0, dx=0.0)
Traceback (most recent call last):
...
ValueError: While trying to calculate the characteristic length for the river channel of `lstream_v001` of element `?`, the following error occurred: The given values result in a mean discharge of 100.0 m³/s and a discharge gradient of 0.0 m³/s/m.

One must define at either h or q but not both:

>>> model.calculate_characteristiclength()
Traceback (most recent call last):
...
ValueError: While trying to calculate the characteristic length for the river channel of `lstream_v001` of element `?`, the following error occurred: Calculating the characteristic length requires either a reference stage or a discharge value, but neither is given.

>>> model.calculate_characteristiclength(h=7.5, q=470.654321)
Traceback (most recent call last):
...
ValueError: While trying to calculate the characteristic length for the river channel of `lstream_v001` of element `?`, the following error occurred: Calculating the characteristic length requires either a reference stage or a discharge value, but both are given.

You can modify the allowed channel length or increase the allowed number of subsections:

>>> model.calculate_characteristiclength(h=7.5, lenmin=20.0)
Characteristics(
    waterstage=7.5,
    discharge=470.654321,
    derivative=0.006929,
    length_orig=13.044707,
    nmb_subsections=5,
    length_adj=20.0,
)

>>> model.calculate_characteristiclength(
...     h=7.5, lenmin=20.0, nmbmax=4)
Characteristics(
    waterstage=7.5,
    discharge=470.654321,
    derivative=0.006929,
    length_orig=13.044707,
    nmb_subsections=4,
    length_adj=25.0,
)

The lowest returned number of subsections is one:

>>> laen(1.0)
>>> model.calculate_characteristiclength(h=7.5)
Characteristics(
    waterstage=7.5,
    discharge=470.654321,
    derivative=0.006929,
    length_orig=13.044707,
    nmb_subsections=1,
    length_adj=1.0,
)
numconsts: hydpy.core.modeltools.NumConstsELS
numvars: hydpy.core.modeltools.NumVarsELS
element: Optional[‘devicetools.Element’]
cymodel: Optional[typingtools.CyModelProtocol]
parameters: parametertools.Parameters
sequences: sequencetools.Sequences
masks: masktools.Masks
class hydpy.models.lstream_v001.AideSequences(master: hydpy.core.sequencetools.Sequences, cls_fastaccess: Optional[Type[FastAccessType]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.sequencetools.ModelSequences[AideSequence, hydpy.core.variabletools.FastAccess]

Aide sequences of model lstream_v001.

The following classes are selected:

  • WBM() Wasserspiegelbreite Hauptgerinne (water level width of the main channel) [m].

  • WBLV() Wasserspiegelbreite des linken Vorlandes (water level width of the left foreland) [m].

  • WBRV() Wasserspiegelbreite des rechten Vorlandes (water level width of the right foreland) [m].

  • WBLVR() Wasserspiegelbreite des linken Vorlandrandes (water level width of the left outer embankment) [m].

  • WBRVR() Wasserspiegelbreite des rechten Vorlandrandes (water level width of the right outer embankment) [m].

  • WBG() Wasserspiegelbreite des gesamten Querschnittes (water level width of the total cross section) [m].

  • AM() Durchflossene Fläche Hauptgerinne (wetted area of the main channel) [m²].

  • ALV() Durchflossene Fläche linkes Vorland (wetted area of the left foreland) [m²].

  • ARV() Durchflossene Fläche rechtes Vorland (wetted area of the right foreland) [m²].

  • ALVR() Durchflossene Fläche linker Vorlandrand (wetted area of the left outer embankments) [m²].

  • ARVR() Durchflossene Fläche rechter Vorlandrand (wetted area of the right outer embankments) [m²].

  • AG() Durchflossene Fläche gesamt (total wetted area) [m²].

  • UM() Benetzter Umfang Hauptgerinne (wetted perimeter of the main channel) [m].

  • ULV() Benetzter Umfang linkes Vorland (wetted perimeter of the left foreland) [m].

  • URV() Benetzter Umfang rechtes Vorland (wetted perimeter of the right foreland) [m].

  • ULVR() Benetzter Umfang linker Vorlandrand (wetted perimeter of the left outer embankment) [m].

  • URVR() Benetzter Umfang rechtes Vorlandrand (wetted perimeter of the right outer embankment) [m].

  • QM() Durchfluss Hauptgerinne (discharge of the main channel) [m³/s].

  • QLV() Durchfluss linkes Vorland (discharge of the left foreland) [m³/s].

  • QRV() Durchfluss rechtes Vorland (discharge of the right foreland) [m³/s].

  • QLVR() Durchfluss linker Vorlandrand (discharge of the left outer embankment) [m³/s].

  • QRVR() Durchfluss rechter Vorlandrand (discharge of the right outer embankment) [m³/s].

  • RHM() Hinsichtlich der Gewässersohle regularisierter Wasserstand (stage regularised with respect to the channel bottom) [m].

  • RHMDH() Ableitung von RHM (derivative of RHM) [m/m].

  • RHV() Hinsichtlich der des Übergangs Hauptgerinne/Vorländer regularisierter Wasserstand (stage regularised with respect to the transition from the main channel to both forelands) [m].

  • RHVDH() Ableitung von RHV (derivative of RHV) [m/m].

  • RHLVR() Hinsichtlich der des Übergangs linkes Vorland/ linker Vorlandrand regularisierter Wasserstand (stage regularised with respect to the transition from the left foreland to the left outer embankment) [m].

  • RHLVRDH() Ableitung von RHLVR (derivative of RHLVR) [m/m].

  • RHRVR() Hinsichtlich der des Übergangs rechtes Vorland/ rechter Vorlandrand regularisierter Wasserstand (stage regularised with respect to the transition from the right foreland to the right outer embankment) [m].

  • RHRVRDH() Ableitung von RHRVR (derivative of RHRVR) [m/m].

class hydpy.models.lstream_v001.ControlParameters(master: hydpy.core.parametertools.Parameters, cls_fastaccess: Optional[Type[hydpy.core.parametertools.FastAccessParameter]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.variabletools.SubVariables[hydpy.core.parametertools.Parameters, Parameter, hydpy.core.parametertools.FastAccessParameter]

Control parameters of model lstream_v001.

The following classes are selected:

  • Laen() Flusslänge (channel length) [km].

  • Gef() Sohlgefälle (channel slope) [-].

  • GTS() Anzahl Gewässerteilstrecken (number of channel subsections) [-].

  • HM() Höhe Hauptgerinne (height of the main channel) [m].

  • BM() Sohlbreite Hauptgerinne (bed width of the main channel) [m].

  • BNM() Böschungsneigung Hauptgerinne (slope of both main channel embankments) [-].

  • BV() Sohlbreite Vorländer (bed widths of both forelands) [m].

  • BBV() Breite Vorlandböschungen (width of both foreland embankments) [m].

  • BNV() Böschungsneigung Vorländer (slope of both foreland embankments) [-].

  • BNVR() Böschungsneigung Vorlandränder (slope of both outer embankments) [-].

  • SKM() Rauigkeitsbeiwert Hauptgerinne (roughness coefficient of the main channel) [m^(1/3)/s].

  • SKV() Rauigkeitsbeiwert Vorländer (roughness coefficient of both forelands) [m^(1/3)/s].

  • EKM() Kalibrierfaktor Hauptgerinne (calibration factor for the main channel) [-].

  • EKV() Kalibrierfaktor Vorländer (calibration factor for both forelands) [m].

  • HR() Allgemeiner Glättungsparameter für den Wasserstand (general smoothing parameter for the water stage) [mm].

class hydpy.models.lstream_v001.DerivedParameters(master: hydpy.core.parametertools.Parameters, cls_fastaccess: Optional[Type[hydpy.core.parametertools.FastAccessParameter]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.variabletools.SubVariables[hydpy.core.parametertools.Parameters, Parameter, hydpy.core.parametertools.FastAccessParameter]

Derived parameters of model lstream_v001.

The following classes are selected:

  • Sek() Sekunden im Simulationszeitschritt (Number of seconds of the selected simulation time step) [s].

  • HV() Höhe Vorländer (height of both forelands) [m].

  • MFM() Produkt der zeitkonstanten Terme der Manning-Strickler-Formel für das Hauptgerinne (product of the time-constant terms of the Manning-Strickler equation, calculated for the main channel) [m^(1/3)/s].

  • MFV() Produkt der zeitkonstanten Terme der Manning-Strickler-Formel für beide Vorländer (product of the time-constant terms of the Manning-Strickler equation, calculated for both forelands) [m^(1/3)/s].

  • BNMF() Hilfsterm zur Berechnung des benetzten Böschungsumfangs im Hauptgerinne (auxiliary term for the calculation of the wetted perimeter of the slope of the main channel) [m].

  • BNVF() Hilfsterm zur Berechnung des benetzten Böschungsumfangs der Vorländer (auxiliary term for the calculation of the wetted perimeter of the slope of both forelands) [m].

  • BNVRF() Hilfsterm zur Berechnung des benetzten Böschungsumfangs der Vorlandränder (auxiliary term for the calculation of the wetted perimeter of the slope of both outer embankments) [m].

  • HRP() Wasserstand-Regularisierungs-Parameter zur Verwendung in Verbindung mit Regularisierungsfunktion smooth_logistic2() (regularisation parameter for water stage to be used when applying regularisation function smooth_logistic2()) [m].

class hydpy.models.lstream_v001.FixedParameters(master: hydpy.core.parametertools.Parameters, cls_fastaccess: Optional[Type[hydpy.core.parametertools.FastAccessParameter]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.variabletools.SubVariables[hydpy.core.parametertools.Parameters, Parameter, hydpy.core.parametertools.FastAccessParameter]

Fixed parameters of model lstream_v001.

The following classes are selected:

  • WBMin() Mindestwert der Wasserspiegelbreite (minimum value of the water level width [m].

  • WBReg() Auf WBMin bezogener effektiver Glättungsparameter (effectiv smoothing parameter related to WBMin) [m].

class hydpy.models.lstream_v001.FluxSequences(master: hydpy.core.sequencetools.Sequences, cls_fastaccess: Optional[Type[FastAccessType]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.sequencetools.OutputSequences[FluxSequence]

Flux sequences of model lstream_v001.

The following classes are selected:

  • QZ() Mittlerer Zufluss in Gerinnestrecke (average inflow into the channel) [m³/s].

  • QG() Durchfluss gesamt (total discharge) [m³/s].

  • QA() Abfluss aus Gerinnestrecke (outflow out of the channel) [m³/s].

  • DH() Wasserstandänderung (temporal change of the water stage) [m/s].

class hydpy.models.lstream_v001.InletSequences(master: hydpy.core.sequencetools.Sequences, cls_fastaccess: Optional[Type[FastAccessType]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.sequencetools.LinkSequences[InletSequence]

Inlet sequences of model lstream_v001.

The following classes are selected:

  • Q() Abfluss (runoff) [m³/s].

class hydpy.models.lstream_v001.OutletSequences(master: hydpy.core.sequencetools.Sequences, cls_fastaccess: Optional[Type[FastAccessType]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.sequencetools.LinkSequences[OutletSequence]

Outlet sequences of model lstream_v001.

The following classes are selected:

  • Q() Abfluss (runoff) [m³/s].

class hydpy.models.lstream_v001.SolverParameters(master: hydpy.core.parametertools.Parameters, cls_fastaccess: Optional[Type[hydpy.core.parametertools.FastAccessParameter]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.variabletools.SubVariables[hydpy.core.parametertools.Parameters, Parameter, hydpy.core.parametertools.FastAccessParameter]

Solver parameters of model lstream_v001.

The following classes are selected:

  • AbsErrorMax() Absolute numerical error tolerance [m3/s].

  • RelErrorMax() Relative numerical error tolerance [-].

  • RelDTMin() Smallest relative integration time step size allowed [-].

  • RelDTMax() Largest relative integration time step size allowed [-].

class hydpy.models.lstream_v001.StateSequences(master: hydpy.core.sequencetools.Sequences, cls_fastaccess: Optional[Type[FastAccessType]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.sequencetools.OutputSequences[StateSequence]

State sequences of model lstream_v001.

The following classes are selected:

  • H() Wasserstand (water stage) [m].