lland

Base model lland is the core of the HydPy implementation of all LARSIM type models (Bremicker). It consists of routines for the preparation of meteorological input, the calculation of potential evaporation, the simulation of water stored on plants, in the snow layer and the soil, as well as runoff concentration.

Method Features

class hydpy.models.lland.lland_model.Model[source]

Bases: hydpy.core.modeltools.AdHocModel

Base model for HydPy-L-Land.

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

  • Pick_QZ_V1 Query the current inflow from all inlet nodes.

The following “run methods” are called in the given sequence during each simulation step:
The following “outlet update methods” are called in the given sequence at the end of each simulation step:
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:
The following “submodels” might be called by one or more of the implemented methods or are meant to be directly called by the user:

  • PegasusESnowInz Pegasus iterator for finding the correct energy content of the intercepted snow.

  • PegasusESnow Pegasus iterator for finding the correct snow energy content.

  • PegasusTempSSurface Pegasus iterator for finding the correct snow surface temperature.

idx_hru

The hydrological response unit index.

See class Idx_HRU for an explanation on the purpose and handling of objects of IndexProperty subclasses.

class hydpy.models.lland.lland_model.Pick_QZ_V1[source]

Bases: hydpy.core.modeltools.Method

Query the current inflow from all inlet nodes.

Requires the inlet sequence:

Q

Calculates the flux sequence:

QZ

Basic equation:

\(QZ = \sum Q_{inlets}\)

class hydpy.models.lland.lland_model.Calc_QZH_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the inflow in mm.

Requires the derived parameter:

QFactor

Requires the flux sequence:

QZ

Calculates the flux sequence:

QZH

Basic equation:

\(QZH = QZ / QFactor\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> derived.qfactor(2.0)
>>> fluxes.qz = 6.0
>>> model.calc_qzh_v1()
>>> fluxes.qzh
qzh(3.0)
class hydpy.models.lland.lland_model.Update_LoggedTemL_V1[source]

Bases: hydpy.core.modeltools.Method

Log the air temperature values of the last 24 hours.

Requires the derived parameter:

NmbLogEntries

Requires the input sequence:

TemL

Updates the log sequence:

LoggedTemL

Example:

The following example shows that each new method call successively moves the three memorised values to the right and stores the respective new value on the most left position:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedteml.shape = 3
>>> logs.loggedteml = 0.0
>>> from hydpy import UnitTest
>>> test = UnitTest(model,
...                 model.update_loggedteml_v1,
...                 last_example=4,
...                 parseqs=(inputs.teml,
...                          logs.loggedteml))
>>> test.nexts.teml = 0.0, 6.0, 3.0, 3.0
>>> del test.inits.loggedteml
>>> test()
| ex. | teml |           loggedteml |
-------------------------------------
|   1 |  0.0 | 0.0  0.0         0.0 |
|   2 |  6.0 | 6.0  0.0         0.0 |
|   3 |  3.0 | 3.0  6.0         0.0 |
|   4 |  3.0 | 3.0  3.0         6.0 |
class hydpy.models.lland.lland_model.Calc_TemLTag_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the average air temperature of the last 24 hours.

Requires the derived parameter:

NmbLogEntries

Requires the log sequence:

LoggedTemL

Updates the flux sequence:

TemLTag

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedteml.shape = 3
>>> logs.loggedteml = 1.0, 5.0, 3.0
>>> model.calc_temltag_v1()
>>> fluxes.temltag
temltag(3.0)
class hydpy.models.lland.lland_model.Update_LoggedRelativeHumidity_V1[source]

Bases: hydpy.core.modeltools.Method

Log the sunshine duration values of the last 24 hours.

Requires the derived parameter:

NmbLogEntries

Requires the input sequence:

RelativeHumidity

Updates the log sequence:

LoggedRelativeHumidity

Example:

The following example shows that each new method call successively moves the three memorised values to the right and stores the respective new value on the most left position:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedrelativehumidity.shape = 3
>>> logs.loggedrelativehumidity = 0.0
>>> from hydpy import UnitTest
>>> method = (
...     model.update_loggedrelativehumidity_v1)
>>> test = UnitTest(model,
...                method,
...                 last_example=4,
...                 parseqs=(inputs.relativehumidity,
...                          logs.loggedrelativehumidity))
>>> test.nexts.relativehumidity = 0.0, 6.0, 3.0, 3.0
>>> del test.inits.loggedrelativehumidity
>>> test()
| ex. | relativehumidity |           loggedrelativehumidity |
-------------------------------------------------------------
|   1 |              0.0 | 0.0  0.0                     0.0 |
|   2 |              6.0 | 6.0  0.0                     0.0 |
|   3 |              3.0 | 3.0  6.0                     0.0 |
|   4 |              3.0 | 3.0  3.0                     6.0 |
class hydpy.models.lland.lland_model.Calc_DailyRelativeHumidity_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the average relative humidity of the last 24 hours.

Requires the derived parameter:

NmbLogEntries

Requires the log sequence:

LoggedRelativeHumidity

Updates the flux sequence:

DailyRelativeHumidity

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedrelativehumidity.shape = 3
>>> logs.loggedrelativehumidity = 1.0, 5.0, 3.0
>>> model.calc_dailyrelativehumidity_v1()
>>> fluxes.dailyrelativehumidity
dailyrelativehumidity(3.0)
class hydpy.models.lland.lland_model.Update_LoggedWindSpeed2m_V1[source]

Bases: hydpy.core.modeltools.Method

Log the wind speed values 2 meters above ground of the last 24 hours.

Requires the derived parameter:

NmbLogEntries

Requires the flux sequence:

WindSpeed2m

Updates the log sequence:

LoggedWindSpeed2m

Example:

The following example shows that each new method call successively moves the three memorised values to the right and stores the respective new value on the most left position:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedwindspeed2m.shape = 3
>>> logs.loggedwindspeed2m = 0.0
>>> from hydpy import UnitTest
>>> test = UnitTest(model,
...                 model.update_loggedwindspeed2m_v1,
...                 last_example=4,
...                 parseqs=(fluxes.windspeed2m,
...                          logs.loggedwindspeed2m))
>>> test.nexts.windspeed2m = 1.0, 3.0, 2.0, 4.0
>>> del test.inits.loggedwindspeed2m
>>> test()
| ex. | windspeed2m |           loggedwindspeed2m |
---------------------------------------------------
|   1 |         1.0 | 1.0  0.0                0.0 |
|   2 |         3.0 | 3.0  1.0                0.0 |
|   3 |         2.0 | 2.0  3.0                1.0 |
|   4 |         4.0 | 4.0  2.0                3.0 |
class hydpy.models.lland.lland_model.Calc_DailyWindSpeed2m_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the average wind speed 2 meters above ground of the last 24 hours.

Requires the derived parameter:

NmbLogEntries

Requires the log sequence:

LoggedWindSpeed2m

Updates the flux sequence:

DailyWindSpeed2m

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedwindspeed2m.shape = 3
>>> logs.loggedwindspeed2m = 1.0, 5.0, 3.0
>>> model.calc_dailywindspeed2m_v1()
>>> fluxes.dailywindspeed2m
dailywindspeed2m(3.0)
class hydpy.models.lland.lland_model.Update_LoggedSunshineDuration_V1[source]

Bases: hydpy.core.modeltools.Method

Log the sunshine duration values of the last 24 hours.

Requires the derived parameter:

NmbLogEntries

Requires the input sequence:

SunshineDuration

Updates the log sequence:

LoggedSunshineDuration

Example:

The following example shows that each new method call successively moves the three memorised values to the right and stores the respective new value on the most left position:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedsunshineduration.shape = 3
>>> logs.loggedsunshineduration = 0.0
>>> from hydpy import UnitTest
>>> test = UnitTest(model,
...                 model.update_loggedsunshineduration_v1,
...                 last_example=4,
...                 parseqs=(inputs.sunshineduration,
...                          logs.loggedsunshineduration))
>>> test.nexts.sunshineduration = 1.0, 3.0, 2.0, 4.0
>>> del test.inits.loggedsunshineduration
>>> test()
| ex. | sunshineduration |           loggedsunshineduration |
-------------------------------------------------------------
|   1 |              1.0 | 1.0  0.0                     0.0 |
|   2 |              3.0 | 3.0  1.0                     0.0 |
|   3 |              2.0 | 2.0  3.0                     1.0 |
|   4 |              4.0 | 4.0  2.0                     3.0 |
class hydpy.models.lland.lland_model.Calc_DailySunshineDuration_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the sunshine duration sum of the last 24 hours.

Requires the derived parameter:

NmbLogEntries

Requires the log sequence:

LoggedSunshineDuration

Updates the flux sequence:

DailySunshineDuration

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedsunshineduration.shape = 3
>>> logs.loggedsunshineduration = 1.0, 5.0, 3.0
>>> model.calc_dailysunshineduration_v1()
>>> fluxes.dailysunshineduration
dailysunshineduration(9.0)
class hydpy.models.lland.lland_model.Calc_NKor_V1[source]

Bases: hydpy.core.modeltools.Method

Adjust the given precipitation value [4].

Requires the control parameters:

NHRU KG

Requires the input sequence:

Nied

Calculates the flux sequence:

NKor

Basic equation:

\(NKor = KG \cdot Nied\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> kg(0.8, 1.0, 1.2)
>>> inputs.nied = 10.0
>>> model.calc_nkor_v1()
>>> fluxes.nkor
nkor(8.0, 10.0, 12.0)
class hydpy.models.lland.lland_model.Calc_TKor_V1[source]

Bases: hydpy.core.modeltools.Method

Adjust the given air temperature value.

Requires the control parameters:

NHRU KT

Requires the input sequence:

TemL

Calculates the flux sequence:

TKor

Basic equation:

\(TKor = KT + TemL\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> kt(-2.0, 0.0, 2.0)
>>> inputs.teml(1.0)
>>> model.calc_tkor_v1()
>>> fluxes.tkor
tkor(-1.0, 1.0, 3.0)
class hydpy.models.lland.lland_model.Calc_TKorTag_V1[source]

Bases: hydpy.core.modeltools.Method

Adjust the given daily air temperature value.

Requires the control parameters:

NHRU KT

Requires the flux sequence:

TemLTag

Calculates the flux sequence:

TKorTag

Basic equation:

\(TKorTag = KT + TemLTag\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> kt(-2.0, 0.0, 2.0)
>>> fluxes.temltag(1.0)
>>> model.calc_tkortag_v1()
>>> fluxes.tkortag
tkortag(-1.0, 1.0, 3.0)
class hydpy.models.lland.lland_model.Return_AdjustedWindSpeed_V1[source]

Bases: hydpy.core.modeltools.Method

Adjust and return the measured wind speed to the given defined height above the ground [4].

Required by the methods:

Calc_WindSpeed10m_V1 Calc_WindSpeed2m_V1

Requires the control parameter:

MeasuringHeightWindSpeed

Requires the fixed parameter:

Z0

Requires the input sequence:

WindSpeed

Basic equation:

\(WindSpeed \cdot \frac{ln(newheight/Z0)}{ln(MeasuringHeightWindSpeed/Z0)}\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(1)
>>> measuringheightwindspeed(10.0)
>>> inputs.windspeed = 5.0
>>> from hydpy import round_
>>> round_(model.return_adjustedwindspeed_v1(2.0))
4.007956
>>> round_(model.return_adjustedwindspeed_v1(0.5))
3.153456
class hydpy.models.lland.lland_model.Calc_WindSpeed2m_V1[source]

Bases: hydpy.core.modeltools.Method

Adjust the measured wind speed to a height of 2 meters above the ground.

Required submethod:

Return_AdjustedWindSpeed_V1

Requires the control parameter:

MeasuringHeightWindSpeed

Requires the fixed parameter:

Z0

Requires the input sequence:

WindSpeed

Calculates the flux sequence:

WindSpeed2m

Method Calc_WindSpeed2m_V1 uses method Return_AdjustedWindSpeed_V1 to adjust the wind speed of all hydrological response units.

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(1)
>>> measuringheightwindspeed(10.0)
>>> inputs.windspeed = 5.0
>>> model.calc_windspeed2m_v1()
>>> fluxes.windspeed2m
windspeed2m(4.007956)
class hydpy.models.lland.lland_model.Calc_ReducedWindSpeed2m_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the landuse-use-specific wind speed at height of 2 meters [4] (based on [5], [6]).

Requires the control parameters:

NHRU Lnk LAI P1Wind P2Wind

Requires the derived parameter:

MOY

Requires the flux sequence:

WindSpeed2m

Calculates the flux sequence:

ReducedWindSpeed2m

Basic equation (for forests):

\(ReducedWindSpeed2m = max(P1Wind - P2Wind \cdot LAI, 0) \cdot WindSpeed2m\)

Example:

The basic equation given above holds for forests (hydrological response units of type LAUBW, MISCHW, and NADELW only. For all other landuse-use types method Calc_ReducedWindSpeed2m_V1 maintains the given wind speed for grass:

>>> from hydpy import pub
>>> pub.timegrids = "2019-05-30", "2019-06-03", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(4)
>>> lnk(OBSTB, LAUBW, MISCHW, NADELW)
>>> lai.obstb_mai = 0.0
>>> lai.laubw_mai = 2.0
>>> lai.mischw_mai = 4.0
>>> lai.nadelw_mai = 7.0
>>> p1wind(0.5)
>>> p2wind(0.1)
>>> derived.moy.update()
>>> fluxes.windspeed2m = 2.0
>>> model.idx_sim = pub.timegrids.init["2019-05-31"]
>>> model.calc_reducedwindspeed2m_v1()
>>> fluxes.reducedwindspeed2m
reducedwindspeed2m(2.0, 0.6, 0.2, 0.0)

>>> lai.obstb_jun = 0.0
>>> lai.laubw_jun = 3.0
>>> lai.mischw_jun = 6.0
>>> lai.nadelw_jun = 10.0
>>> model.idx_sim = pub.timegrids.init["2019-06-01"]
>>> model.calc_reducedwindspeed2m_v1()
>>> fluxes.reducedwindspeed2m
reducedwindspeed2m(2.0, 0.4, 0.0, 0.0)
class hydpy.models.lland.lland_model.Calc_WindSpeed10m_V1[source]

Bases: hydpy.core.modeltools.Method

Adjust the measured wind speed to a height of 10 meters above the ground.

Required submethod:

Return_AdjustedWindSpeed_V1

Requires the control parameter:

MeasuringHeightWindSpeed

Requires the fixed parameter:

Z0

Requires the input sequence:

WindSpeed

Calculates the flux sequence:

WindSpeed10m

Method Calc_WindSpeed10m_V1 uses method Return_AdjustedWindSpeed_V1 to adjust the wind speed of all hydrological response units.

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(1)
>>> measuringheightwindspeed(3.0)
>>> inputs.windspeed = 5.0
>>> model.calc_windspeed10m_v1()
>>> fluxes.windspeed10m
windspeed10m(5.871465)
class hydpy.models.lland.lland_model.Calc_SolarDeclination_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the solar declination ([4]).

Requires the derived parameter:

DOY

Requires the fixed parameter:

Pi

Calculates the flux sequence:

SolarDeclination

Additional requirements:

idx_sim

Basic equation:

\(SolarDeclination = 0.41 \cdot cos \left( \frac{2 \cdot Pi \cdot (DOY - 171)}{365} \right)\)

Examples:

We define an initialisation period covering both a leap year (2000) and a non-leap year (2001):

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> from hydpy import pub, round_
>>> pub.timegrids = "2000-01-01", "2002-01-01", "1d"
>>> derived.doy.update()

The following convenience function applies method Calc_SolarDeclination_V1 for the given dates and prints the results:

>>> def test(*dates):
...     for date in dates:
...         model.idx_sim = pub.timegrids.init[date]
...         model.calc_solardeclination_v1()
...         print(date, end=": ")
...         round_(fluxes.solardeclination.value)

The results are identical for both years, due to :

>>> test("2000-01-01", "2000-02-28", "2000-02-29",
...      "2000-03-01", "2000-12-31")
2000-01-01: -0.401992
2000-02-28: -0.149946
2000-02-29: -0.143355
2000-03-01: -0.136722
2000-12-31: -0.401992

>>> test("2001-01-01", "2001-02-28",
...      "2001-03-01", "2001-12-31")
2001-01-01: -0.401992
2001-02-28: -0.149946
2001-03-01: -0.136722
2001-12-31: -0.401992
class hydpy.models.lland.lland_model.Calc_TSA_TSU_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate time of sunrise and sunset of the current day [4] (based on [7]).

Requires the control parameter:

Longitude

Requires the derived parameters:

LatitudeRad UTCLongitude

Requires the fixed parameter:

Pi

Requires the flux sequence:

SolarDeclination

Calculates the flux sequences:

TSA TSU

Basic equations:

\(TSA^* = \frac{12}{Pi} \cdot acos \left( tan(SolarDeclination) \cdot tan(LatitudeRad) + \frac{0.0145}{cos(SolarDeclination) \cdot cos(LatitudeRad)} \right)\)

\(\delta = \frac{4 \cdot (UTCLongitude - Longitude)}{60}\)

\(TSA = TSA^* + \delta\)

\(TSU = 24 - TSA^* + \delta\)

Examples:

We calculate the local time of sunrise and sunset for a latitude of approximately 52°N and a longitude of 10°E, which is 5° west of the longitude defining the local time zone:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> longitude(10.0)
>>> derived.utclongitude(15.0)
>>> derived.latituderad(0.9)

The sunshine duration varies between seven hours at winter solstice and 16 hours at summer solstice:

>>> fluxes.solardeclination = -0.41
>>> model.calc_tsa_tsu_v1()
>>> fluxes.tsa
tsa(8.432308)
>>> fluxes.tsu
tsu(16.234359)
>>> fluxes.solardeclination = 0.41
>>> model.calc_tsa_tsu_v1()
>>> fluxes.tsa
tsa(4.002041)
>>> fluxes.tsu
tsu(20.664625)
class hydpy.models.lland.lland_model.Calc_EarthSunDistance_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the relative inverse distance between the earth and the sun.

Requires the derived parameter:

DOY

Requires the fixed parameter:

Pi

Calculates the flux sequence:

EarthSunDistance

Basic equation ([14], equation 23):

\(EarthSunDistance = 1 + 0.033 \cdot cos \bigl( 2 \cdot Pi / 366 \cdot (DOY + 1) \bigr)\)

Note that this equation differs a little from the one given by Allen [14]. The following examples show that Calc_EarthSunDistance_V1 calculates the same distance value for a specific “day” (e.g. the 1st March) both for leap years and non-leap years. Hence, there is a tiny “jump” between the 28th February and the 1st March for non-leap years.

Examples:

We define an initialisation period covering both a leap year (2000) and a non-leap year (2001):

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> from hydpy import pub, round_
>>> pub.timegrids = "2000-01-01", "2002-01-01", "1d"
>>> derived.doy.update()

The following convenience function applies method Calc_EarthSunDistance_V1 for the given dates and prints the results:

>>> def test(*dates):
...     for date in dates:
...         model.idx_sim = pub.timegrids.init[date]
...         model.calc_earthsundistance_v1()
...         print(date, end=": ")
...         round_(fluxes.earthsundistance.value)

The results are identical for both years:

>>> test("2000-01-01", "2000-02-28", "2000-02-29",
...      "2000-03-01", "2000-07-01", "2000-12-31")
2000-01-01: 1.032995
2000-02-28: 1.017471
2000-02-29: 1.016988
2000-03-01: 1.0165
2000-07-01: 0.967
2000-12-31: 1.033

>>> test("2001-01-01", "2001-02-28",
...      "2001-03-01", "2001-07-01", "2001-12-31")
2001-01-01: 1.032995
2001-02-28: 1.017471
2001-03-01: 1.0165
2001-07-01: 0.967
2001-12-31: 1.033

The following calculation agrees with example 8 of Allen [14]:

>>> derived.doy(246)
>>> model.idx_sim = 0
>>> model.calc_earthsundistance_v1()
>>> fluxes.earthsundistance
earthsundistance(0.984993)
class hydpy.models.lland.lland_model.Calc_ExtraterrestrialRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the amount of extraterrestrial radiation of the current day [4] (based on [7]).

Requires the derived parameter:

LatitudeRad

Requires the fixed parameters:

Pi Sol

Requires the flux sequences:

SolarDeclination EarthSunDistance TSA TSU

Calculates the flux sequence:

ExtraterrestrialRadiation

Basic equation:

\(ExternalTerrestrialRadiation = \frac{Sol \cdot EarthSunDistance \cdot ( SunsetHourAngle \cdot sin(LatitudeRad) \cdot sin(SolarDeclination) + cos(LatitudeRad) \cdot cos(SolarDeclination) \cdot sin(SunsetHourAngle) )}{PI}\)

\(SunsetHourAngle = (TSU-TSA) \cdot \frac{Pi}{24}\)

Examples:

First, we calculate the extraterrestrial radiation for a latitude of approximately 52°N:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> derived.latituderad(0.9)

The sunshine duration varies between seven hours at winter solstice and 16 hours at summer solstice, which corresponds to a daily sum of extraterrestrial radiation of 6.1 and 44.4 MJ/m², respectively:

>>> fluxes.solardeclination = -0.41
>>> fluxes.earthsundistance = 0.97
>>> fluxes.tsa = 8.4
>>> fluxes.tsu = 15.6
>>> model.calc_extraterrestrialradiation_v1()
>>> fluxes.extraterrestrialradiation
extraterrestrialradiation(6.087605)

>>> fluxes.solardeclination = 0.41
>>> fluxes.earthsundistance = 1.03
>>> fluxes.tsa = 4.0
>>> fluxes.tsu = 20.0
>>> model.calc_extraterrestrialradiation_v1()
>>> fluxes.extraterrestrialradiation
extraterrestrialradiation(44.44131)
class hydpy.models.lland.lland_model.Calc_PossibleSunshineDuration_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the possible astronomical sunshine duration [4].

Requires the derived parameters:

SCT Hours

Requires the flux sequences:

TSA TSU

Calculates the flux sequence:

PossibleSunshineDuration

Basic equation:

\(PossibleSunshineDuration = max \bigl( max(SCT-Hours/2, TSA) - min(SCT+Hours/2, TSU), 0 \bigr)\)

Examples:

We focus on winter conditions with a relatively short possible sunshine duration:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> fluxes.tsa(8.4)
>>> fluxes.tsu(15.6)

We start with a daily simulation time step. The possible sunshine duration is, as to be expected, the span between sunrise and sunset:

>>> from hydpy import pub, round_
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> derived.sct.update()
>>> derived.hours.update()
>>> model.calc_possiblesunshineduration_v1()
>>> fluxes.possiblesunshineduration
possiblesunshineduration(7.2)

The following example calculates the hourly possible sunshine durations of the same day:

>>> pub.timegrids = "2000-01-01", "2000-01-02", "1h"
>>> derived.sct.update()
>>> derived.hours.update()
>>> sum_ = 0.0
>>> for idx in range(24):
...     model.idx_sim = idx
...     model.calc_possiblesunshineduration_v1()
...     print(idx+1, end=": ")   
...     round_(fluxes.possiblesunshineduration.value)
...     sum_ += fluxes.possiblesunshineduration.value
1: 0.0
...
9: 0.6
10: 1.0
...
15: 1.0
16: 0.6
17: 0.0
...
24: 0.0

The sum of the hourly possible sunshine durations equals the daily possible sunshine, of course:

>>> round_(sum_)
7.2
class hydpy.models.lland.lland_model.Calc_DailyPossibleSunshineDuration_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the possible astronomical sunshine duration.

Requires the flux sequences:

TSA TSU

Calculates the flux sequence:

DailyPossibleSunshineDuration

Basic equation:

\(PossibleSunshineDuration = TSU - TSA\)

Examples:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> fluxes.tsa(8.4)
>>> fluxes.tsu(15.6)
>>> model.calc_dailypossiblesunshineduration()
>>> fluxes.dailypossiblesunshineduration
dailypossiblesunshineduration(7.2)
class hydpy.models.lland.lland_model.Calc_SP_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the relative sum of radiation [8].

Requires the derived parameters:

SCT Hours

Requires the fixed parameter:

Pi

Requires the flux sequences:

TSA TSU

Calculates the flux sequence:

SP

Additional requirements:

idx_sim

Basic equations:

\[SP = S_P^*(SCT + Hours/2) - S_P^*(SCT - Hours/2)\]
\[\begin{split}S_P^*(t) = \begin{cases} 0 &|\ TL_P(t) \leq 0 \\ 50 - 50 \cdot cos\bigl(1.8 \cdot TL_P(t)\bigr) - 3.4 \cdot sin\bigl(3.6 \cdot TL_P(t)\bigr)^2 &|\ 0 < TL_P(t) \leq 50 \cdot \frac{2 \cdot Pi}{360} \\ 50 - 50 \cdot cos\bigl(1.8 \cdot TL_P(t)\bigr) + 3.4 \cdot sin\bigl(3.6 \cdot TL_P(t)\bigr)^2 &|\ 50 \cdot \frac{2 \cdot Pi}{360} < TL_P(t) < 100 \cdot \frac{2 \cdot Pi}{360} \\ 100 &|\ 100 \cdot \frac{2 \cdot Pi}{360} \leq TL_P(t) \end{cases}\end{split}\]
\[TL_P(t) = 100 \cdot \frac{2 \cdot Pi}{360} \cdot \frac{t - TSA}{TSU - TSA}\]

Examples:

We focus on winter conditions with a relatively short possible sunshine duration:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> fluxes.tsa(8.4)
>>> fluxes.tsu(15.6)

We start with an hourly simulation time step. The relative radiation sum is, as to be expected, zero before sunrise and after sunset. In between, it reaches its maximum around noon:

>>> from hydpy import pub, round_
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1h"
>>> derived.sct.update()
>>> derived.hours.update()
>>> for idx in range(7, 17):
...     model.idx_sim = idx
...     model.calc_sp_v1()
...     print(idx+1, end=": ")
...     round_(fluxes.sp.value)
8: 0.0
9: 0.853709
10: 7.546592
11: 18.473585
12: 23.126115
13: 23.126115
14: 18.473585
15: 7.546592
16: 0.853709
17: 0.0

The following examples show how method Calc_SP_V1 works for time step sizes longer than one hour:

>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> derived.sct.update()
>>> derived.hours.update()
>>> model.idx_sim = 0
>>> model.calc_sp_v1()
>>> fluxes.sp
sp(100.0)

>>> pub.timegrids = "2000-01-01", "2000-01-02", "6h"
>>> derived.sct.update()
>>> derived.hours.update()
>>> for idx in range(4):
...     model.idx_sim = idx
...     model.calc_sp_v1()
...     print((idx+1)*6, end=": ")
...     round_(fluxes.sp.value)
6: 0.0
12: 50.0
18: 50.0
24: 0.0

>>> pub.timegrids = "2000-01-01", "2000-01-02", "3h"
>>> derived.sct.update()
>>> derived.hours.update()
>>> for idx in range(8):
...     model.idx_sim = idx
...     model.calc_sp_v1()
...     print((idx+1)*3, end=": ")
...     round_(fluxes.sp.value)
3: 0.0
6: 0.0
9: 0.853709
12: 49.146291
15: 49.146291
18: 0.853709
21: 0.0
24: 0.0

Often, method Calc_SP_V1 calculates a small but unrealistic “bumb” around noon (for example, the relative radiation is slightly smaller between 11:30 and 12:00 than it is between 11:00 and 11:30):

>>> pub.timegrids = "2000-01-01", "2000-01-02", "30m"
>>> derived.sct.update()
>>> derived.hours.update()
>>> for idx in range(15, 33):
...     model.idx_sim = idx
...     model.calc_sp_v1()
...     print((idx+1)/2, end=": ")
...     round_(fluxes.sp.value)
8.0: 0.0
8.5: 0.021762
9.0: 0.831947
9.5: 2.514315
10.0: 5.032276
10.5: 7.989385
11.0: 10.4842
11.5: 11.696873
12.0: 11.429242
12.5: 11.429242
13.0: 11.696873
13.5: 10.4842
14.0: 7.989385
14.5: 5.032276
15.0: 2.514315
15.5: 0.831947
16.0: 0.021762
16.5: 0.0
class hydpy.models.lland.lland_model.Return_DailyGlobalRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the daily global radiation [4].

Required by the methods:

Calc_DailyGlobalRadiation_V1 Calc_GlobalRadiation_V1

Requires the control parameters:

AngstromConstant AngstromFactor AngstromAlternative

Requires the derived parameters:

MOY Days

Requires the flux sequence:

ExtraterrestrialRadiation

Additional requirements:

idx_sim

Basic equation:
\[\begin{split}ExtraterrestrialRadiation \cdot \begin{cases} AngstromConstant + AngstromFactor \cdot \frac{sunshineduration}{possiblesunshineduration} &|\ sunshineduration > 0 \;\; \lor \;\; Days < 1 \\ AngstromAlternative &|\ sunshineduration = 0 \;\; \land \;\; Days \geq1 \end{cases}\end{split}\]

Example:

You can define the underlying Angstrom coefficients on a monthly basis to reflect the annual variability in the relationship between sunshine duration and global radiation. First, we demonstrate this for a daily time-step basis:

>>> from hydpy import pub, round_
>>> pub.timegrids = "2000-01-30", "2000-02-03", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> derived.moy.update()
>>> derived.days.update()
>>> angstromconstant.jan = 0.1
>>> angstromfactor.jan = 0.5
>>> angstromalternative.jan = 0.2
>>> angstromconstant.feb = 0.2
>>> angstromfactor.feb = 0.6
>>> angstromalternative.feb = 0.3
>>> fluxes.extraterrestrialradiation = 1.7
>>> model.idx_sim = 1
>>> round_(model.return_dailyglobalradiation_v1(0.6, 1.0))
0.68
>>> model.idx_sim = 2
>>> round_(model.return_dailyglobalradiation_v1(0.6, 1.0))
0.952

If possible sunshine duration is zero, we generally set global radiation to zero (even if the actual sunshine duration is larger than zero, which might occur as a result of small inconsistencies between measured and calculated input data):

>>> round_(model.return_dailyglobalradiation_v1(0.6, 0.0))
0.0

When actual sunshine is zero, the alternative Angstrom coefficient applies:

>>> model.idx_sim = 1
>>> round_(model.return_dailyglobalradiation_v1(0.0, 1.0))
0.34
>>> model.idx_sim = 2
>>> round_(model.return_dailyglobalradiation_v1(0.0, 1.0))
0.51

All of the examples and explanations above hold for short simulation time steps, except that parameter AngstromAlternative does never replace parameter AngstromConstant:

>>> pub.timegrids = "2000-01-30", "2000-02-03", "1h"
>>> derived.moy.update()
>>> derived.days.update()
>>> model.idx_sim = 1
>>> round_(model.return_dailyglobalradiation_v1(0.0, 1.0))
0.17
class hydpy.models.lland.lland_model.Calc_GlobalRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the global radiation [4].

Required submethod:

Return_DailyGlobalRadiation_V1

Requires the control parameters:

AngstromConstant AngstromFactor AngstromAlternative

Requires the derived parameters:

MOY Days

Requires the input sequence:

SunshineDuration

Requires the flux sequences:

ExtraterrestrialRadiation PossibleSunshineDuration DailySunshineDuration DailyPossibleSunshineDuration SP

Calculates the flux sequence:

GlobalRadiation

Additional requirements:

idx_sim

Basic equation:
\[\begin{split}GlobalRadiation = \frac{SP}{100}\cdot \begin{cases} Return\_DailyGlobalRadiation\_V1( SunshineDuration, PossibleSunshineDuration) &|\ PossibleSunshineDuration > 0 \\ Return\_DailyGlobalRadiation\_V1( DailySunshineDuration, DailyPossibleSunshineDuration) &|\ PossibleSunshineDuration = 0 \end{cases}\end{split}\]

Examples:

Method Calc_GlobalRadiation_V1 uses the actual value of SP and method Return_DailyGlobalRadiation_V1, to calculate the current global radiation agreeing with the current values of sequence SunshineDuration and sequence PossibleSunshineDuration:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-30", "2000-02-03", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> derived.nmblogentries.update()
>>> derived.moy.update()
>>> derived.days.update()
>>> angstromconstant.jan = 0.1
>>> angstromconstant.jan = 0.1
>>> angstromfactor.jan = 0.5
>>> angstromalternative.jan = 0.2
>>> inputs.sunshineduration = 0.6
>>> fluxes.possiblesunshineduration = 1.0
>>> fluxes.extraterrestrialradiation = 1.7
>>> fluxes.sp = 50.0
>>> model.idx_sim = 1
>>> model.calc_globalradiation_v1()
>>> fluxes.globalradiation
globalradiation(0.34)

During nightime periods, the value of PossibleSunshineDuration is zero. Then, method Calc_GlobalRadiation_V1 uses the values of the sequences DailySunshineDuration and DailyPossibleSunshineDuration as surrogates:

>>> fluxes.possiblesunshineduration = 0.0
>>> fluxes.dailysunshineduration = 4.0
>>> fluxes.dailypossiblesunshineduration = 10.0

>>> model.calc_globalradiation_v1()
>>> fluxes.globalradiation
globalradiation(0.255)
class hydpy.models.lland.lland_model.Update_LoggedGlobalRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Log the global radiation values of the last 24 hours.

Requires the derived parameter:

NmbLogEntries

Requires the flux sequence:

GlobalRadiation

Updates the log sequence:

LoggedGlobalRadiation

Example:

The following example shows that each new method call successively moves the three memorised values to the right and stores the respective new value on the most left position:

>>> from hydpy.models.lland import *
>>> simulationstep("8h")
>>> parameterstep()
>>> derived.nmblogentries.update()
>>> logs.loggedglobalradiation = 0.0
>>> from hydpy import UnitTest
>>> test = UnitTest(model,
...                 model.update_loggedglobalradiation_v1,
...                 last_example=4,
...                 parseqs=(fluxes.globalradiation,
...                          logs.loggedglobalradiation))
>>> test.nexts.globalradiation = 1.0, 3.0, 2.0, 4.0
>>> del test.inits.loggedglobalradiation
>>> test()
| ex. | globalradiation |           loggedglobalradiation |
-----------------------------------------------------------
|   1 |             1.0 | 1.0  0.0                    0.0 |
|   2 |             3.0 | 3.0  1.0                    0.0 |
|   3 |             2.0 | 2.0  3.0                    1.0 |
|   4 |             4.0 | 4.0  2.0                    3.0 |
class hydpy.models.lland.lland_model.Calc_DailyGlobalRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the daily global radiation.

Required submethod:

Return_DailyGlobalRadiation_V1

Requires the control parameters:

AngstromConstant AngstromFactor AngstromAlternative

Requires the derived parameters:

MOY Days

Requires the flux sequences:

ExtraterrestrialRadiation DailySunshineDuration DailyPossibleSunshineDuration

Updates the flux sequence:

DailyGlobalRadiation

Additional requirements:

idx_sim

Basic equation:

\(DailyGlobalRadiation = Return\_DailyGlobalRadiation\_( DailySunshineDuration, DailyPossibleSunshineDuration)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> from hydpy import pub
>>> angstromconstant.jan = 0.1
>>> angstromfactor.jan = 0.5
>>> angstromconstant.feb = 0.2
>>> angstromfactor.feb = 0.6

We define the extraterrestrial radiation to 10 MJ/m² and the possible sunshine duration to 12 hours:

>>> fluxes.extraterrestrialradiation = 10.0
>>> fluxes.dailypossiblesunshineduration = 12.0

We define a daily simulation step size and update the relevant derived parameters:

>>> pub.timegrids = "2000-01-30", "2000-02-03", "1d"
>>> derived.moy.update()
>>> derived.nmblogentries.update()

Applying the Angstrom coefficients for January and February on the defined extraterrestrial radiation and a sunshine duration of 7.2 hours results in a daily global radiation sum of 4.0 MJ/m² and 5.6 MJ/m², respectively:

>>> model.idx_sim = 1
>>> fluxes.dailysunshineduration = 7.2
>>> model.calc_dailyglobalradiation_v1()
>>> fluxes.dailyglobalradiation
dailyglobalradiation(4.0)

>>> model.idx_sim = 2
>>> model.calc_dailyglobalradiation_v1()
>>> fluxes.dailyglobalradiation
dailyglobalradiation(5.6)

Finally, we demonstrate for January that method Calc_DailyGlobalRadiation_V1 calculates the same values for an hourly simulation time step, as long as the daily sum of sunshine duration remains identical:

>>> pub.timegrids = "2000-01-30", "2000-02-03", "1h"
>>> derived.moy.update()
>>> derived.nmblogentries.update()

The actual simulation step starts at 11 o’clock and ends at 12 o’clock:

>>> model.idx_sim = pub.timegrids.init["2000-01-31 11:00"]
>>> fluxes.dailysunshineduration = 7.2
>>> model.calc_dailyglobalradiation_v1()
>>> fluxes.dailyglobalradiation
dailyglobalradiation(4.0)
class hydpy.models.lland.lland_model.Calc_AdjustedGlobalRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Adjust the current global radiation to the daily global radiation.

Requires the derived parameter:

NmbLogEntries

Requires the flux sequences:

GlobalRadiation DailyGlobalRadiation

Requires the log sequence:

LoggedGlobalRadiation

Updates the flux sequence:

AdjustedGlobalRadiation

Additional requirements:

idx_sim

Basic equation:

\(AdjustedGlobalRadiation = GlobalRadiation \cdot \frac{DailyGlobalRadiation}{\sum LoggedGlobalRadiation}\)

Examples:

The purpose of method Calc_AdjustedGlobalRadiation_V1 is to adjust hourly global radiation values (or those of other short simulation time steps) so that their sum over the last 24 hours equals the global radiation value directly calculated with the relative sunshine duration over the last 24 hours. We try to explain this somewhat contraintuitive approach by building up the examples on the examples on the documentation on method Calc_DailyGlobalRadiation_V1.

Again, we start with a daily simulation time step:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep()
>>> derived.nmblogentries.update()

For such a daily simulation time step, the values of the sequences GlobalRadiation, DailyGlobalRadiation, and LoggedGlobalRadiation must be identical:

>>> model.idx_sim = 1
>>> fluxes.globalradiation = 4.0
>>> fluxes.dailyglobalradiation = 4.0
>>> logs.loggedglobalradiation = 4.0

After calling method Calc_AdjustedGlobalRadiation_V1, the same holds for the adjusted global radiation sum:

>>> model.calc_adjustedglobalradiation_v1()
>>> fluxes.adjustedglobalradiation
adjustedglobalradiation(4.0)

Normally, one would not expect method Calc_AdjustedGlobalRadiation_V1 to have an effect when applied on daily simulation time steps at all. However, it corrects “wrong” predefined global radiation values:

>>> fluxes.dailyglobalradiation = 5.6
>>> model.calc_adjustedglobalradiation_v1()
>>> fluxes.adjustedglobalradiation
adjustedglobalradiation(5.6)

We now demonstrate how method Calc_AdjustedGlobalRadiation_V1 actually works for hourly simulation time steps:

>>> simulationstep("1h")
>>> derived.nmblogentries.update()

The daily global radiation value does not depend on the simulation time step. We reset it to 4 MJ/m²/d:

>>> fluxes.dailyglobalradiation = 4.0

The other global radiation values now must be smaller and vary throughout the day. We set them consistently with the values of the logged sunshine duration in the documentation on method Calc_DailyGlobalRadiation_V1:

>>> fluxes.globalradiation = 0.8
>>> logs.loggedglobalradiation = (
...     0.8, 0.8, 0.2, 0.1, 0.1, 0.0,
...     0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
...     0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
...     0.0, 0.1, 0.4, 0.6, 0.7, 0.8)

Compared with the total 24 hours, the simulation time steps around noon are relatively sunny, both for the current and the last day (see the first and the last entries of the log sequence for sunshine duration). Accordingly, the sum of the hourly global radiation values (4.6 W/m²) is larger than the directly calculated daily sum (4.0 W/m²). Method Calc_AdjustedGlobalRadiation_V1 uses the fraction of both sums to finally calculate the adjusted global radiation (\(0.8 \cdot 4.0 / 4.6\)):

>>> model.calc_adjustedglobalradiation_v1()
>>> fluxes.adjustedglobalradiation
adjustedglobalradiation(0.695652)
class hydpy.models.lland.lland_model.Calc_ET0_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate reference evapotranspiration after Turc-Wendling.

Requires the control parameters:

NHRU KE KF HNN

Requires the input sequence:

Glob

Requires the flux sequence:

TKor

Calculates the flux sequence:

ET0

Basic equation:

\(ET0 = KE \cdot \frac{(8.64 \cdot Glob+93 \cdot KF) \cdot (TKor+22)} {165 \cdot (TKor+123) \cdot (1 + 0.00019 \cdot min(HNN, 600))}\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> ke(1.1)
>>> kf(0.6)
>>> hnn(200.0, 600.0, 1000.0)
>>> inputs.glob = 200.0
>>> fluxes.tkor = 15.0
>>> model.calc_et0_v1()
>>> fluxes.et0
et0(3.07171, 2.86215, 2.86215)
class hydpy.models.lland.lland_model.Calc_ET0_WET0_V1[source]

Bases: hydpy.core.modeltools.Method

Correct the given reference evapotranspiration and update the corresponding log sequence.

Requires the control parameters:

NHRU WfET0 KE

Requires the input sequence:

PET

Updates the log sequence:

WET0

Calculates the flux sequence:

ET0

Basic equation:

\(ET0_{new} = WfET0 \cdot KE \cdot PET + (1-WfET0) \cdot ET0_{old}\)

Example:

Prepare four hydrological response units with different value combinations of parameters KE and WfET0:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> simulationstep("12h")
>>> nhru(4)
>>> ke(0.8, 1.2, 0.8, 1.2)
>>> wfet0(2.0, 2.0, 0.2, 0.2)

Note that the actual value of time dependend parameter WfET0 is reduced due the difference between the given parameter and simulation time steps:

>>> from hydpy import round_
>>> round_(wfet0.values)
1.0, 1.0, 0.1, 0.1

For the first two hydrological response units, the given PET value is modified by -0.4 mm and +0.4 mm, respectively. For the other two response units, which weight the “new” evapotranspiration value with 10 %, ET0 does deviate from the old value of WET0 by -0.04 mm and +0.04 mm only:

>>> inputs.pet = 2.0
>>> logs.wet0 = 2.0
>>> model.calc_et0_wet0_v1()
>>> fluxes.et0
et0(1.6, 2.4, 1.96, 2.04)
>>> logs.wet0
wet0([[1.6, 2.4, 1.96, 2.04]])
class hydpy.models.lland.lland_model.Calc_EvPo_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the potential evapotranspiration for the relevant land use and month.

Requires the control parameters:

NHRU Lnk FLn

Requires the derived parameter:

MOY

Requires the flux sequence:

ET0

Calculates the flux sequence:

EvPo

Additional requirements:

idx_sim

Basic equation:

\(EvPo = FLn \cdot ET0\)

Example:

For clarity, this is more of a kind of an integration example. Parameter FLn both depends on time (the actual month) and space (the actual land use). Firstly, let us define a initialization time period spanning the transition from June to July:

>>> from hydpy import pub
>>> pub.timegrids = "30.06.2000", "02.07.2000", "1d"

Secondly, assume that the considered subbasin is differenciated in two HRUs, one of primarily consisting of arable land and the other one of deciduous forests:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(2)
>>> lnk(ACKER, LAUBW)

Thirdly, set the FLn values, one for the relevant months and land use classes:

>>> fln.acker_jun = 1.299
>>> fln.acker_jul = 1.304
>>> fln.laubw_jun = 1.350
>>> fln.laubw_jul = 1.365

Fourthly, the index array connecting the simulation time steps defined above and the month indexes (0…11) can be retrieved from the pub module. This can be done manually more conveniently via its update method:

>>> derived.moy.update()
>>> derived.moy
moy(5, 6)

Finally, the actual method (with its simple equation) is applied as usual:

>>> fluxes.et0 = 2.0
>>> model.idx_sim = 0
>>> model.calc_evpo_v1()
>>> fluxes.evpo
evpo(2.598, 2.7)
>>> model.idx_sim = 1
>>> model.calc_evpo_v1()
>>> fluxes.evpo
evpo(2.608, 2.73)
class hydpy.models.lland.lland_model.Calc_NBes_Inzp_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate stand precipitation and update the interception storage accordingly.

Requires the control parameters:

NHRU Lnk

Requires the derived parameters:

MOY KInz

Requires the flux sequence:

NKor

Updates the state sequence:

Inzp

Calculates the flux sequence:

NBes

Additional requirements:

idx_sim

Basic equation:
\[\begin{split}NBes = \begin{cases} PKor &|\ Inzp = KInz \\ 0 &|\ Inzp < KInz \end{cases}\end{split}\]

Examples:

Initialise five HRUs with different land usages:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(5)
>>> lnk(SIED_D, FEUCHT, GLETS, FLUSS, SEE)

Define KInz values for July the selected land usages directly:

>>> derived.kinz.sied_d_jul = 2.0
>>> derived.kinz.feucht_jul = 1.0
>>> derived.kinz.glets_jul = 0.0
>>> derived.kinz.fluss_jul = 1.0
>>> derived.kinz.see_jul = 1.0

Now we prepare a MOY object, that assumes that the first, second, and third simulation time steps are in June, July, and August respectively (we make use of the value defined above for July, but setting the values of parameter MOY this way allows for a more rigorous testing of proper indexing):

>>> derived.moy.shape = 3
>>> derived.moy = 5, 6, 7
>>> model.idx_sim = 1

The dense settlement (SIED_D), the wetland area (FEUCHT), and both water areas (FLUSS and SEE) start with a initial interception storage of 1/2 mm, the glacier (GLETS) and water areas (FLUSS and SEE) start with 0 mm. In the first example, actual precipition is 1 mm:

>>> states.inzp = 0.5, 0.5, 0.0, 1.0, 1.0
>>> fluxes.nkor = 1.0
>>> model.calc_nbes_inzp_v1()
>>> states.inzp
inzp(1.5, 1.0, 0.0, 0.0, 0.0)
>>> fluxes.nbes
nbes(0.0, 0.5, 1.0, 0.0, 0.0)

Only for the settled area, interception capacity is not exceeded, meaning no stand precipitation occurs. Note that it is common in define zero interception capacities for glacier areas, but not mandatory. Also note that the KInz, Inzp and NKor values given for both water areas are ignored completely, and Inzp and NBes are simply set to zero.

If there is no precipitation, there is of course also no stand precipitation and interception storage remains unchanged:

>>> states.inzp = 0.5, 0.5, 0.0, 0.0, 0.0
>>> fluxes.nkor = 0.
>>> model.calc_nbes_inzp_v1()
>>> states.inzp
inzp(0.5, 0.5, 0.0, 0.0, 0.0)
>>> fluxes.nbes
nbes(0.0, 0.0, 0.0, 0.0, 0.0)

Interception capacities change discontinuously between consecutive months. This can result in little stand precipitation events in periods without precipitation:

>>> states.inzp = 1.0, 0.0, 0.0, 0.0, 0.0
>>> derived.kinz.sied_d_jul = 0.6
>>> fluxes.nkor = 0.0
>>> model.calc_nbes_inzp_v1()
>>> states.inzp
inzp(0.6, 0.0, 0.0, 0.0, 0.0)
>>> fluxes.nbes
nbes(0.4, 0.0, 0.0, 0.0, 0.0)
class hydpy.models.lland.lland_model.Calc_SNRatio_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the ratio of frozen to total precipitation [4].

Requires the control parameters:

NHRU TGr TSp

Requires the flux sequence:

TKor

Calculates the aide sequence:

SNRatio

Basic equation:

\(SNRatio = min\left(max\left(\frac{(TGr-TSp/2-TKor)}{TSp}, 0\right), 1\right)\)

Examples:

In the first example, the threshold temperature of seven hydrological response units is 0 °C and the temperature interval of mixed precipitation 2 °C:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(7)
>>> tgr(1.0)
>>> tsp(2.0)

The value of SNRatio is zero above 0 °C and 1 below 2 °C. Between these temperature values SNRatio decreases linearly:

>>> fluxes.nkor = 4.0
>>> fluxes.tkor = -1.0, 0.0, 0.5, 1.0, 1.5, 2.0, 3.0
>>> model.calc_snratio_v1()
>>> aides.snratio
snratio(1.0, 1.0, 0.75, 0.5, 0.25, 0.0, 0.0)

Note the special case of a zero temperature interval. With the actual temperature being equal to the threshold temperature, the the value of SNRatio is zero:

>>> tsp(0.0)
>>> model.calc_snratio_v1()
>>> aides.snratio
snratio(1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0)
class hydpy.models.lland.lland_model.Calc_SBes_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the frozen part of stand precipitation.

Requires the control parameter:

NHRU

Requires the flux sequence:

NBes

Requires the aide sequence:

SNRatio

Calculates the flux sequence:

SBes

Basic equation:

\(SBes = SNRatio \cdot NBes\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(2)
>>> fluxes.nbes = 10.0
>>> aides.snratio = 0.2, 0.8
>>> model.calc_sbes_v1()
>>> fluxes.sbes
sbes(2.0, 8.0)
class hydpy.models.lland.lland_model.Calc_SnowIntMax_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the current capacity of the snow interception storage.

Requires the control parameters:

NHRU Lnk LAI P1SIMax P2SIMax

Requires the derived parameter:

MOY

Requires the flux sequence:

TKor

Calculates the flux sequence:

SnowIntMax

Basic equation (see [4], equations 3.69 to 3.71):
\[\begin{split}SnowIntMax = \bigg( P1SIMax + P2SIMax \cdot LAI \bigg) \cdot \begin{cases} 1 &|\ TKor \leq -3 \\ (5 + TKor ) / 2 &|\ -3 < TKor < -1 \\ 2 &|\ -1 \leq TKor \end{cases}\end{split}\]

Examples:

>>> from hydpy import pub
>>> pub.timegrids = "2000-04-29", "2000-05-03", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(8)
>>> lnk(ACKER, LAUBW, LAUBW, LAUBW, LAUBW, LAUBW, MISCHW, NADELW)
>>> lai.laubw_apr = 4.0
>>> lai.laubw_mai = 7.0
>>> lai.mischw_apr = 6.0
>>> lai.mischw_mai = 8.0
>>> lai.nadelw = 11.0
>>> p1simax(8.0)
>>> p2simax(1.5)
>>> derived.moy.update()
>>> fluxes.tkor = 0.0, 0.0, -1.0, -2.0, -3.0, -4.0, -4.0, -4.0

>>> model.idx_sim = pub.timegrids.init["2000-04-30"]
>>> model.calc_snowintmax_v1()
>>> fluxes.snowintmax
snowintmax(0.0, 28.0, 28.0, 21.0, 14.0, 14.0, 17.0, 24.5)

>>> model.idx_sim = pub.timegrids.init["2000-05-01"]
>>> model.calc_snowintmax_v1()
>>> fluxes.snowintmax
snowintmax(0.0, 37.0, 37.0, 27.75, 18.5, 18.5, 20.0, 24.5)
class hydpy.models.lland.lland_model.Calc_SnowIntRate_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the ratio between the snow interception rate and precipitation intensity.

Requires the control parameters:

NHRU Lnk LAI P1SIRate P2SIRate P3SIRate

Requires the derived parameter:

MOY

Requires the state sequence:

SInz

Calculates the flux sequence:

SnowIntRate

Basic equation (see [4], equations 3.72 to 3.74):

\(SnowIntRate = min\big( P1SIRate + P2SIRate \cdot LAI + P3SIRate \cdot SInz, 1 \big))\)

Example:

>>> from hydpy import pub
>>> pub.timegrids = "2000-04-29", "2000-05-03", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(7)
>>> lnk(ACKER, LAUBW, LAUBW, LAUBW, LAUBW, MISCHW, NADELW)
>>> lai.laubw_apr = 4.0
>>> lai.laubw_mai = 7.0
>>> lai.mischw_apr = 6.0
>>> lai.mischw_mai = 8.0
>>> lai.nadelw = 11.0
>>> p1sirate(0.2)
>>> p2sirate(0.02)
>>> p3sirate(0.003)
>>> derived.moy.update()
>>> states.sinz = 500.0, 500.0, 50.0, 5.0, 0.0, 0.0, 0.0

>>> model.idx_sim = pub.timegrids.init["2000-04-30"]
>>> model.calc_snowintrate_v1()
>>> fluxes.snowintrate
snowintrate(0.0, 1.0, 0.43, 0.295, 0.28, 0.32, 0.42)

>>> model.idx_sim = pub.timegrids.init["2000-05-01"]
>>> model.calc_snowintrate_v1()
>>> fluxes.snowintrate
snowintrate(0.0, 1.0, 0.49, 0.355, 0.34, 0.36, 0.42)
class hydpy.models.lland.lland_model.Calc_NBesInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the total amount of stand precipitation reaching the snow interception storage.

Requires the control parameters:

NHRU Lnk

Requires the flux sequences:

NBes SnowIntMax SnowIntRate

Requires the state sequence:

SInz

Calculates the flux sequence:

NBesInz

Basic equation (does this comply with LARSIM?):

\(NBesInz = min \big( SnowIntRate \cdot NBes, max (SnowIntMax - SInz, 0) \big)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(6)
>>> lnk(ACKER, LAUBW, MISCHW, NADELW, NADELW, NADELW)
>>> states.sinz = 0.0, 0.0, 5.0, 10.0, 15.0, 20.0
>>> fluxes.nbes = 20.0
>>> fluxes.snowintmax = 15.0
>>> fluxes.snowintrate = 0.5
>>> model.calc_nbesinz_v1()
>>> fluxes.nbesinz
nbesinz(0.0, 10.0, 10.0, 5.0, 0.0, 0.0)
class hydpy.models.lland.lland_model.Calc_SBesInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the frozen amount of stand precipitation reaching the snow interception storage.

Requires the control parameters:

NHRU Lnk

Requires the flux sequence:

NBesInz

Requires the aide sequence:

SNRatio

Calculates the flux sequence:

SBesInz

Basic equations (does this comply with LARSIM?):

\(SBesInz = SNRatio \cdot NBesInz\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(4)
>>> lnk(ACKER, LAUBW, MISCHW, NADELW)
>>> fluxes.nbesinz = 10.0, 10.0, 5.0, 2.5
>>> aides.snratio = 0.8
>>> model.calc_sbesinz_v1()
>>> fluxes.sbesinz
sbesinz(0.0, 8.0, 4.0, 2.0)
class hydpy.models.lland.lland_model.Calc_STInz_V1[source]

Bases: hydpy.core.modeltools.Method

Add the relevant fraction of the frozen amount of stand precipitation to the frozen water equivalent of the interception snow storage.

Requires the control parameters:

NHRU Lnk

Requires the flux sequence:

SBesInz

Updates the state sequence:

STInz

Basic equation:

\(\frac{STInz}{dt} = SBesInz\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(4)
>>> lnk(ACKER, LAUBW, MISCHW, NADELW)
>>> states.stinz = 0.0, 1.0, 2.0, 3.0
>>> fluxes.sbesinz = 1.0
>>> model.calc_stinz_v1()
>>> states.stinz
stinz(0.0, 2.0, 3.0, 4.0)
class hydpy.models.lland.lland_model.Calc_WaDaInz_SInz_V1[source]

Bases: hydpy.core.modeltools.Method

Add as much liquid precipitation to the snow interception storage as it is able to hold.

Requires the control parameters:

NHRU Lnk PWMax

Requires the flux sequence:

NBesInz

Requires the state sequence:

STInz

Updates the state sequence:

SInz

Calculates the flux sequence:

WaDaInz

Basic equations:

\(\frac{dSInz}{dt} = NBesInz - WaDaInz\)

\(SInz \leq PWMax \cdot STInz\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(5)
>>> lnk(ACKER, LAUBW, MISCHW, NADELW, NADELW)
>>> pwmax(2.0)
>>> fluxes.nbesinz = 1.0
>>> states.stinz = 0.0, 0.0, 1.0, 1.0, 1.0
>>> states.sinz = 1.0, 0.0, 1.0, 1.5, 2.0
>>> model.calc_wadainz_sinz_v1()
>>> states.sinz
sinz(0.0, 0.0, 2.0, 2.0, 2.0)
>>> fluxes.wadainz
wadainz(0.0, 1.0, 0.0, 0.5, 1.0)
class hydpy.models.lland.lland_model.Calc_WNiedInz_ESnowInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the heat flux into the snow interception storage due to the amount of precipitation actually hold by the snow layer.

Requires the control parameters:

NHRU Lnk TRefN

Requires the fixed parameters:

CPWasser CPEis

Requires the flux sequences:

TKor NBesInz SBesInz WaDaInz

Updates the state sequence:

ESnowInz

Calculates the flux sequence:

WNiedInz

Basic equation:

\(\frac{dESnowInz}{dt} = W\!NiedInz\)

\(W\!NiedInz = (TKor-TRefN) \cdot (CPEis \cdot SBesInz + CPWasser \cdot (NBesInz - SBesInz - WaDaInz))\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(6)
>>> lnk(LAUBW, MISCHW, NADELW, NADELW, NADELW, ACKER)
>>> trefn(1.0)
>>> states.esnowinz = 0.02
>>> fluxes.tkor = 4.0, 0.0, 0.0, 0.0, 0.0, 0.0
>>> fluxes.nbesinz = 10.0
>>> fluxes.sbesinz = 0.0, 0.0, 5.0, 10.0, 5.0, 5.0
>>> fluxes.wadainz = 0.0, 0.0, 0.0, 0.0, 5.0, 5.0
>>> model.calc_wniedinz_esnowinz_v1()
>>> fluxes.wniedinz
wniedinz(0.125604, -0.041868, -0.031384, -0.0209, -0.01045, 0.0)
>>> states.esnowinz
esnowinz(0.145604, -0.021868, -0.011384, -0.0009, 0.00955, 0.0)
class hydpy.models.lland.lland_model.Return_TempSInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the average temperature of the intercepted snow.

Required by the methods:

Calc_TempSInz_V1 Return_BackwardEulerErrorInz_V1

Requires the fixed parameters:

CPWasser CPEis

Requires the state sequences:

STInz SInz ESnowInz

Basic equation:

\(max \left( \frac{ESnowInz}{STInz \cdot CPEis + (SInz - STInz) \cdot CPWasser}, -273 \right)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(5)
>>> states.stinz = 0.0, 0.5, 5.0, 0.5, 0.5
>>> states.sinz = 0.0, 1.0, 10.0, 1.0, 1.0
>>> states.esnowinz = 0.0, 0.0, -0.1, -0.8, -1.0
>>> from hydpy import round_
>>> round_(model.return_tempsinz_v1(0))
nan
>>> round_(model.return_tempsinz_v1(1))
0.0
>>> round_(model.return_tempsinz_v1(2))
-3.186337
>>> round_(model.return_tempsinz_v1(3))
-254.906959
>>> round_(model.return_tempsinz_v1(4))
-273.0
class hydpy.models.lland.lland_model.Calc_TempSInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the average temperature of the intercepted snow.

Required submethod:

Return_TempSInz_V1

Requires the control parameter:

NHRU

Requires the fixed parameters:

CPWasser CPEis

Requires the state sequences:

STInz SInz ESnowInz

Calculates the aide sequence:

TempSInz

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(6)
>>> lnk(ACKER, LAUBW, MISCHW, NADELW, NADELW, NADELW)
>>> pwmax(2.0)
>>> fluxes.tkor = -1.0
>>> states.stinz = 0.0, 0.5, 5.0, 5.0, 5.0, 5.0
>>> states.sinz = 0.0, 1.0, 10.0, 10.0, 10.0, 10.0
>>> states.esnowinz = 0.0, 0.0, -0.1, -0.1, -0.1, -0.1
>>> model.calc_tempsinz_v1()
>>> aides.tempsinz
tempsinz(nan, 0.0, -3.186337, -3.186337, -3.186337, -3.186337)
class hydpy.models.lland.lland_model.Update_ASInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the dimensionless age of the intercepted snow.

Requires the control parameter:

NHRU

Requires the derived parameter:

Seconds

Requires the flux sequence:

SBesInz

Requires the state sequence:

SInz

Requires the aide sequence:

TempSInz

Calculates the state sequence:

ASInz

Basic equations:

\(TauSInz_{new} = TauSInz_{old} \cdot max(1 - 0.1 \cdot SBesInz), 0) + \frac{r_1+r_2+r_3}{10^6} \cdot Seconds\)

\(r_1 = exp \left( 5000 \cdot \left( \frac{1}{273.15} - \frac{1}{273.15 + TempSInz} \right) \right)\)

\(r_2 = min \left(r_1^{10}, 1 \right)\)

\(r_3 = 0.03\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(10)
>>> derived.seconds(24*60*60)
>>> fluxes.sbesinz = 0.0, 1.0, 5.0, 9.0, 10.0, 11.0, 11.0, 11.0, 11.0, 11.0
>>> states.sinz = 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0
>>> states.asinz = 1.0, nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0
>>> aides.tempsinz = 0.0, 0.0, -10.0, -10.0, -10.0, -10.0, -1.0, 0.0, 1.0, 10.0
>>> model.update_asinz_v1()
>>> states.asinz
asinz(nan, 0.175392, 0.545768, 0.145768, 0.045768, 0.045768, 0.127468,
      0.175392, 0.181358, 0.253912)
class hydpy.models.lland.lland_model.Calc_ActualAlbedoInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the current albedo of the intercepted snow.

Requires the control parameters:

NHRU SnowAgingFactor Albedo0Snow

Requires the state sequences:

ASInz SInz

Calculates the flux sequence:

ActualAlbedoInz

Basic equation:

\(AlbedoSnowInz = Albedo0Snow \cdot \left( 1 - SnowAgingFactor \cdot \frac{ASInz}{1 + ASInz} \right)\)

Examples:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(5)
>>> albedo0snow(0.8)
>>> snowagingfactor(0.35)
>>> states.asinz = nan, nan, 0.0, 1.0, 3.0
>>> states.sinz = 0.0, 0.0, 1.0, 1.0, 1.0
>>> model.calc_actualalbedoinz_v1()
>>> fluxes.actualalbedoinz
actualalbedoinz(nan, nan, 0.8, 0.66, 0.59)
class hydpy.models.lland.lland_model.Calc_NetShortwaveRadiationInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the net shortwave radiation for the intercepted snow.

Requires the control parameters:

NHRU Lnk

Requires the derived parameters:

Fr MOY

Requires the flux sequences:

ActualAlbedoInz AdjustedGlobalRadiation

Calculates the flux sequence:

NetShortwaveRadiationInz

Basic equation:

\(NetShortwaveRadiationInz = (1 - Fr) \cdot (1.0 - ActualAlbedoInz) \\cdot AdjustedGlobalRadiation\)

Examples:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-30", "2000-02-03", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(2)
>>> lnk(ACKER, LAUBW)
>>> derived.fr.acker_jan = 1.0
>>> derived.fr.acker_feb = 1.0
>>> derived.fr.laubw_jan = 0.5
>>> derived.fr.laubw_feb = 0.1
>>> derived.moy.update()
>>> fluxes.actualalbedoinz = 0.5
>>> fluxes.adjustedglobalradiation = 2.0

>>> model.idx_sim = pub.timegrids.init["2000-01-31"]
>>> model.calc_netshortwaveradiationinz_v1()
>>> fluxes.netshortwaveradiationinz
netshortwaveradiationinz(0.0, 0.5)

>>> model.idx_sim = pub.timegrids.init["2000-02-01"]
>>> model.calc_netshortwaveradiationinz_v1()
>>> fluxes.netshortwaveradiationinz
netshortwaveradiationinz(0.0, 0.9)
class hydpy.models.lland.lland_model.Calc_SchmPotInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the potential melt of the intercepted snow according to its heat content.

Requires the control parameter:

NHRU

Requires the fixed parameter:

RSchmelz

Requires the state sequences:

ESnowInz SInz

Calculates the flux sequence:

SchmPotInz

Basic equation:

\(SchmPotInz = max \left( \frac{ESnowInz}{RSchmelz}, 0 \right)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(4)
>>> states.sinz = 0.0, 1.0, 1.0, 1.0
>>> states.esnowinz = nan, 5.0, 2.0, -2.0
>>> model.calc_schmpotinz_v1()
>>> fluxes.schmpotinz
schmpotinz(0.0, 14.97006, 5.988024, 0.0)
class hydpy.models.lland.lland_model.Calc_SchmInz_STInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the actual amount of snow melting within the snow interception storage.

Requires the control parameters:

NHRU Lnk

Requires the flux sequence:

SchmPotInz

Updates the state sequence:

STInz

Calculates the flux sequence:

SchmInz

Basic equations:

\(\frac{dSTInz}{dt} = -SchmInz\)

\[\begin{split}SchmInz = \begin{cases} SchmPotInz &|\ STInz> 0 \\ 0 &|\ STInz = 0 \end{cases}\end{split}\]

Examples:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(6)
>>> lnk(ACKER, LAUBW, MISCHW, NADELW, NADELW, NADELW)
>>> states.stinz = 0.0, 0.0, 2.0, 2.0, 2.0, 2.0
>>> fluxes.schmpotinz = 1.0, 1.0, 0.0, 1.0, 3.0, 5.0
>>> model.calc_schminz_stinz_v1()
>>> states.stinz
stinz(0.0, 0.0, 2.0, 1.0, 0.0, 0.0)
>>> fluxes.schminz
schminz(0.0, 0.0, 0.0, 1.0, 2.0, 2.0)
class hydpy.models.lland.lland_model.Calc_GefrPotInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the potential refreezing within the snow interception storage according to its thermal energy.

Requires the control parameter:

NHRU

Requires the fixed parameter:

RSchmelz

Requires the state sequences:

ESnowInz SInz

Calculates the flux sequence:

GefrPotInz

Basic equation:

\(GefrPotInz = max \left( -\frac{ESnowInz}{RSchmelz}, 0 \right)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(4)
>>> states.sinz = 0.0, 1.0, 1.0, 1.0
>>> states.esnowinz = nan, -5.0, -2.0, 2.0
>>> model.calc_gefrpotinz_v1()
>>> fluxes.gefrpotinz
gefrpotinz(0.0, 14.97006, 5.988024, 0.0)
class hydpy.models.lland.lland_model.Calc_GefrInz_STInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the actual amount of snow melting within the snow interception storage.

Requires the control parameters:

NHRU Lnk RefreezeFlag

Requires the flux sequence:

GefrPotInz

Requires the state sequence:

SInz

Updates the state sequence:

STInz

Calculates the flux sequence:

GefrInz

Basic equations:

\(\frac{dGefrInz}{dt} = -GefrInz\)

\[\begin{split}GefrInz = \begin{cases} GefrPotInz &|\ SInz - STInz > 0 \\ 0 &|\ SInz - STInz = 0 \end{cases}\end{split}\]

Examples:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(6)
>>> lnk(ACKER, LAUBW, LAUBW, LAUBW, MISCHW, NADELW)
>>> refreezeflag(True)
>>> states.stinz = 0.0, 0.0, 2.0, 2.0, 2.0, 2.0
>>> states.sinz = 0.0, 0.0, 4.0, 4.0, 4.0, 4.0
>>> fluxes.gefrpotinz = 1.0, 1.0, 0.0, 1.0, 3.0, 5.0
>>> model.calc_gefrinz_stinz_v1()
>>> states.stinz
stinz(0.0, 0.0, 2.0, 3.0, 4.0, 4.0)
>>> fluxes.gefrinz
gefrinz(0.0, 0.0, 0.0, 1.0, 2.0, 2.0)

>>> refreezeflag(False)
>>> model.calc_gefrinz_stinz_v1()
>>> states.stinz
stinz(0.0, 0.0, 2.0, 3.0, 4.0, 4.0)
>>> fluxes.gefrinz
gefrinz(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
class hydpy.models.lland.lland_model.Calc_EvSInz_SInz_STInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the evaporation from the snow interception storage, if any exists, and its content accordingly.

Requires the control parameters:

NHRU Lnk

Requires the fixed parameter:

LWE

Requires the flux sequence:

WLatInz

Updates the state sequences:

SInz STInz

Calculates the flux sequence:

EvSInz

Basic equations:

\(SInz_{new} = f \cdot SInz_{old}\)

\(STInz_{new} = f \cdot STInz_{old}\)

\(f = \frac{SInz-EvS}{SInz}\)

\(EvSInz = max \left( \frac{WLatSnow}{L}, SInz \right)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(8)
>>> lnk(LAUBW, MISCHW, NADELW, NADELW, NADELW, NADELW, NADELW, ACKER)
>>> fluxes.wlatinz = -1.0, 0.0, 2.0, 4.0, 6.0, 6.0, 6.0, 6.0
>>> states.sinz = 2.0, 2.0, 2.0, 2.0, 2.0, 1.5, 0.0, 2.0
>>> states.stinz = 1.0, 1.0, 1.0, 1.0, 1.0, 0.5, 0.0, 1.0
>>> model.calc_evsinz_sinz_stinz_v1()
>>> fluxes.evsinz
evsinz(-0.37489, 0.0, 0.74978, 1.49956, 2.0, 1.5, 0.0, 0.0)
>>> states.sinz
sinz(2.37489, 2.0, 1.25022, 0.50044, 0.0, 0.0, 0.0, 0.0)
>>> states.stinz
stinz(1.187445, 1.0, 0.62511, 0.25022, 0.0, 0.0, 0.0, 0.0)
class hydpy.models.lland.lland_model.Update_WaDaInz_SInz_V1[source]

Bases: hydpy.core.modeltools.Method

Update the actual water release from and the liquid water content of the snow interception storage due to melting.

Requires the control parameters:

NHRU Lnk PWMax

Requires the state sequence:

STInz

Updates the flux sequence:

WaDaInz

Updates the state sequence:

SInz

Basic equations:

\(WaDaInz_{new} = WaDaInz_{old} + \Delta\)

\(SInz_{new} = SInz_{old} - \Delta\)

\(\Delta = max(SInz - PWMax \cdot STInz, 0)\)

Examples:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(5)
>>> lnk(ACKER, LAUBW, LAUBW, MISCHW, NADELW)
>>> pwmax(2.0)
>>> states.stinz = 0.0, 0.0, 1.0, 1.0, 1.0
>>> states.sinz = 1.0, 0.0, 1.0, 2.0, 3.0
>>> fluxes.wadainz = 1.0
>>> model.update_wadainz_sinz_v1()
>>> states.sinz
sinz(1.0, 0.0, 1.0, 2.0, 2.0)
>>> fluxes.wadainz
wadainz(1.0, 1.0, 1.0, 1.0, 2.0)
class hydpy.models.lland.lland_model.Update_ESnowInz_V2[source]

Bases: hydpy.core.modeltools.Method

Update the thermal energy content of the intercepted snow regarding snow melt and refreezing.

Requires the control parameters:

NHRU Lnk

Requires the fixed parameter:

RSchmelz

Requires the flux sequences:

GefrInz SchmInz

Requires the state sequence:

SInz

Updates the state sequence:

ESnowInz

Basic equation:

\(\frac{dESnowInz}{dt} = RSchmelz \cdot (GefrInz - SchmInz)\)

Examples:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(5)
>>> lnk(ACKER, NADELW, NADELW, NADELW, NADELW)
>>> fluxes.gefrinz = 0.0, 0.0, 4.0, 0.0, 4.0
>>> fluxes.schminz = 0.0, 0.0, 0.0, 4.0, 4.0
>>> states.esnowinz = 1.0, 1.0, -1.5, 1.336, 0.0
>>> states.sinz = 1.0, 0.0, 5.0, 5.0, 10.0
>>> model.update_esnowinz_v2()
>>> states.esnowinz
esnowinz(0.0, 0.0, -0.164, 0.0, 0.0)
class hydpy.models.lland.lland_model.Calc_WATS_V1[source]

Bases: hydpy.core.modeltools.Method

Add the snow fall to the frozen water equivalent of the snow cover.

Requires the control parameters:

NHRU Lnk

Requires the flux sequence:

SBes

Updates the state sequence:

WATS

Basic equation:

\(\frac{dW\!ATS}{dt} = SBes\)

Example:

On water surfaces, method Calc_WATS_V1 never builds up a snow layer:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(4)
>>> lnk(WASSER, FLUSS, SEE, ACKER)
>>> fluxes.sbes = 2.0
>>> states.wats = 5.5
>>> model.calc_wats_v1()
>>> states.wats
wats(0.0, 0.0, 0.0, 7.5)
class hydpy.models.lland.lland_model.Calc_WATS_V2[source]

Bases: hydpy.core.modeltools.Method

Add the not intercepted snow fall to the frozen water equivalent of the snow cover.

Requires the control parameters:

NHRU Lnk

Requires the flux sequences:

SBes SBesInz

Updates the state sequence:

WATS

Basic equation:

\(\frac{dW\!\!ATS}{dt} = SBes - SBesInz\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> lnk(WASSER, ACKER, LAUBW)
>>> states.wats = 0.0, 1.0, 2.0
>>> fluxes.sbes = 2.0
>>> fluxes.sbesinz = 1.0
>>> model.calc_wats_v2()
>>> states.wats
wats(0.0, 3.0, 3.0)
class hydpy.models.lland.lland_model.Calc_WaDa_WAeS_V1[source]

Bases: hydpy.core.modeltools.Method

Add as much liquid precipitation to the snow cover as it is able to hold.

Requires the control parameters:

NHRU Lnk PWMax

Requires the flux sequence:

NBes

Requires the state sequence:

WATS

Updates the state sequence:

WAeS

Calculates the flux sequence:

WaDa

Basic equations:

\(\frac{dW\!AeS}{dt} = NBes - WaDa\)

\(W\!AeS \leq PWMax \cdot W\!ATS\)

Example:

For simplicity, we set the threshold parameter PWMax to a value of two for each of the six initialised hydrological response units. Thus, the snow layer can hold as much liquid water as it contains frozen water. Stand precipitation is also always set to the same value, but we vary the initial conditions of the snow cover:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(6)
>>> lnk(FLUSS, SEE, ACKER, ACKER, ACKER, ACKER)
>>> pwmax(2.0)
>>> fluxes.nbes = 1.0
>>> states.wats = 0.0, 0.0, 0.0, 1.0, 1.0, 1.0
>>> states.waes = 1.0, 1.0, 0.0, 1.0, 1.5, 2.0
>>> model.calc_wada_waes_v1()
>>> states.waes
waes(0.0, 0.0, 0.0, 2.0, 2.0, 2.0)
>>> fluxes.wada
wada(1.0, 1.0, 1.0, 0.0, 0.5, 1.0)

Note the special cases of the first two response units of type FLUSS and SEE. For water areas, stand precipitaton NBes is generally passed to WaDa and WAeS is set to zero. For all other land use classes (of which only ACKER is selected), method Calc_WaDa_WAeS_V1 only passes the part of NBes exceeding the actual snow holding capacity to WaDa.

class hydpy.models.lland.lland_model.Calc_WaDa_WAeS_V2[source]

Bases: hydpy.core.modeltools.Method

Add as much liquid precipitation and interception melt to the snow cover as it is able to hold.

Requires the control parameters:

NHRU Lnk PWMax

Requires the flux sequences:

NBes NBesInz WaDaInz

Requires the state sequence:

WATS

Updates the state sequence:

WAeS

Calculates the flux sequence:

WaDa

Basic equations:

\(\frac{dW\!\!AeS}{dt} = NBes - NBesInz + WaDaInz - WaDa\)

\(W\!\!AeS \leq PWMax \cdot W\!\!AT\!S\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(10)
>>> lnk(FLUSS, SEE, ACKER, ACKER, ACKER, ACKER, LAUBW, LAUBW, LAUBW, LAUBW)
>>> pwmax(2.0)
>>> fluxes.nbes = 1.5
>>> fluxes.nbesinz = 1.0
>>> fluxes.wadainz = 0.5
>>> states.wats = 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0
>>> states.waes = 1.0, 1.0, 0.0, 1.0, 1.5, 2.0, 0.0, 1.0, 1.5, 2.0
>>> model.calc_wada_waes_v2()
>>> states.waes
waes(0.0, 0.0, 0.0, 2.0, 2.0, 2.0, 0.0, 2.0, 2.0, 2.0)
>>> fluxes.wada
wada(1.0, 1.0, 1.0, 0.0, 0.5, 1.0, 1.5, 0.5, 1.0, 1.5)
class hydpy.models.lland.lland_model.Calc_WGTF_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the heat flux according to the degree-day method [4].

Requires the control parameters:

NHRU Lnk GTF TRefT

Requires the fixed parameter:

RSchmelz

Requires the flux sequence:

TKor

Calculates the flux sequence:

WGTF

Basic equation:

\(WGTF = GTF \cdot (TKor - TRefT) \cdot RSchmelz\)

Examples:

Initialise six hydrological response units with identical degree-day factors and temperature thresholds, but different combinations of land use and air temperature:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> simulationstep("12h")
>>> nhru(6)
>>> lnk(FLUSS, SEE, LAUBW, ACKER, ACKER, LAUBW)
>>> gtf(5.0)
>>> treft(0.0)
>>> trefn(1.0)
>>> fluxes.tkor = 1.0, 1.0, 1.0, 1.0, 0.0, -1.0

Note that the values of the degree-day factor are only half as much as the given value, due to the simulation step size being only half as long as the parameter step size:

>>> gtf
gtf(5.0)
>>> from hydpy import print_values
>>> print_values(gtf.values)
2.5, 2.5, 2.5, 2.5, 2.5, 2.5

The results of the first four hydrological response units show that WGTF is generally zero for water areas (here, FLUSS and SEE) in principally identical for all other landuse-use type (here, ACKER and LAUBW). The results of the last three response units show the expectable linear relationship. However, note that that WGTF is allowed to be negative:

>>> model.calc_wgtf_v1()
>>> fluxes.wgtf
wgtf(0.0, 0.0, 0.835, 0.835, 0.0, -0.835)
class hydpy.models.lland.lland_model.Calc_WNied_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the heat flux into the snow layer due to the total amount of ingoing precipitation ([4], modified).

Requires the control parameters:

NHRU Lnk TRefN

Requires the fixed parameters:

CPWasser CPEis

Requires the flux sequences:

TKor NBes SBes

Calculates the flux sequence:

WNied

Method Calc_WNied_V1 assumes that the temperature of precipitation equals air temperature minus TRefN.

Basic equation:

\(WNied = (TKor - TRefN) \cdot (CPEis \cdot SBes + CPWasser \cdot (NBes - SBes))\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(5)
>>> lnk(ACKER, ACKER, ACKER, ACKER, WASSER)
>>> trefn(-2.0, 2.0, 2.0, 2.0, 2.0)
>>> fluxes.tkor(1.0)
>>> fluxes.nbes = 10.0
>>> fluxes.sbes = 0.0, 0.0, 5.0, 10.0, 10.0
>>> model.calc_wnied_v1()
>>> fluxes.wnied
wnied(0.125604, -0.041868, -0.031384, -0.0209, 0.0)
class hydpy.models.lland.lland_model.Calc_WNied_ESnow_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the heat flux into the snow layer due to the amount of precipitation actually hold by the snow layer.

Requires the control parameters:

NHRU Lnk TRefN

Requires the fixed parameters:

CPWasser CPEis

Requires the flux sequences:

TKor NBes SBes WaDa

Updates the state sequence:

ESnow

Calculates the flux sequence:

WNied

Method Calc_WNied_V1 assumes that the temperature of precipitation equals air temperature minus TRefN. The same holds for the temperature of the fraction of precipitation not hold by the snow layer (in other words: no temperature mixing occurs).

Basic equation:

\(\frac{dESnow}{dt} = WNied\)

\(WNied = (TKor-TRefN) \cdot (CPEis \cdot SBes + CPWasser \cdot (NBes - SBes - WaDa))\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(6)
>>> lnk(ACKER, ACKER, ACKER, ACKER, ACKER, WASSER)
>>> trefn(1.0)
>>> states.esnow = 0.02
>>> fluxes.tkor = 4.0, 0.0, 0.0, 0.0, 0.0, 0.0
>>> fluxes.nbes = 10.0
>>> fluxes.sbes = 0.0, 0.0, 5.0, 10.0, 5.0, 5.0
>>> fluxes.wada = 0.0, 0.0, 0.0, 0.0, 5.0, 5.0
>>> model.calc_wnied_esnow_v1()
>>> fluxes.wnied
wnied(0.125604, -0.041868, -0.031384, -0.0209, -0.01045, 0.0)
>>> states.esnow
esnow(0.145604, -0.021868, -0.011384, -0.0009, 0.00955, 0.0)
class hydpy.models.lland.lland_model.Return_SaturationVapourPressure_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the saturation vapour pressure over an arbitrary surface for the given temperature [4] (based on [13]).

Required by the methods:

Calc_DailySaturationVapourPressure_V1 Calc_SaturationVapourPressure_V1 Return_BackwardEulerErrorInz_V1 Return_EnergyGainSnowSurface_V1 Return_WSurfInz_V1

Basic equation:

\(0.61078 \cdot 2.71828^{\frac{17.08085 \cdot temperature}{temperature + 234.175}}\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> from hydpy import round_
>>> round_(model.return_saturationvapourpressure_v1(10.0))
1.229385
class hydpy.models.lland.lland_model.Return_SaturationVapourPressureSlope_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the saturation vapour pressure slope over an arbitrary surface for the given temperature.

Required by the methods:

Calc_DailySaturationVapourPressureSlope_V1 Calc_SaturationVapourPressureSlope_V1

Basic equation (derivative of Return_SaturationVapourPressure_V1:

\(\frac{2443.06 \cdot exp((17.08085 \cdot temperature) / (temperature + 234.175)} {(temperature+234.175)^2}\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> from hydpy import round_
>>> round_(model.return_saturationvapourpressureslope_v1(10.0))
0.082477
>>> dx = 1e-6
>>> round_((model.return_saturationvapourpressure_v1(10.0+dx) -
...         model.return_saturationvapourpressure_v1(10.0-dx))/2/dx)
0.082477
class hydpy.models.lland.lland_model.Calc_SaturationVapourPressure_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the saturation vapour pressure over arbitrary surfaces.

Required submethod:

Return_SaturationVapourPressure_V1

Requires the control parameter:

NHRU

Requires the flux sequence:

TKor

Calculates the flux sequence:

SaturationVapourPressure

Basic equation:

\(SaturationVapourPressure = Return\_SaturationVapourPressure\_V1(TKor)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> fluxes.tkor = -10.0, 0.0, 10.0
>>> model.calc_saturationvapourpressure_v1()
>>> fluxes.saturationvapourpressure
saturationvapourpressure(0.285087, 0.61078, 1.229385)
class hydpy.models.lland.lland_model.Calc_DailySaturationVapourPressure_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the daily saturation vapour pressure over arbitrary surfaces.

Required submethod:

Return_SaturationVapourPressure_V1

Requires the control parameter:

NHRU

Requires the flux sequence:

TKorTag

Calculates the flux sequence:

DailySaturationVapourPressure

Basic equation:

\(DailySaturationVapourPressure = Return\_SaturationVapourPressure\_V1(TKorTag)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> fluxes.tkortag = -10.0, 0.0, 10.0
>>> model.calc_dailysaturationvapourpressure_v1()
>>> fluxes.dailysaturationvapourpressure
dailysaturationvapourpressure(0.285087, 0.61078, 1.229385)
class hydpy.models.lland.lland_model.Calc_SaturationVapourPressureSlope_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the daily slope of the saturation vapour pressure curve.

Required submethod:

Return_SaturationVapourPressureSlope_V1

Requires the control parameter:

NHRU

Requires the flux sequence:

TKor

Calculates the flux sequence:

SaturationVapourPressureSlope

Basic equation:

\(SaturationVapourPressureSlope = Return\_SaturationVapourPressureSlope\_V1(TKor)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> fluxes.tkor = -10.0, 0.0, 10.0
>>> fluxes.saturationvapourpressure = 0.285096, 0.6108, 1.229426
>>> model.calc_saturationvapourpressureslope_v1()
>>> fluxes.saturationvapourpressureslope
saturationvapourpressureslope(0.022691, 0.044551, 0.082477)
class hydpy.models.lland.lland_model.Calc_DailySaturationVapourPressureSlope_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the daily slope of the saturation vapour pressure curve.

Required submethod:

Return_SaturationVapourPressureSlope_V1

Requires the control parameter:

NHRU

Requires the flux sequence:

TKorTag

Calculates the flux sequence:

DailySaturationVapourPressureSlope

Basic equation:

\(DailySaturationVapourPressureSlope = Return\_SaturationVapourPressureSlope\_V1(TKorTag)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> fluxes.tkortag = 10.0, 0.0, -10.0
>>> model.calc_dailysaturationvapourpressureslope_v1()
>>> fluxes.dailysaturationvapourpressureslope
dailysaturationvapourpressureslope(0.082477, 0.044551, 0.022691)
class hydpy.models.lland.lland_model.Return_ActualVapourPressure_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the actual vapour pressure for the given saturation vapour pressure and relative humidity. [4] (based on ref-Weischet1983)

Required by the methods:

Calc_ActualVapourPressure_V1 Calc_DailyActualVapourPressure_V1

Basic equation:

\(saturationvapourpressure \cdot relativehumidity / 100\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> from hydpy import round_
>>> round_(model.return_actualvapourpressure_v1(2.0, 60.0))
1.2
class hydpy.models.lland.lland_model.Calc_ActualVapourPressure_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the actual vapour pressure.

Required submethod:

Return_ActualVapourPressure_V1

Requires the control parameter:

NHRU

Requires the input sequence:

RelativeHumidity

Requires the flux sequence:

SaturationVapourPressure

Calculates the flux sequence:

ActualVapourPressure

Basic equation:

\(ActualVapourPressure = Return\_ActualVapourPressure\_V1( SaturationVapourPressure, RelativeHumidity)\)

Example:

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep()
>>> nhru(1)
>>> derived.nmblogentries.update()
>>> inputs.relativehumidity = 60.0
>>> fluxes.saturationvapourpressure = 2.0
>>> model.calc_actualvapourpressure_v1()
>>> fluxes.actualvapourpressure
actualvapourpressure(1.2)
class hydpy.models.lland.lland_model.Calc_DailyActualVapourPressure_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the daily actual vapour pressure.

Required submethod:

Return_ActualVapourPressure_V1

Requires the control parameter:

NHRU

Requires the flux sequences:

DailyRelativeHumidity DailySaturationVapourPressure

Calculates the flux sequence:

DailyActualVapourPressure

Basic equation:

\(DailyActualVapourPressure = Return\_ActualVapourPressure\_V1( DailySaturationVapourPressure, DailyRelativeHumidity)\)

Example:

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep()
>>> nhru(1)
>>> derived.nmblogentries.update()
>>> fluxes.dailyrelativehumidity = 40.0
>>> fluxes.dailysaturationvapourpressure = 4.0
>>> model.calc_dailyactualvapourpressure_v1()
>>> fluxes.dailyactualvapourpressure
dailyactualvapourpressure(1.6)
class hydpy.models.lland.lland_model.Calc_DailyNetLongwaveRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the daily net longwave radiation.

Requires the control parameters:

NHRU Emissivity

Requires the fixed parameters:

Sigma FrAtm

Requires the flux sequences:

TKorTag DailyActualVapourPressure DailySunshineDuration DailyPossibleSunshineDuration

Calculates the flux sequence:

DailyNetLongwaveRadiation

Basic equation above a snow-free surface:

\(DailyNetLongwaveRadiation = Sigma \cdot (TKorTag + 273.15)^4 \cdot \left(Emissivity - FrAtm \cdot \left(\frac{DailyActualVapourPressure \cdot 10} {TKorTag + 273.15}\right)^{1/7}\right) \cdot \left(0.2 + 0.8 \cdot \frac{DailySunshineDuration}{DailyPossibleSunshineDuration}\right)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(2)
>>> emissivity(0.95)
>>> fluxes.tkortag = 22.1, 0.0
>>> fluxes.dailyactualvapourpressure = 1.6, 0.6
>>> fluxes.dailysunshineduration = 12.0
>>> fluxes.dailypossiblesunshineduration = 14.0
>>> model.calc_dailynetlongwaveradiation_v1()
>>> fluxes.dailynetlongwaveradiation
dailynetlongwaveradiation(3.495045, 5.027685)
class hydpy.models.lland.lland_model.Calc_RLAtm_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the longwave radiation emitted from the atmosphere

[7].

Requires the control parameter:

NHRU

Requires the derived parameter:

Days

Requires the fixed parameters:

Sigma FrAtm

Requires the flux sequences:

TKor ActualVapourPressure DailySunshineDuration DailyPossibleSunshineDuration

Calculates the aide sequence:

RLAtm

Basic equation (see [4], equation 3.40):

\(RLAtm = FrAtm \cdot Sigma \cdot (Tkor + 273.15)^4 \cdot \left( \frac{ActualVapourPressure \cdot 10}{TKor + 273.15} \right) ^{1/7} \cdot \left(1 + 0.22 \cdot \left( 1 - \frac{DailySunshineDuration}{DailyPossibleSunshineDuration} \right)^2 \right)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(2)
>>> derived.days(1/24)
>>> emissivity(0.95)
>>> fluxes.tkor = 0.0, 10.0
>>> fluxes.actualvapourpressure = 0.6
>>> fluxes.dailysunshineduration = 12.0
>>> fluxes.dailypossiblesunshineduration = 14.0
>>> model.calc_rlatm_v1()
>>> aides.rlatm
rlatm(0.846746, 0.972711)
class hydpy.models.lland.lland_model.Return_NetLongwaveRadiationInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the net longwave radiation for intercepted snow.

Required by the methods:

Return_BackwardEulerErrorInz_V1 Return_WSurfInz_V1

Requires the control parameter:

Lnk

Requires the derived parameters:

MOY Days Fr

Requires the fixed parameter:

Sigma

Requires the aide sequences:

TempSInz RLAtm

The following equation is not part of the official LARSIM documentation. We think, it fits to the geometric assumtions underlying method Return_NetLongwaveRadiationSnow_V1 but so far have not thoroughly checked if it results in realistic net longwave radiations.

Basic equation:

\(\big( 1 - Fr \big) \cdot \big( 0.97 \cdot Sigma \cdot (TempS + 273.15)^4 - RLAtm \big)\)

Examples:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-30", "2000-02-03", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(2)
>>> lnk(LAUBW, NADELW)
>>> derived.moy.update()
>>> derived.days(1/24)
>>> derived.fr.laubw_jan = 0.4
>>> derived.fr.laubw_feb = 0.5
>>> derived.fr.nadelw_jan = 0.6
>>> derived.fr.nadelw_feb = 0.7
>>> aides.tempsinz = -1.0
>>> aides.rlatm = 0.846746

>>> model.idx_sim = pub.timegrids.init["2000-01-31"]
>>> from hydpy import print_values
>>> for hru in range(2):
...     print_values(
...         [hru, model.return_netlongwaveradiationinz_v1(hru)])
0, 0.163799
1, 0.109199

>>> model.idx_sim = pub.timegrids.init["2000-02-01"]
>>> from hydpy import print_values
>>> for hru in range(2):
...     print_values(
...         [hru, model.return_netlongwaveradiationinz_v1(hru)])
0, 0.136499
1, 0.0819
class hydpy.models.lland.lland_model.Return_NetLongwaveRadiationSnow_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the net longwave radiation for snow-covered areas.

Required by the method:

Return_EnergyGainSnowSurface_V1

Requires the control parameter:

Lnk

Requires the derived parameters:

Days MOY Fr

Requires the fixed parameter:

Sigma

Requires the flux sequences:

TempSSurface TKor

Requires the aide sequence:

RLAtm

Method Return_NetLongwaveRadiationSnow_V1 differentiates between forests (LAUBW, MISCHW, and NADELW) and open areas. The outgoing longwave radiation always depends on the snow surface temperature. For open areas, the ingoing counter radiation stems from the atmosphere only. This atmospheric radiation is partly replaced by the longwave radiation emitted by the tree canopies for forests. The lower the value of parameter Fr, the higher this shading effect of the canopies. See [4] and:cite:ref-Thompson1981 for further information.

Basic equation:

\[\begin{split}Sigma \cdot (TempSSurface + 273.15)^4 - \begin{cases} Fr \cdot RLAtm + \big( 1 - Fr \big) \cdot \big( 0.97 \cdot Sigma \cdot (TKor + 273.15)^4 \big) &|\ Lnk \in \{LAUBW, MISCHW, NADELW\} \\ RLAtm &|\ Lnk \notin \{LAUBW, MISCHW, NADELW\} \end{cases}\end{split}\]

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(2)
>>> lnk(ACKER, LAUBW)
>>> derived.moy(5)
>>> derived.days(1/24)
>>> derived.fr(0.3)
>>> fluxes.tempssurface = -5.0
>>> fluxes.tkor = 0.0
>>> aides.rlatm = 0.846746
>>> from hydpy import print_values
>>> for hru in range(2):
...     print_values(
...         [hru, model.return_netlongwaveradiationsnow_v1(hru)])
0, 0.208605
1, 0.029784
class hydpy.models.lland.lland_model.Update_TauS_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the dimensionless age of the snow layer [4] (based on [9]).

Requires the control parameter:

NHRU

Requires the derived parameter:

Seconds

Requires the flux sequence:

SBes

Requires the state sequence:

WAeS

Requires the aide sequence:

TempS

Calculates the state sequence:

TauS

Basic equations:

\(TauS_{new} = TauS_{old} \cdot max(1 - 0.1 \cdot SBes), 0) + \frac{r_1+r_2+r_3}{10^6} \cdot Seconds\)

\(r_1 = exp\left(5000 \cdot \left(\frac{1}{273.15} - \frac{1}{273.15+TempS}\right)\right)\)

\(r_2 = min\left(r_1^{10}, 1\right)\)

\(r_3 = 0.03\)

Example:

For snow-free surfaces, TauS is not defined; snowfall rejuvenates an existing snow layer; high temperatures increase the speed of aging:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(10)
>>> derived.seconds(24*60*60)
>>> fluxes.sbes = 0.0, 1.0, 5.0, 9.0, 10.0, 11.0, 11.0, 11.0, 11.0, 11.0
>>> states.waes = 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0
>>> states.taus = 1.0, nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0
>>> aides.temps = (
...     0.0, 0.0, -10.0, -10.0, -10.0, -10.0, -1.0, 0.0, 1.0, 10.0)
>>> model.update_taus()
>>> states.taus
taus(nan, 0.175392, 0.545768, 0.145768, 0.045768, 0.045768, 0.127468,
     0.175392, 0.181358, 0.253912)

Note that an initial nan value serves as an indication that there has been no snow-layer in the last simulation step, meaning the snow is fresh and starts with an age of zero (see the first two hydrological response units).

class hydpy.models.lland.lland_model.Calc_ActualAlbedo_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the current albedo value [4] (based on [9]).

Requires the control parameters:

NHRU Lnk SnowAgingFactor Albedo0Snow Albedo

Requires the derived parameter:

MOY

Requires the state sequences:

TauS WAeS

Calculates the flux sequence:

ActualAlbedo

For snow-free surfaces, method Calc_ActualAlbedo_V1 takes the value of parameter Albedo relevant for the given landuse and month. For snow conditions, it estimates the albedo based on the snow age, as shown by the following equation.

Basic equation:

\(AlbedoSnow = Albedo0Snow \cdot \left(1-SnowAgingFactor \cdot \frac{TauS}{1 + TauS}\right)\)

Examples:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-30", "2000-02-03", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(5)
>>> lnk(ACKER, VERS, VERS, VERS, VERS)
>>> albedo0snow(0.8)
>>> snowagingfactor(0.35)
>>> albedo.acker_jan = 0.2
>>> albedo.vers_jan = 0.3
>>> albedo.acker_feb = 0.4
>>> albedo.vers_feb = 0.5
>>> derived.moy.update()
>>> states.taus = nan, nan, 0.0, 1.0, 3.0
>>> states.waes = 0.0, 0.0, 1.0, 1.0, 1.0
>>> model.idx_sim = 1
>>> model.calc_actualalbedo_v1()
>>> fluxes.actualalbedo
actualalbedo(0.2, 0.3, 0.8, 0.66, 0.59)
>>> model.idx_sim = 2
>>> model.calc_actualalbedo_v1()
>>> fluxes.actualalbedo
actualalbedo(0.4, 0.5, 0.8, 0.66, 0.59)
class hydpy.models.lland.lland_model.Calc_NetShortwaveRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the net shortwave radiation.

Requires the control parameter:

NHRU

Requires the flux sequences:

ActualAlbedo AdjustedGlobalRadiation

Calculates the flux sequence:

NetShortwaveRadiation

Basic equation:

\(NetShortwaveRadiation = (1.0 - ActualAlbedo) \cdot AdjustedGlobalRadiation\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(1)
>>> fluxes.actualalbedo = 0.25
>>> fluxes.adjustedglobalradiation = 1.0
>>> model.calc_netshortwaveradiation_v1()
>>> fluxes.netshortwaveradiation
netshortwaveradiation(0.75)
class hydpy.models.lland.lland_model.Calc_NetShortwaveRadiationSnow_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the net shortwave radiation for snow-surfaces.

Requires the control parameters:

NHRU Lnk

Requires the derived parameters:

MOY Fr

Requires the flux sequences:

ActualAlbedo AdjustedGlobalRadiation

Calculates the flux sequence:

NetShortwaveRadiationSnow

Basic equation:

\(NetShortwaveRadiationSnow = Fr \cdot (1.0 - ActualAlbedo) \cdot AdjustedGlobalRadiation\)

Examples:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-30", "2000-02-03", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(2)
>>> lnk(ACKER, LAUBW)
>>> derived.fr.acker_jan = 1.0
>>> derived.fr.acker_feb = 1.0
>>> derived.fr.laubw_jan = 0.5
>>> derived.fr.laubw_feb = 0.1
>>> derived.moy.update()
>>> fluxes.actualalbedo = 0.5
>>> fluxes.adjustedglobalradiation = 2.0

>>> model.idx_sim = pub.timegrids.init["2000-01-31"]
>>> model.calc_netshortwaveradiationsnow_v1()
>>> fluxes.netshortwaveradiationsnow
netshortwaveradiationsnow(1.0, 0.5)

>>> model.idx_sim = pub.timegrids.init["2000-02-01"]
>>> model.calc_netshortwaveradiationsnow_v1()
>>> fluxes.netshortwaveradiationsnow
netshortwaveradiationsnow(1.0, 0.1)
class hydpy.models.lland.lland_model.Calc_DailyNetShortwaveRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the daily net shortwave radiation.

Requires the control parameter:

NHRU

Requires the flux sequences:

DailyGlobalRadiation ActualAlbedo

Calculates the flux sequence:

DailyNetShortwaveRadiation

Basic equation:

\(DailyNetShortwaveRadiation = (1.0 - ActualAlbedo) \cdot DailyGlobalRadiation\)

Example:

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep()
>>> nhru(1)
>>> fluxes.actualalbedo(0.25)
>>> fluxes.dailyglobalradiation = 1.0
>>> model.calc_dailynetshortwaveradiation_v1()
>>> fluxes.dailynetshortwaveradiation
dailynetshortwaveradiation(0.75)
class hydpy.models.lland.lland_model.Return_TempS_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the average temperature of the snow layer [4].

Required by the methods:

Calc_TempS_V1 Return_BackwardEulerError_V1

Requires the fixed parameters:

CPWasser CPEis

Requires the state sequences:

WATS WAeS ESnow

Basic equation:

\(max\left( \frac{ESnow}{WATS \cdot CPEis + (WAeS-WATS) \cdot CPWasser}, -273\right)\)

Example:

Note that we use nan values for snow-free surfaces (see the result of the first hydrological response unit) and that method Return_TempS_V1 never returns temperature values lower than -273 °C (see the result of the fifth response unit):

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(5)
>>> states.wats = 0.0, 0.5, 5.0, 0.5, 0.5
>>> states.waes = 0.0, 1.0, 10.0, 1.0, 1.0
>>> states.esnow = 0.0, 0.0, -0.1, -0.8, -1.0
>>> from hydpy import round_
>>> round_(model.return_temps_v1(0))
nan
>>> round_(model.return_temps_v1(1))
0.0
>>> round_(model.return_temps_v1(2))
-3.186337
>>> round_(model.return_temps_v1(3))
-254.906959
>>> round_(model.return_temps_v1(4))
-273.0
class hydpy.models.lland.lland_model.Return_ESnowInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the thermal energy content of the intercepted snow for its given bulk temperature.

Required by the method:

Update_ESnowInz_V1

Requires the fixed parameters:

CPWasser CPEis

Requires the state sequences:

STInz SInz

Basic equation:

\(temps \cdot \big( STInz \cdot CPEis + (SInz - STInz) \cdot CPWasser \big)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(3)
>>> states.stinz = 0.0, 0.5, 5.0
>>> states.sinz = 0.0, 1.0, 10.0
>>> states.esnowinz = 0.0, 0.0, -0.1
>>> from hydpy import round_
>>> round_(model.return_esnowinz_v1(0, 1.0))
0.0
>>> round_(model.return_esnowinz_v1(1, 0.0))
0.0
>>> round_(model.return_esnowinz_v1(2, -3.186337))
-0.1
class hydpy.models.lland.lland_model.Return_ESnow_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the thermal energy content of the snow layer for the given bulk temperature [4].

Required by the method:

Update_ESnow_V1

Requires the fixed parameters:

CPWasser CPEis

Requires the state sequences:

WATS WAeS

Basic equation:

\(temps \cdot (WATS \cdot CPEis + (WAeS-WATS)\cdot CPWasser)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(3)
>>> states.wats = 0.0, 0.5, 5.0
>>> states.waes = 0.0, 1.0, 10.0
>>> states.esnow = 0.0, 0.0, -0.1
>>> from hydpy import round_
>>> round_(model.return_esnow_v1(0, 1.0))
0.0
>>> round_(model.return_esnow_v1(1, 0.0))
0.0
>>> round_(model.return_esnow_v1(2, -3.186337))
-0.1
class hydpy.models.lland.lland_model.Calc_TempS_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the average temperature of the snow layer.

Required submethod:

Return_TempS_V1

Requires the control parameter:

NHRU

Requires the fixed parameters:

CPWasser CPEis

Requires the state sequences:

WATS WAeS ESnow

Calculates the aide sequence:

TempS

Method Calc_TempS_V1 uses method Return_TempS_V1 to calculate the snow temperature of all hydrological response units.

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(3)
>>> pwmax(2.0)
>>> fluxes.tkor = -1.0
>>> states.wats = 0.0, 0.5, 5
>>> states.waes = 0.0, 1.0, 10
>>> states.esnow = 0.0, 0.0, -0.1
>>> model.calc_temps_v1()
>>> aides.temps
temps(nan, 0.0, -3.186337)
class hydpy.models.lland.lland_model.Calc_TZ_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the mean temperature in the top-layer of the soil [4] (based on [9]).

Requires the control parameters:

NHRU Lnk

Requires the derived parameter:

HeatOfFusion

Requires the fixed parameters:

Z CG

Requires the state sequence:

EBdn

Calculates the flux sequence:

TZ

Basic equation:
\[\begin{split}TZ = \begin{cases} \frac{EBdn}{2 \cdot z \cdot CG} &|\ EBdn \leq 0 \\ 0 &|\ 0 < EBdn \leq HeatOfFusion \\ \frac{EBdn - HeatOfFusion}{2 \cdot z \cdot CG} &|\ HeatOfFusion < EBdn \end{cases}\end{split}\]

Examples:

We set TZ to nan for all types of water areas:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(7)
>>> lnk(WASSER, FLUSS, SEE, WASSER, SEE, FLUSS, WASSER)
>>> model.calc_tz_v1()
>>> fluxes.tz
tz(nan, nan, nan, nan, nan, nan, nan)

For all other land use types, the above basic equation applies:

>>> lnk(ACKER)
>>> derived.heatoffusion(26.72)
>>> states.ebdn(-10.0, -1.0, 0.0, 13.36, 26.72, 27.72, 36.72)
>>> model.calc_tz_v1()
>>> fluxes.tz
tz(-33.333333, -3.333333, 0.0, 0.0, 0.0, 3.333333, 33.333333)
class hydpy.models.lland.lland_model.Calc_G_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the “MORECS” soil heat flux (modified [4], based on [7]).

Requires the control parameters:

NHRU Lnk LAI WG2Z

Requires the derived parameters:

MOY Hours

Requires the flux sequences:

PossibleSunshineDuration DailyPossibleSunshineDuration DailyNetRadiation

Calculates the flux sequence:

G

Basic equations:

\(G = \frac{PossibleSunshineDuration} {DailyPossibleSunshineDuration} \cdot G_D + \frac{(Hours - PossibleSunshineDuration)} {24-DailyPossibleSunshineDuration} \cdot G_N\)

\(G_N = WG2Z - G_D\)

\(G_D = (0.3 - 0.03 \cdot LAI) \cdot DailyNetRadiation\)

The above equations are our interpretation on the relevant equations and explanations given in the LARSIM user manual. \(G_D\) is the daytime sum of the soil heat flux, which depends on the daily sum of net radiation and the leaf area index. Curiously, DailyNetRadiation and \(G_D\) become inversely related for leaf area index values larger than 10. WG2Z defines the daily energy change of the soil layer, which is why we use its difference to \(G_D\) for estimating the nighttime sum of the soil heat flux (\(G_N\)).

Note

The sudden jumps of the soil heat flux calculated by method Calc_G_V1 sometimes result in strange-looking evapotranspiration time-series. Hence, we do not use Calc_G_V1 in any application model for now but leave it for further discussions and use the simplified method Calc_G_V2 instead.

Examples:

To start as simple as possible, we perform the first test calculation for a daily simulation step size:

>>> from hydpy import pub
>>> pub.timegrids = "2000-05-30", "2000-06-03", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep()

We define five hydrological respose units, of which only the first four need further parameterisation, as method Calc_G_V1 generally sets G to zero for all kinds of water areas:

>>> nhru(6)
>>> lnk(BODEN, OBSTB, OBSTB, LAUBW, NADELW, WASSER)

We assign leaf area indices covering the usual range of values:

>>> lai.boden = 0.0
>>> lai.obstb = 5.0
>>> lai.laubw = 10.0
>>> lai.nadelw = 15.0

We define a positive WG2Z value for May (on average, energy moves from the soil body to the soil surface) and a negative one for June (enery moves for the surface to the body):

>>> wg2z.may = 1.0
>>> wg2z.jun = -2.0

The following derived parameters need to be updated:

>>> derived.moy.update()
>>> derived.hours.update()

For a daily simulation step size, the values of PossibleSunshineDuration (of the current simulation step) and DailyPossibleSunshineDuration must be identical:

>>> fluxes.possiblesunshineduration = 14.0
>>> fluxes.dailypossiblesunshineduration = 14.0

We set DailyNetRadiation to 10 MJ/m² for most response units, except one of the ACKER ones:

>>> fluxes.dailynetradiation = 10.0, 10.0, -10.0, 10.0, 10.0, 10.0

For the given daily simulation step size, method Calc_G_V1 calculates soil surface fluxes identical with the WG2Z value of the respective month:

>>> model.idx_sim = pub.timegrids.init["2000-05-31"]
>>> model.calc_g_v1()
>>> fluxes.g
g(1.0, 1.0, 1.0, 1.0, 1.0, 0.0)
>>> model.idx_sim = pub.timegrids.init["2000-06-01"]
>>> model.calc_g_v1()
>>> fluxes.g
g(-2.0, -2.0, -2.0, -2.0, -2.0, 0.0)

Next, we switch to an hourly step size and focus on May:

>>> pub.timegrids = "2000-05-30 00:00", "2000-06-02 00:00", "1h"
>>> model.idx_sim = pub.timegrids.init["2000-05-31"]
>>> derived.moy.update()
>>> derived.hours.update()
>>> derived.days.update()

During daytime (when the possible sunshine duration is one hour), the soil surface flux is negative for net radiation values larger one and for leaf area index values smaller than ten (see response units one and two). Negative net radiation (response unit three) ar leaf area indices larger then ten (response unit five) result in positive soil surface fluxes:

>>> fluxes.possiblesunshineduration = 1.0
>>> model.calc_g_v1()
>>> fluxes.g
g(-0.214286, -0.107143, 0.107143, 0.0, 0.107143, 0.0)
>>> day = fluxes.g.values.copy()

The nighttime soils surface fluxes (which we calculate through setting PossibleSunshineDuration to zero) somehow compensate the daytime ones:

>>> fluxes.possiblesunshineduration = 0.0
>>> model.calc_g_v1()
>>> fluxes.g
g(0.4, 0.25, -0.05, 0.1, -0.05, 0.0)
>>> night = fluxes.g.values.copy()

This compensation enforces that the daily sum the surface flux agrees with the actual value of WG2Z, which we confirm by the following test calculation:

>>> from hydpy import print_values
>>> print_values(day*fluxes.dailypossiblesunshineduration +
...              night*(24-fluxes.dailypossiblesunshineduration))
1.0, 1.0, 1.0, 1.0, 1.0, 0.0
class hydpy.models.lland.lland_model.Calc_G_V2[source]

Bases: hydpy.core.modeltools.Method

Take the actual daily soil heat flux from parameter WG2Z.

Requires the control parameters:

NHRU Lnk WG2Z

Requires the derived parameters:

MOY Days

Calculates the flux sequence:

G

Basic equations:

\(G = WG2Z\)

Note

Method Calc_G_V2 workaround. We might remove it, as soon as the shortcomings of method Calc_G_V1 are fixed.

Examples:

>>> from hydpy import pub
>>> pub.timegrids = "2000-05-30 00:00", "2000-06-02 00:00", "1h"
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(4)
>>> lnk(ACKER, WASSER, FLUSS, SEE)
>>> wg2z.may = 1.2
>>> wg2z.jun = -2.4
>>> derived.moy.update()
>>> derived.days.update()
>>> model.idx_sim = pub.timegrids.init["2000-05-31 23:00"]
>>> model.calc_g_v2()
>>> fluxes.g
g(0.05, 0.0, 0.0, 0.0)
>>> model.idx_sim = pub.timegrids.init["2000-06-01 00:00"]
>>> model.calc_g_v2()
>>> fluxes.g
g(-0.1, 0.0, 0.0, 0.0)
class hydpy.models.lland.lland_model.Return_WG_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the “dynamic” soil heat flux [4].

Required by the methods:

Calc_WG_V1 Return_BackwardEulerError_V1 Update_ESnow_V1

Requires the fixed parameters:

Z LambdaG

Requires the flux sequences:

TZ TKor

Requires the state sequence:

WAeS

Requires the aide sequence:

TempS

The soil heat flux WG depends on the temperature gradient between depth z and the surface. We set the soil surface temperature to the air temperature for snow-free conditions and otherwise to the average temperature of the snow layer.

Basic equations:
\[\begin{split}\begin{cases} LambdaG \cdot \frac{TZ-TempS}{Z} &|\ WAeS > 0 \\ LambdaG \cdot \frac{TZ-TKor}{Z} &|\ WAeS = 0 \end{cases}\end{split}\]

Examples:

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep("1d")
>>> nhru(2)
>>> fixed.lambdag.restore()
>>> fluxes.tz = 2.0
>>> fluxes.tkor = 10.0
>>> states.waes = 0.0, 1.0
>>> aides.temps = nan, -1.0
>>> from hydpy import round_
>>> round_(model.return_wg_v1(0))
-0.1728
>>> round_(model.return_wg_v1(1))
0.0648
class hydpy.models.lland.lland_model.Calc_WG_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the soil heat flux.

Required submethod:

Return_WG_V1

Requires the control parameters:

NHRU Lnk

Requires the fixed parameters:

Z LambdaG

Requires the flux sequences:

TZ TKor

Requires the state sequence:

WAeS

Requires the aide sequence:

TempS

Calculates the flux sequence:

WG

Method Calc_WG_V1 uses method Return_WG_V1 to calculate the “dynamic” soil heat flux for all hydrological response units that do not represent water areas.

Examples:

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep("1d")
>>> nhru(5)
>>> lnk(ACKER, VERS, WASSER, FLUSS, SEE)
>>> fixed.lambdag.restore()
>>> fluxes.tz = 2.0
>>> fluxes.tkor = 10.0
>>> states.waes = 0.0, 1.0, 0.0, 0.0, 0.0
>>> aides.temps = nan, -1.0, nan, nan, nan
>>> model.calc_wg_v1()
>>> fluxes.wg
wg(-0.1728, 0.0648, 0.0, 0.0, 0.0)
class hydpy.models.lland.lland_model.Update_EBdn_V1[source]

Bases: hydpy.core.modeltools.Method

Update the thermal energy content of the upper soil layer [4].

Requires the control parameters:

NHRU Lnk WG2Z

Requires the derived parameters:

MOY Days

Requires the flux sequence:

WG

Updates the state sequence:

EBdn

Basic equation:

\(\frac{dEBdn}{dt} = WG2Z \cdot Days - WG\)

Example:

Water areas do not posses a soil energy content. For all other landuse types, the above equation applies:

>>> from hydpy.models.lland import *
>>> from hydpy import pub
>>> parameterstep()
>>> nhru(6)
>>> lnk(WASSER, FLUSS, SEE, ACKER, ACKER, ACKER)
>>> pub.timegrids = "2019-04-29", "2019-05-03", "1d"
>>> derived.moy.update()
>>> derived.seconds.update()
>>> derived.days.update()
>>> wg2z.apr = -0.03
>>> wg2z.may = -0.04
>>> states.ebdn = 0.0
>>> fluxes.wg = 0.0, 0.0, 0.0, 0.5, 1.0, 2.0
>>> model.idx_sim = 1
>>> model.update_ebdn_v1()
>>> states.ebdn
ebdn(0.0, 0.0, 0.0, -0.53, -1.03, -2.03)
>>> model.idx_sim = 2
>>> model.update_ebdn_v1()
>>> states.ebdn
ebdn(0.0, 0.0, 0.0, -1.07, -2.07, -4.07)
class hydpy.models.lland.lland_model.Return_WSensInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the sensible heat flux between the intercepted snow and the atmosphere.

Required by the methods:

Return_BackwardEulerErrorInz_V1 Return_WSurfInz_V1

Requires the control parameters:

Turb0 Turb1

Requires the flux sequences:

TKor ReducedWindSpeed2m

Requires the aide sequence:

TempSInz

Basic equation:

\((Turb0 + Turb1 \cdot WindSpeed2m) \cdot (TempSInz - TKor)\)

Example:

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep("1d")
>>> nhru(2)
>>> turb0(0.1728)
>>> turb1(0.1728)
>>> fluxes.tkor = -2.0, -1.0
>>> fluxes.reducedwindspeed2m = 3.0
>>> aides.tempsinz = -5.0, 0.0
>>> from hydpy import round_
>>> round_(model.return_wsensinz_v1(0))
-0.0864
>>> round_(model.return_wsensinz_v1(1))
0.0288
class hydpy.models.lland.lland_model.Return_WSensSnow_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the sensible heat flux of the snow surface [4].

Required by the method:

Return_EnergyGainSnowSurface_V1

Requires the control parameters:

Turb0 Turb1

Requires the flux sequences:

TKor TempSSurface ReducedWindSpeed2m

Basic equation:

\((Turb0 + Turb1 \cdot WindSpeed2m) \cdot (TempSSurface - TKor)\)

Example:

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep("1d")
>>> nhru(2)
>>> turb0(0.1728)
>>> turb1(0.1728)
>>> fluxes.tkor = -2.0, -1.0
>>> fluxes.tempssurface = -5.0, 0.0
>>> fluxes.reducedwindspeed2m = 3.0
>>> from hydpy import round_
>>> round_(model.return_wsenssnow_v1(0))
-0.0864
>>> round_(model.return_wsenssnow_v1(1))
0.0288
class hydpy.models.lland.lland_model.Return_WLatInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the latent heat flux between the surface of the intercepted snow and the atmosphere.

Required by the methods:

Return_BackwardEulerErrorInz_V1 Return_WSurfInz_V1

Requires the control parameters:

Turb0 Turb1

Requires the fixed parameter:

PsyInv

Requires the flux sequences:

ReducedWindSpeed2m SaturationVapourPressureInz ActualVapourPressure

Basic equation:

\((Turb0 + Turb1 \cdot ReducedWindSpeed2m) \cdot PsiInv \cdot (SaturationVapourPressureInz - ActualVapourPressure))\)

Example:

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep("1d")
>>> nhru(2)
>>> turb0(0.1728)
>>> turb1(0.1728)
>>> fluxes.reducedwindspeed2m = 3.0
>>> fluxes.saturationvapourpressureinz = 0.4, 0.8
>>> fluxes.actualvapourpressure = .6108
>>> from hydpy import round_
>>> round_(model.return_wlatinz_v1(0))
-0.10685
>>> round_(model.return_wlatinz_v1(1))
0.095902
class hydpy.models.lland.lland_model.Return_WLatSnow_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the latent heat flux of the snow surface [4].

Required by the method:

Return_EnergyGainSnowSurface_V1

Requires the control parameters:

Turb0 Turb1

Requires the fixed parameter:

PsyInv

Requires the flux sequences:

ReducedWindSpeed2m SaturationVapourPressureSnow ActualVapourPressure

Basic equation:

\((Turb0 + Turb1 \cdot ReducedWindSpeed2m) \cdot PsiInv \cdot (SaturationVapourPressureSnow - ActualVapourPressure))\)

Example:

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep("1d")
>>> nhru(2)
>>> turb0(0.1728)
>>> turb1(0.1728)
>>> fluxes.reducedwindspeed2m = 3.0
>>> fluxes.saturationvapourpressuresnow = 0.4, 0.8
>>> fluxes.actualvapourpressure = .6108
>>> from hydpy import round_
>>> round_(model.return_wlatsnow_v1(0))
-0.10685
>>> round_(model.return_wlatsnow_v1(1))
0.095902
class hydpy.models.lland.lland_model.Return_WSurf_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the snow surface heat flux [4] (based on [9]).

Required by the method:

Return_EnergyGainSnowSurface_V1

Requires the control parameter:

KTSchnee

Requires the flux sequence:

TempSSurface

Requires the aide sequence:

TempS

Basic equation:

\(KTSchnee \cdot (TempS - TempSSurface)\)

Example:

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep("1d")
>>> nhru(1)
>>> ktschnee(0.432)
>>> fluxes.tempssurface = -3.0
>>> aides.temps = -2.0
>>> from hydpy import round_
>>> round_(model.return_wsurf_v1(0))
0.018

Method Return_WSurf_V1 explicitely supports infinite KTSchnee values:

>>> ktschnee(inf)
>>> round_(model.return_wsurf_v1(0))
inf
class hydpy.models.lland.lland_model.Return_NetRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the total net radiation.

Required by the methods:

Calc_DailyNetRadiation_V1 Calc_NetRadiation_V1 Return_BackwardEulerErrorInz_V1 Return_EnergyGainSnowSurface_V1 Return_WSurfInz_V1

Basic equation:

\(netshortwaveradiation - netlongwaveradiation\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> from hydpy import round_
>>> round_(model.return_netradiation_v1(3.0, 2.0))
1.0
class hydpy.models.lland.lland_model.Calc_NetRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the total net radiation.

Required submethod:

Return_NetRadiation_V1

Requires the control parameter:

NHRU

Requires the derived parameter:

Days

Requires the flux sequences:

NetShortwaveRadiation DailyNetLongwaveRadiation

Updates the flux sequence:

NetRadiation

Basic equation:

\(NetRadiation = Return\_NetRadiation\_V1( NetShortwaveRadiation, DailyNetLongwaveRadiation \cdot Days)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(1)
>>> derived.days(0.5)
>>> fluxes.netshortwaveradiation = 3.0
>>> fluxes.dailynetlongwaveradiation = 2.0
>>> model.calc_netradiation_v1()
>>> fluxes.netradiation
netradiation(2.0)
class hydpy.models.lland.lland_model.Calc_DailyNetRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the daily total net radiation for snow-free land surfaces.

Required submethod:

Return_NetRadiation_V1

Requires the control parameter:

NHRU

Requires the flux sequences:

DailyNetLongwaveRadiation DailyNetShortwaveRadiation

Calculates the flux sequence:

DailyNetRadiation

Basic equation:

\(NetRadiation = Return\_NetRadiation\_V1( DailyDailyNetShortwaveRadiation, DailyNetLongwaveRadiation)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(1)
>>> fluxes.dailynetshortwaveradiation = 3.0
>>> fluxes.dailynetlongwaveradiation = 2.0
>>> model.calc_dailynetradiation_v1()
>>> fluxes.dailynetradiation
dailynetradiation(1.0)
class hydpy.models.lland.lland_model.Return_EnergyGainSnowSurface_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the net energy gain of the snow surface ([4] [9], modified).

Required by the method:

Return_TempSSurface_V1

Required submethods:

Return_SaturationVapourPressure_V1 Return_WLatSnow_V1 Return_WSensSnow_V1 Return_NetLongwaveRadiationSnow_V1 Return_NetRadiation_V1 Return_WSurf_V1

Requires the control parameters:

Lnk KTSchnee Turb0 Turb1

Requires the derived parameters:

MOY Days Fr

Requires the fixed parameters:

PsyInv Sigma

Requires the flux sequences:

NetShortwaveRadiationSnow TKor ReducedWindSpeed2m ActualVapourPressure

Requires the aide sequences:

TempS RLAtm

Calculates the flux sequences:

TempSSurface SaturationVapourPressureSnow WSensSnow WLatSnow NetLongwaveRadiationSnow NetRadiationSnow WSurf

As surface cannot store any energy, method Return_EnergyGainSnowSurface_V1 returns zero if one supplies it with the correct temperature of the snow surface. Hence, this methods provides a means to find this “correct” temperature via root finding algorithms.

Basic equation:

\(WSurf(tempssurface) + NetshortwaveRadiation - NetlongwaveRadiation(tempssurface) - WSensSnow(tempssurface) - WLatSnow(tempssurface)\)

Example:

Method Return_EnergyGainSnowSurface_V1 relies on multiple submethods with different requirements. Hence, we first need to specify a lot of input data (see the documentation on the different submethods for further information):

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> nhru(1)
>>> lnk(ACKER)
>>> turb0(0.1728)
>>> turb1(0.1728)
>>> ktschnee(0.432)
>>> derived.days.update()
>>> inputs.relativehumidity = 60.0
>>> states.waes = 1.0
>>> fluxes.tkor = -3.0
>>> fluxes.reducedwindspeed2m = 3.0
>>> fluxes.actualvapourpressure = 0.29
>>> fluxes.netshortwaveradiationsnow = 2.0
>>> derived.nmblogentries.update()
>>> aides.temps = -2.0
>>> aides.rlatm = 17.581556544

Under the defined conditions and for a snow surface temperature of -4 °C, the net energy gain would be negative:

>>> from hydpy import round_
>>> model.idx_hru = 0
>>> round_(model.return_energygainsnowsurface_v1(-4.0))
-6.565618

As a side-effect, method Return_EnergyGainSnowSurface_V1 calculates the following flux sequences for the given snow surface temperature:

>>> fluxes.saturationvapourpressuresnow
saturationvapourpressuresnow(0.453913)
>>> fluxes.netlongwaveradiationsnow
netlongwaveradiationsnow(8.126801)
>>> fluxes.netradiationsnow
netradiationsnow(-6.126801)
>>> fluxes.wsenssnow
wsenssnow(-0.6912)
>>> fluxes.wlatsnow
wlatsnow(1.994016)
>>> fluxes.wsurf
wsurf(0.864)

Technical checks:

Note that method Return_EnergyGainSnowSurface_V1 calculates the value of sequence SaturationVapourPressureSnow before its submethod Return_WLatSnow_V1 uses it and that it assigns the given value to sequence TempSSurface before its submethods Return_WSensSnow_V1, Return_NetLongwaveRadiationSnow_V1, and Return_WSurf_V1 use it:

>>> from hydpy.core.testtools import check_selectedvariables
>>> from hydpy.models.lland.lland_model import (
...     Return_EnergyGainSnowSurface_V1)
>>> print(check_selectedvariables(Return_EnergyGainSnowSurface_V1))
Possibly missing (REQUIREDSEQUENCES):
    Return_WLatSnow_V1: SaturationVapourPressureSnow
    Return_WSensSnow_V1: TempSSurface
    Return_NetLongwaveRadiationSnow_V1: TempSSurface
    Return_WSurf_V1: TempSSurface
class hydpy.models.lland.lland_model.Return_TempSSurface_V1[source]

Bases: hydpy.core.modeltools.Method

Determine and return the snow surface temperature ([4] based on [9], modified).

Required by the methods:

Return_BackwardEulerError_V1 Update_ESnow_V1

Required submethod:

Return_EnergyGainSnowSurface_V1

Requires the control parameters:

Lnk Turb0 Turb1 KTSchnee

Requires the derived parameters:

MOY Days Fr

Requires the fixed parameters:

Sigma PsyInv

Requires the flux sequences:

NetShortwaveRadiationSnow TKor ReducedWindSpeed2m ActualVapourPressure

Requires the state sequence:

WAeS

Requires the aide sequences:

TempS RLAtm

Calculates the flux sequences:

TempSSurface SaturationVapourPressureSnow WSensSnow WLatSnow NetLongwaveRadiationSnow NetRadiationSnow WSurf

Return_TempSSurface_V1 needs to determine the snow surface temperature via iteration. Therefore, it uses the class PegasusTempSSurface which searches the root of the net energy gain of the snow surface defined by method Return_EnergyGainSnowSurface_V1.

For snow-free conditions, method Return_TempSSurface_V1 sets the value of TempSSurface to nan and the values of WSensSnow, WLatSnow, and WSurf to zero. For snow conditions, the side-effects discussed in the documentation on method Return_EnergyGainSnowSurface_V1 apply.

Example:

We reuse the configuration of the documentation on method Return_EnergyGainSnowSurface_V1, except that we prepare six hydrological response units and calculate their snow surface temperature:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> nhru(6)
>>> lnk(ACKER)
>>> turb0(0.1728)
>>> turb1(0.1728)
>>> ktschnee(0.432)
>>> derived.nmblogentries.update()
>>> derived.days.update()
>>> inputs.relativehumidity = 60.0
>>> states.waes = 0.0, 1.0, 1.0, 1.0, 1.0, 1.0
>>> fluxes.tkor = -3.0
>>> fluxes.reducedwindspeed2m = 3.0
>>> fluxes.actualvapourpressure = 0.29
>>> fluxes.netshortwaveradiationsnow = 1.0, 1.0, 2.0, 2.0, 2.0, 20.0
>>> aides.temps = nan, -2.0, -2.0, -50.0, -200.0, -2.0
>>> aides.rlatm = 17.581556544
>>> for hru in range(6):
...     _ = model.return_tempssurface_v1(hru)

For the first, snow-free response unit, we cannot define a reasonable snow surface temperature, of course:

>>> fluxes.tempssurface[0]
nan

Comparing response units two and three shows that a moderate increase in short wave radiation is compensated by a moderate increase in snow surface temperature:

>>> from hydpy import print_values
>>> print_values(fluxes.tempssurface[1:3])
-8.064938, -7.512933

To demonstrate the robustness of the implemented approach, response units three to five show the extreme decrease in surface temperature due to an even more extrem decrease in the bulk temperature of the snow layer:

>>> print_values(fluxes.tempssurface[2:5])
-7.512933, -19.826442, -66.202324

The sixths response unit comes with a very high net radiation to clarify that the allowed maximum value of the snow surface temperature is 0°C. Hence, the snow temperature gradient might actually be too small for conducting all available energy deeper into the snow layer. In reality, only the topmost snow layer would melt in such a situation. Here, we do not differentiate between melting processes in different layers and thus add the potential energy excess at the snow surface to WSurf:

>>> print_values(fluxes.tempssurface[5:])
0.0

As to be expected, the energy fluxes of the snow surface neutralise each other (within the defined numerical accuracy):

>>> print_values(fluxes.netradiationsnow -
...              fluxes.wsenssnow -
...              fluxes.wlatsnow +
...              fluxes.wsurf)
nan, 0.0, 0.0, 0.0, 0.0, 0.0

Through setting parameter KTSchnee to inf, we disable the iterative search for the correct surface temperature. Instead, method Return_TempSSurface_V1 simply uses the bulk temperature of the snow layer as its surface temperature and sets WSurf so that the energy gain of the snow surface is zero:

>>> ktschnee(inf)
>>> for hru in range(6):
...     _ = model.return_tempssurface_v1(hru)
>>> fluxes.tempssurface
tempssurface(nan, -2.0, -2.0, -50.0, -200.0, -2.0)
>>> fluxes.wsurf
wsurf(0.0, 11.476385, 10.476385, -43.376447, -159.135575, -7.523615)
>>> print_values(fluxes.netradiationsnow -
...              fluxes.wsenssnow -
...              fluxes.wlatsnow +
...              fluxes.wsurf)
nan, 0.0, 0.0, 0.0, 0.0, 0.0
class hydpy.models.lland.lland_model.Return_WSurfInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the intercepted snow heat flux WSurfInz.

Required by the methods:

Return_BackwardEulerErrorInz_V1 Update_ESnowInz_V1

Required submethods:

Return_SaturationVapourPressure_V1 Return_WLatInz_V1 Return_WSensInz_V1 Return_NetLongwaveRadiationInz_V1 Return_NetRadiation_V1

Requires the control parameters:

Turb0 Turb1 Lnk

Requires the derived parameters:

MOY Days Fr

Requires the fixed parameters:

Sigma PsyInv

Requires the flux sequences:

NetShortwaveRadiationInz TKor ReducedWindSpeed2m ActualVapourPressure

Requires the aide sequences:

TempSInz RLAtm

Calculates the flux sequences:

SaturationVapourPressureInz WSensInz WLatInz NetLongwaveRadiationInz NetRadiationInz WSurfInz

Basic equation:

\(WSurfInz = WSensInz + WLatInz - NetRadiationInz\)

Note that method Return_WSurfInz_V1 calls a number of submethods and uses their results to update the corresponding sequences. When calculating SaturationVapourPressureInz calls method Return_SaturationVapourPressure_V1, as follows:

\(SaturationVapourPressureInz = Return_SaturationVapourPressure_V1( max(TempSInz, TKor)\)

The reason for using the maximum of the intercepted snow temperature (TempSInz) and the air temperature (TKor) is to increase the evaporation of intercepted snow (EvSInz). See [4], section 3.4.6.1, for a more detailed discussion.

Example:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(1)
>>> lnk(LAUBW)
>>> turb0(0.1728)
>>> turb1(0.1728)
>>> derived.fr(0.5)
>>> derived.nmblogentries.update()
>>> derived.days.update()
>>> derived.moy.update()
>>> inputs.relativehumidity = 60.0
>>> fluxes.tkor = -3.0
>>> fluxes.reducedwindspeed2m = 3.0
>>> fluxes.actualvapourpressure = 0.29
>>> fluxes.netshortwaveradiationinz = 2.0
>>> fluxes.dailysunshineduration = 10.0
>>> fluxes.dailypossiblesunshineduration = 12.0
>>> aides.tempsinz = -6.3252369154
>>> aides.rlatm = 17.581556544

>>> from hydpy import round_
>>> round_(model.return_wsurfinz_v1(0))
1.751625

>>> fluxes.saturationvapourpressureinz
saturationvapourpressureinz(0.489349)
>>> fluxes.netlongwaveradiationinz
netlongwaveradiationinz(3.624925)
>>> fluxes.netradiationinz
netradiationinz(-1.624925)
>>> fluxes.wsensinz
wsensinz(-2.298404)
>>> fluxes.wlatinz
wlatinz(2.425103)
>>> fluxes.wsurfinz
wsurfinz(1.751625)

Technical checks:

>>> from hydpy.core.testtools import check_selectedvariables
>>> from hydpy.models.lland.lland_model import Return_WSurfInz_V1
>>> print(check_selectedvariables(Return_WSurfInz_V1))
Possibly missing (REQUIREDSEQUENCES):
    Return_WLatInz_V1: SaturationVapourPressureInz
class hydpy.models.lland.lland_model.Return_BackwardEulerErrorInz_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the “Backward Euler error” regarding the update of ESnowInz due to the energy flux WSurfInz.

Required by the method:

Update_ESnowInz_V1

Required submethods:

Return_TempSInz_V1 Return_SaturationVapourPressure_V1 Return_WLatInz_V1 Return_WSensInz_V1 Return_NetLongwaveRadiationInz_V1 Return_NetRadiation_V1 Return_WSurfInz_V1

Requires the control parameters:

Turb0 Turb1 Lnk

Requires the derived parameters:

MOY Days Fr

Requires the fixed parameters:

CPWasser CPEis Sigma PsyInv

Requires the flux sequences:

NetShortwaveRadiationInz TKor ReducedWindSpeed2m ActualVapourPressure

Requires the state sequences:

SInz STInz ESnowInz

Requires the aide sequence:

RLAtm

Calculates the flux sequences:

SaturationVapourPressureInz WSensInz WLatInz NetLongwaveRadiationInz NetRadiationInz WSurfInz

Calculates the aide sequence:

TempSInz

Basic equation:

\(ESnowInz_{old} - esnowinz_{new} - WSurfInz(esnowinz{new})\)

Example:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(1)
>>> lnk(LAUBW)
>>> turb0(0.1728)
>>> turb1(0.1728)
>>> derived.fr(0.5)
>>> derived.nmblogentries.update()
>>> derived.days.update()
>>> derived.moy.update()
>>> inputs.relativehumidity = 60.0
>>> states.sinz = 120.0
>>> states.stinz = 100.0
>>> fluxes.tkor = -3.0
>>> fluxes.reducedwindspeed2m = 3.0
>>> fluxes.actualvapourpressure = 0.29
>>> fluxes.netshortwaveradiationinz = 2.0
>>> states.esnowinz = -0.1
>>> fluxes.dailysunshineduration = 10.0
>>> fluxes.dailypossiblesunshineduration = 12.0
>>> aides.rlatm = 17.581556544

>>> from hydpy import round_
>>> model.idx_hru = 0
>>> round_(model.return_backwardeulererrorinz_v1(-1.8516245536573426))
0.0

>>> aides.tempsinz
tempsinz(-6.325237)
>>> fluxes.saturationvapourpressureinz
saturationvapourpressureinz(0.489349)
>>> fluxes.netlongwaveradiationinz
netlongwaveradiationinz(3.624925)
>>> fluxes.netradiationinz
netradiationinz(-1.624925)
>>> fluxes.wsensinz
wsensinz(-2.298404)
>>> fluxes.wlatinz
wlatinz(2.425103)
>>> fluxes.wsurfinz
wsurfinz(1.751625)

>>> states.esnowinz
esnowinz(-0.1)

>>> states.sinz = 0.0
>>> round_(model.return_backwardeulererrorinz_v1(-1.8516245536573426))
nan
>>> fluxes.wsurfinz
wsurfinz(1.751625)

Technical checks:

>>> from hydpy.core.testtools import check_selectedvariables
>>> from hydpy.models.lland.lland_model import Return_BackwardEulerErrorInz_V1
>>> print(check_selectedvariables(Return_BackwardEulerErrorInz_V1))
Possibly missing (REQUIREDSEQUENCES):
    Return_WLatInz_V1: SaturationVapourPressureInz
    Return_WSensInz_V1: TempSInz
    Return_NetLongwaveRadiationInz_V1: TempSInz
    Return_WSurfInz_V1: TempSInz
class hydpy.models.lland.lland_model.Return_BackwardEulerError_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the “Backward Euler error” regarding the update of ESnow due to the energy fluxes WG and WSurf ([4] based on [9], modified).

Required by the method:

Update_ESnow_V1

Required submethods:

Return_TempS_V1 Return_WG_V1 Return_TempSSurface_V1

Requires the control parameters:

Turb0 Turb1 Lnk KTSchnee

Requires the derived parameters:

MOY Days Fr

Requires the fixed parameters:

CPWasser CPEis Z LambdaG Sigma PsyInv

Requires the flux sequences:

NetShortwaveRadiationSnow TKor ReducedWindSpeed2m TZ ActualVapourPressure

Requires the state sequences:

WAeS WATS ESnow

Requires the aide sequences:

TempS RLAtm

Calculates the flux sequences:

TempSSurface SaturationVapourPressureSnow WSensSnow WLatSnow NetLongwaveRadiationSnow NetRadiationSnow WSurf WG

Basic equation:

\(ESnow_{old} - esnow_{new} + WG(esnow{new} ) - WSurf(esnow{new})\)

Method Return_BackwardEulerError_V1 does not calculate any hydrologically meaningfull property. It is just a technical means to update the energy content of the snow layer with running into instability issues. See the documentation on method Update_ESnow_V1 for further information.

Example:

Method Return_BackwardEulerError_V1 relies on multiple submethods with different requirements. Hence, we first need to specify a lot of input data (see the documentation on the different submethods for further information):

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> nhru(1)
>>> lnk(ACKER)
>>> turb0(0.1728)
>>> turb1(0.1728)
>>> derived.nmblogentries.update()
>>> derived.days.update()
>>> inputs.relativehumidity = 60.0
>>> states.waes = 12.0
>>> states.wats = 10.0
>>> fluxes.tkor = -3.0
>>> fluxes.reducedwindspeed2m = 3.0
>>> fluxes.actualvapourpressure = 0.29
>>> fluxes.netshortwaveradiationsnow = 2.0
>>> states.esnow = -0.1
>>> fluxes.tz = 0.0
>>> aides.rlatm = 17.581556544

Under the defined conditions the “correct” next value of ESnow, when following the Backward Euler approach, is approximately -0.195 MJ/m²:

>>> ktschnee(inf)
>>> from hydpy import round_
>>> model.idx_hru = 0
>>> round_(model.return_backwardeulererror_v1(-0.19536469903172524))
0.0

As a side-effect, method Return_BackwardEulerError_V1 calculates the following flux sequences for the given amount of energy:

>>> aides.temps
temps(-6.67375)
>>> fluxes.tempssurface
tempssurface(-6.67375)
>>> fluxes.saturationvapourpressuresnow
saturationvapourpressuresnow(0.370062)
>>> fluxes.netlongwaveradiationsnow
netlongwaveradiationsnow(7.12037)
>>> fluxes.netradiationsnow
netradiationsnow(-5.12037)
>>> fluxes.wsenssnow
wsenssnow(-2.539296)
>>> fluxes.wlatsnow
wlatsnow(0.973963)
>>> fluxes.wsurf
wsurf(3.555037)
>>> fluxes.wg
wg(3.459672)

Note that the original value of ESnow remains unchanged, to allow for calling method Return_BackwardEulerError_V1 multiple times during a root search without the need for an external reset:

>>> states.esnow
esnow(-0.1)

In the above example, KTSchnee is set to inf, which is why TempSSurface is identical with TempS. After setting the common value of 0.432 MJ/m²/K/d, the surface temperature is calculated by another, embeded iteration approach (see method Return_TempSSurface_V1). Hence, the values of TempSSurface and TempS differ and the energy amount of -0.195 MJ/m² is not correct anymore:

>>> ktschnee(0.432)
>>> round_(model.return_backwardeulererror_v1(-0.19536469903172524))
2.70906
>>> aides.temps
temps(-6.67375)
>>> fluxes.tempssurface
tempssurface(-8.632029)
>>> fluxes.saturationvapourpressuresnow
saturationvapourpressuresnow(0.317671)
>>> fluxes.netlongwaveradiationsnow
netlongwaveradiationsnow(6.402218)
>>> fluxes.netradiationsnow
netradiationsnow(-4.402218)
>>> fluxes.wsenssnow
wsenssnow(-3.892859)
>>> fluxes.wlatsnow
wlatsnow(0.336617)
>>> fluxes.wsurf
wsurf(0.845976)
>>> fluxes.wg
wg(3.459672)
>>> states.esnow
esnow(-0.1)

If there is no snow-cover, it makes little sense to call method Return_BackwardEulerError_V1. For savety, we let it then return a nan value:

>>> states.waes = 0.0
>>> round_(model.return_backwardeulererror_v1(-0.10503956))
nan
>>> fluxes.wsurf
wsurf(0.845976)
class hydpy.models.lland.lland_model.Update_ESnowInz_V1[source]

Bases: hydpy.core.modeltools.Method

Update the thermal energy content of the intercepted snow with regard to the energy fluxes from the atmosphere (except the one related to the heat content of precipitation).

Required submethods:

Return_ESnowInz_V1 Return_BackwardEulerErrorInz_V1 Return_WSurfInz_V1

Requires the control parameters:

NHRU Lnk Turb0 Turb1

Requires the derived parameters:

MOY Days Fr

Requires the fixed parameters:

CPWasser CPEis Sigma PsyInv

Requires the flux sequences:

NetShortwaveRadiationInz TKor ReducedWindSpeed2m ActualVapourPressure

Requires the state sequences:

STInz SInz

Requires the aide sequence:

RLAtm

Updates the state sequence:

ESnowInz

Calculates the flux sequences:

SaturationVapourPressureInz WSensInz WLatInz NetLongwaveRadiationInz NetRadiationInz WSurfInz

Calculates the aide sequence:

TempSInz

Basic equation:

\(\frac{dESnow}{dt} = - WSurf\)

Example:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> nhru(8)
>>> lnk(LAUBW)
>>> turb0(0.1728)
>>> turb1(0.1728)
>>> derived.fr(0.5)
>>> derived.nmblogentries.update()
>>> derived.days.update()
>>> derived.moy.update()
>>> inputs.relativehumidity = 60.0
>>> states.sinz = 0.0, 120.0, 12.0, 1.2, 0.12, 0.012, 1.2e-6, 1.2e-12
>>> states.stinz = 0.0, 100.0, 12.0, 1.0, 0.10, 0.010, 1.0e-6, 1.0e-12
>>> fluxes.tkor = -3.0
>>> fluxes.reducedwindspeed2m = 3.0
>>> fluxes.actualvapourpressure = 0.29
>>> fluxes.netshortwaveradiationinz = 2.0
>>> states.esnowinz = -0.1
>>> aides.rlatm = 17.581556544

>>> model.update_esnowinz_v1()
>>> states.esnowinz
esnowinz(0.0, -1.851625, -0.205791, -0.024628, -0.00247, -0.000247, 0.0,
         0.0)
>>> aides.tempsinz
tempsinz(nan, -6.325237, -8.2054, -8.41287, -8.438252, -8.440799,
         -8.441082, -8.441082)

>>> esnowinz = states.esnowinz.values.copy()
>>> states.esnowinz = -0.1
>>> errors = []
>>> for hru in range(8):
...     model.idx_hru = hru
...     errors.append(model.return_backwardeulererrorinz_v1(esnowinz[hru]))
>>> from hydpy import print_values
>>> print_values(errors)
nan, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0

Technical checks:

>>> from hydpy.core.testtools import check_selectedvariables
>>> from hydpy.models.lland.lland_model import Update_ESnowInz_V1
>>> print(check_selectedvariables(Update_ESnowInz_V1))
Possibly missing (REQUIREDSEQUENCES):
    Return_WSurfInz_V1: TempSInz
class hydpy.models.lland.lland_model.Update_ESnow_V1[source]

Bases: hydpy.core.modeltools.Method

Update the thermal energy content of the snow layer with regard to the energy fluxes from the soil and the atmosphere (except the one related to the heat content of precipitation). [4] based on [9], modified.

Required submethods:

Return_ESnow_V1 Return_TempSSurface_V1 Return_WG_V1 Return_BackwardEulerError_V1

Requires the control parameters:

NHRU Lnk Turb0 Turb1 KTSchnee

Requires the derived parameters:

MOY Days Fr

Requires the fixed parameters:

CPWasser CPEis Z LambdaG Sigma PsyInv

Requires the flux sequences:

NetShortwaveRadiationSnow TKor ReducedWindSpeed2m ActualVapourPressure TZ

Requires the state sequences:

WATS WAeS

Requires the aide sequences:

TempS RLAtm

Updates the state sequence:

ESnow

Calculates the flux sequences:

SaturationVapourPressureSnow TempSSurface WSensSnow WLatSnow NetLongwaveRadiationSnow NetRadiationSnow WSurf WG

Basic equation:

\(\frac{dESnow}{dt} = WG - WSurf\)

For a thin snow cover, small absolute changes in its energy content result in extreme temperature changes, which makes the above calculation stiff. Furthermore, the nonlinearity of the term \(WSurf(ESnow(t))\) prevents from finding an analytical solution of the problem. This is why we apply the A-stable Backward Euler method. Through our simplified approach of taking only one variable (ESnow) into account, we can solve the underlying root finding problem without any need to calculate or approximate derivatives. Speaking plainly, we use the Pegasus iterator PegasusESnow to find the root of method Return_BackwardEulerError_V1 whenever the surface is snow-covered.

Example:

We reuse the configuration of the documentation on method Return_BackwardEulerError_V1, except that we prepare five hydrological response units:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> nhru(8)
>>> lnk(ACKER)
>>> turb0(0.1728)
>>> turb1(0.1728)
>>> ktschnee(inf)
>>> derived.nmblogentries.update()
>>> derived.days.update()
>>> inputs.relativehumidity = 60.0
>>> states.waes = 0.0, 120.0, 12.0, 1.2, 0.12, 0.012, 1.2e-6, 1.2e-12
>>> states.wats = 0.0, 100.0, 12.0, 1.0, 0.10, 0.010, 1.0e-6, 1.0e-12
>>> fluxes.tkor = -3.0
>>> fluxes.reducedwindspeed2m = 3.0
>>> fluxes.actualvapourpressure = 0.29
>>> fluxes.netshortwaveradiationsnow = 2.0
>>> states.esnow = -0.1
>>> fluxes.tz = 0.0
>>> aides.rlatm = 17.581556544

For the first, snow-free response unit, the energy content of the snow layer is zero. For the other response units we see that the energy content decreases with decreasing snow thickness (This result is intuitively clear, but requires iteration in very different orders of magnitudes. We hope, our implementation works always well. Please tell us, if you encounter any cases where it does not):

>>> model.update_esnow_v1()
>>> states.esnow
esnow(0.0, -1.723064, -0.167737, -0.019803, -0.001983, -0.000198, 0.0,
      0.0)
>>> aides.temps
temps(nan, -5.886068, -6.688079, -6.764855, -6.774109, -6.775036,
      -6.775139, -6.775139)
>>> fluxes.tempssurface
tempssurface(nan, -5.886068, -6.688079, -6.764855, -6.774109, -6.775036,
             -6.775139, -6.775139)

As to be expected, the requirement of the Backward Euler method is approximetely fullfilled for each response unit:

>>> esnow = states.esnow.values.copy()
>>> states.esnow = -0.1
>>> errors = []
>>> for hru in range(8):
...     model.idx_hru = hru
...     errors.append(model.return_backwardeulererror_v1(esnow[hru]))
>>> from hydpy import print_values
>>> print_values(errors)
nan, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0

The following example repeats the above one, but enables the iterative adjustment of the snow surface temperature, which is embeded into the iterative adjustment of the energy content of the snow layer:

>>> ktschnee(0.432)
>>> model.update_esnow_v1()
>>> states.esnow
esnow(0.0, -0.806055, -0.090244, -0.010808, -0.001084, -0.000108, 0.0,
      0.0)
>>> aides.temps
temps(nan, -2.753522, -3.59826, -3.692022, -3.7035, -3.704652, -3.70478,
      -3.70478)
>>> fluxes.tempssurface
tempssurface(nan, -7.692134, -7.893588, -7.915986, -7.918728, -7.919003,
             -7.919034, -7.919034)

The resulting energy amounts are, again, the “correct” ones:

>>> esnow = states.esnow.values.copy()
>>> states.esnow = -0.1
>>> errors = []
>>> for hru in range(8):
...     model.idx_hru = hru
...     errors.append(model.return_backwardeulererror_v1(esnow[hru]))
>>> print_values(errors)
nan, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
class hydpy.models.lland.lland_model.Calc_SchmPot_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the potential snow melt according to the day degree method.

Requires the control parameter:

NHRU

Requires the fixed parameter:

RSchmelz

Requires the flux sequences:

WGTF WNied

Calculates the flux sequence:

SchmPot

Basic equation:

\(SchmPot = max\left(\frac{WGTF + WNied}{RSchmelz}, 0\right)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(2)
>>> fluxes.wgtf = 2.0
>>> fluxes.wnied = 1.0, 2.0
>>> model.calc_schmpot_v1()
>>> fluxes.schmpot
schmpot(8.982036, 11.976048)
class hydpy.models.lland.lland_model.Calc_SchmPot_V2[source]

Bases: hydpy.core.modeltools.Method

Calculate the potential snow melt according to the heat content of the snow layer.

Requires the control parameter:

NHRU

Requires the fixed parameter:

RSchmelz

Requires the state sequences:

ESnow WAeS

Calculates the flux sequence:

SchmPot

Basic equation:

\(SchmPot = max\left(\frac{ESnow}{RSchmelz}, 0\right)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(4)
>>> states.waes = 0.0, 1.0, 1.0, 1.0
>>> states.esnow = nan, 5.0, 2.0, -2.0
>>> model.calc_schmpot_v2()
>>> fluxes.schmpot
schmpot(0.0, 14.97006, 5.988024, 0.0)
class hydpy.models.lland.lland_model.Calc_GefrPot_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the potential refreezing within the snow layer according to the thermal energy content of the snow layer.

Requires the control parameter:

NHRU

Requires the fixed parameter:

RSchmelz

Requires the state sequences:

ESnow WAeS

Calculates the flux sequence:

GefrPot

Basic equation:

\(GefrPot = max\left(-\frac{ESnow}{RSchmelz}, 0\right)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(4)
>>> states.waes = 0.0, 1.0, 1.0, 1.0
>>> states.esnow = nan, -5.0, -2.0, 2.0
>>> model.calc_gefrpot_v1()
>>> fluxes.gefrpot
gefrpot(0.0, 14.97006, 5.988024, 0.0)
class hydpy.models.lland.lland_model.Calc_Schm_WATS_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the actual amount of water melting within the snow layer.

Requires the control parameters:

NHRU Lnk

Requires the flux sequence:

SchmPot

Updates the state sequence:

WATS

Calculates the flux sequence:

Schm

Basic equations:

\(\frac{dW\!ATS}{dt} = -Schm\)

\[\begin{split}Schm = \begin{cases} SchmPot &|\ WATS > 0 \\ 0 &|\ WATS = 0 \end{cases}\end{split}\]

Examples:

We initialise two water (FLUSS and SEE) and four arable land (ACKER) HRUs. We assume the same values for the initial amount of frozen water (WATS) and the frozen part of stand precipitation (SBes), but different values for potential snowmelt (SchmPot):

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(6)
>>> lnk(FLUSS, SEE, ACKER, ACKER, ACKER, ACKER)
>>> states.wats = 0.0, 0.0, 2.0, 2.0, 2.0, 2.0
>>> fluxes.schmpot = 1.0, 1.0, 0.0, 1.0, 3.0, 5.0
>>> model.calc_schm_wats_v1()
>>> states.wats
wats(0.0, 0.0, 2.0, 1.0, 0.0, 0.0)
>>> fluxes.schm
schm(0.0, 0.0, 0.0, 1.0, 2.0, 2.0)

Actual melt is either limited by potential melt or the available frozen water, which is the sum of initial frozen water and the frozen part of stand precipitation.

class hydpy.models.lland.lland_model.Calc_Gefr_WATS_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the actual amount of water melting within the snow layer.

Requires the control parameters:

NHRU Lnk RefreezeFlag

Requires the flux sequence:

GefrPot

Requires the state sequence:

WAeS

Updates the state sequence:

WATS

Calculates the flux sequence:

Gefr

Basic equations:

\(\frac{dGefr}{dt} = -Gefr\)

\[\begin{split}Gefr = \begin{cases} GefrPot &|\ WAeS - WATS > 0 \\ 0 &|\ WAeS - WATS = 0 \end{cases}\end{split}\]

Examples:

We initialise two water (FLUSS and SEE) and four arable land (ACKER) HRUs. We assume the same values for the initial amount of frozen water (WATS) and the frozen part of stand precipitation (SBes), but different values for potential snowmelt (SchmPot):

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(6)
>>> lnk(FLUSS, SEE, ACKER, ACKER, ACKER, ACKER)
>>> refreezeflag(True)
>>> states.wats = 0.0, 0.0, 2.0, 2.0, 2.0, 2.0
>>> states.waes = 0.0, 0.0, 4.0, 4.0, 4.0, 4.0
>>> fluxes.gefrpot = 1.0, 1.0, 0.0, 1.0, 3.0, 5.0
>>> model.calc_gefr_wats_v1()
>>> states.wats
wats(0.0, 0.0, 2.0, 3.0, 4.0, 4.0)
>>> fluxes.gefr
gefr(0.0, 0.0, 0.0, 1.0, 2.0, 2.0)

If we deactivate the refreezing flag, liquid water in the snow layer does not refreeze. Gefr is set to 0 and WATS does not change:

>>> refreezeflag(False)
>>> model.calc_gefr_wats_v1()
>>> states.wats
wats(0.0, 0.0, 2.0, 3.0, 4.0, 4.0)
>>> fluxes.gefr
gefr(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)

Actual refreezing is either limited by potential refreezing or the available water.

class hydpy.models.lland.lland_model.Update_WaDa_WAeS_V1[source]

Bases: hydpy.core.modeltools.Method

Update the actual water release from and the liquid water content of the snow layer due to melting.

Requires the control parameters:

NHRU Lnk PWMax

Requires the state sequence:

WATS

Updates the flux sequence:

WaDa

Updates the state sequence:

WAeS

Basic equations:

\(WaDa_{new} = WaDa_{old} + \Delta\)

\(WAeS_{new} = WAeS_{old} - \Delta\)

\(\Delta = max(WAeS-PWMax \cdot WATS, 0)\)

Examples:

We set the threshold parameter PWMax for each of the seven initialised hydrological response units to two. Thus, the snow cover can hold as much liquid water as it contains frozen water. For the first three response units, which represent water surfaces, snow-related processes are ignored and the original values of WaDa and WAeS remain unchanged. For all other land use classes (of which we select ACKER arbitrarily), method Update_WaDa_WAeS_V1 passes only the amount of WAeS exceeding the actual snow holding capacity to WaDa:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(7)
>>> lnk(WASSER, FLUSS, SEE, ACKER, ACKER, ACKER, ACKER)
>>> pwmax(2.0)
>>> states.wats = 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0
>>> states.waes = 1.0, 1.0, 1.0, 0.0, 1.0, 2.0, 3.0
>>> fluxes.wada = 1.0
>>> model.update_wada_waes_v1()
>>> states.waes
waes(1.0, 1.0, 1.0, 0.0, 1.0, 2.0, 2.0)
>>> fluxes.wada
wada(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0)
class hydpy.models.lland.lland_model.Update_ESnow_V2[source]

Bases: hydpy.core.modeltools.Method

Update the thermal energy content of the snow layer regarding snow melt and refreezing.

Requires the control parameters:

NHRU Lnk

Requires the fixed parameter:

RSchmelz

Requires the flux sequences:

Gefr Schm

Requires the state sequence:

WAeS

Updates the state sequence:

ESnow

Basic equation:

\(\frac{dESNOW}{dt} = RSchmelz \cdot (Gefr - Schm)\)

Examples:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(7)
>>> lnk(WASSER, FLUSS, SEE, ACKER, ACKER, ACKER, ACKER)
>>> fluxes.gefr = 0.0, 0.0, 0.0, 0.0, 4.0, 0.0, 4.0
>>> fluxes.schm = 0.0, 0.0, 0.0, 0.0, 0.0, 4.0, 4.0
>>> states.esnow = 1.0, 1.0, 1.0, 1.0, -1.5, 1.336, 0.0
>>> states.waes = 1.0, 1.0, 1.0, 0.0, 5.0, 5.0, 10.0
>>> model.update_esnow_v2()
>>> states.esnow
esnow(0.0, 0.0, 0.0, 0.0, -0.164, 0.0, 0.0)
class hydpy.models.lland.lland_model.Calc_SFF_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the ratio between frozen water and total water within the top soil layer [4].

Requires the control parameters:

NHRU Lnk

Requires the fixed parameters:

BoWa2Z RSchmelz

Requires the state sequence:

EBdn

Calculates the flux sequence:

SFF

Basic equations:

\(SFF = min\left(max\left( 1 - \frac{EBdn}{BoWa2Z} \cdot RSchmelz, 0\right), 1\right)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(9)
>>> lnk(VERS, WASSER, FLUSS, SEE, ACKER, ACKER, ACKER, ACKER, ACKER)
>>> states.ebdn(0.0, 0.0, 0.0, 0.0, 28.0, 27.0, 10.0, 0.0, -1.0)
>>> model.calc_sff_v1()
>>> fluxes.sff
sff(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.625749, 1.0, 1.0)
class hydpy.models.lland.lland_model.Calc_FVG_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the degree of frost sealing of the soil [4].

Requires the control parameters:

NHRU Lnk BSFF FVF

Requires the flux sequence:

SFF

Calculates the flux sequence:

FVG

Basic equation:

\(FVG = min\bigl(FVF \cdot SFF^{BSFF}, 1\bigl)\)

Examples:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(7)
>>> lnk(VERS, WASSER, FLUSS, SEE, ACKER, ACKER, ACKER)
>>> fvf(0.8)
>>> bsff(2.0)
>>> fluxes.sff(1.0, 1.0, 1.0, 1.0, 0.0, 0.5, 1.0)
>>> model.calc_fvg_v1()
>>> fluxes.fvg
fvg(0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.8)

The calculated degree of frost sealing does never exceed one, even when defining FVF values larger one:

>>> fvf(1.6)
>>> model.calc_fvg_v1()
>>> fluxes.fvg
fvg(0.0, 0.0, 0.0, 0.0, 0.0, 0.4, 1.0)
class hydpy.models.lland.lland_model.Calc_EvB_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the actual soil evapotranspiration.

Requires the control parameters:

NHRU Lnk WMax GrasRef_R

Requires the flux sequences:

EvPo EvI

Requires the state sequence:

BoWa

Calculates the flux sequence:

EvB

Basic equations:

\(EvB = (EvPo - EvI) \cdot \frac{1 - temp}{1 + temp -2 \cdot exp(-GrasRef_R)}\)

\(temp = exp\left(-GrasRef_R \cdot \frac{BoWa}{WMax}\right)\)

Examples:

Soil evapotranspiration is calculated neither for water nor for sealed areas (see the first three hydrological reponse units of type FLUSS, SEE, and VERS). All other land use classes are handled in accordance with a recommendation of the set of codes described in DVWK-M 504 [15]. In case maximum soil water storage (WMax) is zero, soil evaporation (EvB) is generally set to zero (see the fourth hydrological response unit). The last three response units demonstrate the rise in soil evaporation with increasing soil moisture, which is lessening in the high soil moisture range:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(7)
>>> lnk(FLUSS, SEE, VERS, ACKER, ACKER, ACKER, ACKER)
>>> grasref_r(5.0)
>>> wmax(100.0, 100.0, 100.0, 0.0, 100.0, 100.0, 100.0)
>>> fluxes.evpo = 5.0
>>> fluxes.evi = 3.0
>>> states.bowa = 50.0, 50.0, 50.0, 0.0, 0.0, 50.0, 100.0
>>> model.calc_evb_v1()
>>> fluxes.evb
evb(0.0, 0.0, 0.0, 0.0, 0.0, 1.717962, 2.0)
class hydpy.models.lland.lland_model.Calc_DryAirPressure_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the pressure of the dry air (based on [10]).

Requires the control parameter:

NHRU

Requires the input sequence:

AtmosphericPressure

Requires the flux sequence:

ActualVapourPressure

Calculates the flux sequence:

DryAirPressure

Basic equation:

\(DryAirPressure = AirPressure - ActualVapourPressure\)

Example:
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> fluxes.actualvapourpressure = 0.9, 1.1, 2.5
>>> inputs.atmosphericpressure = 120.0
>>> model.calc_dryairpressure_v1()
>>> fluxes.dryairpressure
dryairpressure(119.1, 118.9, 117.5)
class hydpy.models.lland.lland_model.Calc_DensityAir_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the density of the air (based on [10]).

Requires the control parameter:

NHRU

Requires the fixed parameters:

RDryAir RWaterVapour

Requires the flux sequences:

ActualVapourPressure DryAirPressure TKor

Calculates the flux sequence:

DensityAir

Basic equation:

\(DensityAir = \frac{DryAirPressure}{RDryAir \cdot (TKor+273.15)} + \frac{ActualVapourPressure}{RWaterVapour \cdot (TKor+273.15)}\)

Example:
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> fluxes.dryairpressure = 119.1, 100.0, 115.0
>>> fluxes.actualvapourpressure = 0.8, 0.7, 1.0
>>> fluxes.tkor = 10.0, 12.0, 14.0
>>> model.calc_densityair_v1()
>>> fluxes.densityair
densityair(1.471419, 1.226998, 1.402691)
class hydpy.models.lland.lland_model.Calc_AerodynamicResistance_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the aerodynamic resistance [4] (based on [7]).

Requires the control parameters:

NHRU Lnk CropHeight

Requires the derived parameter:

MOY

Requires the flux sequence:

WindSpeed10m

Calculates the flux sequence:

AerodynamicResistance

Basic equations (\(z_0\) after Quast and Boehm, 1997):
\[\begin{split}AerodynamicResistance = \begin{cases} \frac{6.25}{WindSpeed10m} \cdot ln\left(\frac{10}{z_0}\right)^2 &|\ z_0 < 10 \\ \frac{94}{WindSpeed10m} &|\ z_0 \geq 10 \end{cases}\end{split}\]

\(z_0 = 0.021 + 0.163 \cdot CropHeight\)

Examples:

Besides wind speed, aerodynamic resistance depends on the crop height, which typically varies between different landuse-use classes and, for vegetated surfaces, months. In the first example, we set some different crop heights for different landuse-use types to cover the relevant range of values:

>>> from hydpy import pub
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(5)
>>> lnk(WASSER, ACKER, OBSTB, LAUBW, NADELW)
>>> pub.timegrids = "2000-01-30", "2000-02-03", "1d"
>>> derived.moy.update()
>>> cropheight.wasser_jan = 0.0
>>> cropheight.acker_jan = 1.0
>>> cropheight.obstb_jan = 5.0
>>> cropheight.laubw_jan = 10.0
>>> cropheight.nadelw_jan = 15.0
>>> fluxes.windspeed10m = 3.0
>>> model.idx_sim = 1
>>> model.calc_aerodynamicresistance_v1()
>>> fluxes.aerodynamicresistance
aerodynamicresistance(79.202731, 33.256788, 12.831028, 31.333333,
                      31.333333)

The last example shows an decrease in resistance for increasing crop height for the first three hydrological response units only. When reaching a crop height of 10 m, the calculated resistance increases discontinously (see the fourth response unit) and then remains constant (see the fifth response unit). In the next example, we set some unrealistic values, to inspect this behaviour more closely:

>>> cropheight.wasser_feb = 8.0
>>> cropheight.acker_feb = 9.0
>>> cropheight.obstb_feb = 10.0
>>> cropheight.laubw_feb = 11.0
>>> cropheight.nadelw_feb = 12.0
>>> model.idx_sim = 2
>>> model.calc_aerodynamicresistance_v1()
>>> fluxes.aerodynamicresistance
aerodynamicresistance(8.510706, 7.561677, 31.333333, 31.333333,
                      31.333333)

To get rid of this jump, one could use a threshold crop height of 1.14 m instead of 10 m for the selection of the two underlying equations:

\(1.1404411695422059 = \frac{\frac{10}{\exp(\sqrt{94/6.25}}-0.021}{0.163}\)

The last example shows the inverse relationship between resistance and wind speed. For zero wind speed, resistance becomes infinite:

>>> from hydpy import print_values
>>> cropheight(2.0)
>>> for ws in (0.0, 0.1, 1.0, 10.0):
...     fluxes.windspeed10m = ws
...     model.calc_aerodynamicresistance_v1()
...     print_values([ws, fluxes.aerodynamicresistance[0]])
0.0, inf
0.1, 706.026613
1.0, 70.602661
10.0, 7.060266
class hydpy.models.lland.lland_model.Calc_SoilSurfaceResistance_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the surface resistance of the bare soil surface [4] (based on [7]).

Requires the control parameters:

NHRU Lnk PWP

Requires the derived parameter:

NFk

Requires the state sequence:

BoWa

Calculates the flux sequence:

SoilSurfaceResistance

Basic equation:
\[\begin{split}SoilSurfaceResistance = \begin{cases} 100 &|\ NFk > 20 \\ \frac{100 \cdot NFk}{max(BoWa-PWP, 0) + NFk/100} &|\ NFk \geq 20 \end{cases}\end{split}\]

Examples:

Water areas and sealed surfaces do not posses a soil, which is why we set the soil surface resistance to nan:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(4)
>>> lnk(VERS, WASSER, FLUSS, SEE)
>>> fk(0.0)
>>> pwp(0.0)
>>> derived.nfk.update()
>>> states.bowa = 0.0
>>> model.calc_soilsurfaceresistance_v1()
>>> fluxes.soilsurfaceresistance
soilsurfaceresistance(nan, nan, nan, nan)

For “typical” soils, which posses an available field capacity larger than 20 mm, we set the soil surface resistance to 100.0 s/m:

>>> lnk(ACKER)
>>> fk(20.1, 30.0, 40.0, 40.0)
>>> pwp(0.0, 0.0, 10.0, 10.0)
>>> derived.nfk.update()
>>> states.bowa = 0.0, 20.0, 5.0, 30.0
>>> model.calc_soilsurfaceresistance_v1()
>>> fluxes.soilsurfaceresistance
soilsurfaceresistance(100.0, 100.0, 100.0, 100.0)

For all soils with smaller actual field capacities, resistance is 10’000 s/m as long as the soil water content does not exceed the permanent wilting point:

>>> pwp(0.1, 20.0, 20.0, 30.0)
>>> derived.nfk.update()
>>> states.bowa = 0.0, 10.0, 20.0, 30.0
>>> model.calc_soilsurfaceresistance_v1()
>>> fluxes.soilsurfaceresistance
soilsurfaceresistance(10000.0, 10000.0, 10000.0, 10000.0)

With increasing soil water contents, resistance decreases and reaches a value of 99 s/m:

>>> pwp(0.0)
>>> fk(20.0)
>>> derived.nfk.update()
>>> states.bowa = 5.0, 10.0, 15.0, 20.0
>>> model.calc_soilsurfaceresistance_v1()
>>> fluxes.soilsurfaceresistance
soilsurfaceresistance(384.615385, 196.078431, 131.578947, 99.009901)

>>> fk(50.0)
>>> pwp(40.0)
>>> derived.nfk.update()
>>> states.bowa = 42.5, 45.0, 47.5, 50.0
>>> model.calc_soilsurfaceresistance_v1()
>>> fluxes.soilsurfaceresistance
soilsurfaceresistance(384.615385, 196.078431, 131.578947, 99.009901)

For zero field capacity, we set the soil surface resistance to zero:

>>> pwp(0.0)
>>> fk(0.0)
>>> derived.nfk.update()
>>> states.bowa = 0.0
>>> model.calc_soilsurfaceresistance_v1()
>>> fluxes.soilsurfaceresistance
soilsurfaceresistance(inf, inf, inf, inf)
class hydpy.models.lland.lland_model.Calc_LanduseSurfaceResistance_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the surface resistance of vegetation, water and sealed areas. [4] (based on [7])

Requires the control parameters:

NHRU Lnk SurfaceResistance PY

Requires the derived parameter:

MOY

Requires the flux sequences:

TKor SaturationVapourPressure ActualVapourPressure

Requires the state sequence:

BoWa

Calculates the flux sequence:

LanduseSurfaceResistance

Basic equations:

\(LanduseSurfaceResistance = SR^* \cdot \left(3.5 \cdot \left(1 - \frac{min(BoWa, PY)}{PY}\right) + exp\left(\frac{0.2 \cdot PY}{max(BoWa, 0)}\right)\right)\)

\[\begin{split}SR^* = \begin{cases} SurfaceResistance &|\ Lnk \neq NADELW \\ 10\,000 &|\ Lnk = NADELW \;\; \land \;\; (TKor \leq -5 \;\; \lor \;\; \Delta \geq 2) \\ min\left(\frac{25 \cdot SurfaceResistance}{(TKor + 5) \cdot (1 - \Delta/2)}, 10\,000\right) &|\ Lnk = NADELW \;\; \land \;\; (-5 < TKor < 20 \;\; \land \;\; \Delta < 2) \\ min\left(\frac{SurfaceResistance}{(1 - \Delta/2)}, 10\,000\right) &|\ Lnk = NADELW \;\; \land \;\; (20 \leq TKor \;\; \land \;\; \Delta < 2) \end{cases}\end{split}\]

\(\Delta = SaturationVapourPressure - ActualVapourPressure\)

Example:

Method Calc_LanduseSurfaceResistance_V1 relies on multiple discontinuous relationships, works different for different types of landuse-use, and uses montly varying base parameters. Hence, we try to start simple and introduce further complexities step by step.

For sealed surfaces and water areas the original parameter values are in effect without any modification:

>>> from hydpy import pub
>>> pub.timegrids = "2000-05-30", "2000-06-03", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(4)
>>> lnk(VERS, FLUSS, SEE, WASSER)
>>> surfaceresistance.fluss_mai = 0.0
>>> surfaceresistance.see_mai = 0.0
>>> surfaceresistance.wasser_mai = 0.0
>>> surfaceresistance.vers_mai = 500.0
>>> derived.moy.update()
>>> model.idx_sim = 1
>>> model.calc_landusesurfaceresistance_v1()
>>> fluxes.landusesurfaceresistance
landusesurfaceresistance(500.0, 0.0, 0.0, 0.0)

For all “soil areas”, we sligthly increase the original parameter value by a constant factor for wet soils (BoWa > PY) and increase it even more for dry soils (BoWa > PY). For a completely dry soil, surface resistance becomes infinite:

>>> lnk(ACKER)
>>> py(0.0)
>>> surfaceresistance.acker_jun = 40.0
>>> states.bowa = 0.0, 10.0, 20.0, 30.0
>>> model.idx_sim = 2
>>> model.calc_landusesurfaceresistance_v1()
>>> fluxes.landusesurfaceresistance
landusesurfaceresistance(inf, 48.85611, 48.85611, 48.85611)

>>> py(20.0)
>>> model.calc_landusesurfaceresistance_v1()
>>> fluxes.landusesurfaceresistance
landusesurfaceresistance(inf, 129.672988, 48.85611, 48.85611)

>>> states.bowa = 17.0, 18.0, 19.0, 20.0
>>> model.calc_landusesurfaceresistance_v1()
>>> fluxes.landusesurfaceresistance
landusesurfaceresistance(71.611234, 63.953955, 56.373101, 48.85611)

Only for coniferous trees, we further increase surface resistance for low temperatures and high water vapour pressure deficits. The highest resistance value results from air temperatures lower than -5 °C or vapour deficits higher than 2 kPa:

>>> lnk(NADELW)
>>> surfaceresistance.nadelw_jun = 80.0
>>> states.bowa = 20.0
>>> fluxes.tkor = 30.0
>>> fluxes.saturationvapourpressure = 3.0
>>> fluxes.actualvapourpressure = 0.0, 1.0, 2.0, 3.0
>>> model.calc_landusesurfaceresistance_v1()
>>> fluxes.landusesurfaceresistance
landusesurfaceresistance(12214.027582, 12214.027582, 195.424441,
                         97.712221)

>>> fluxes.actualvapourpressure = 1.0, 1.01, 1.1, 1.2
>>> model.calc_landusesurfaceresistance_v1()
>>> fluxes.landusesurfaceresistance
landusesurfaceresistance(12214.027582, 12214.027582, 1954.244413,
                         977.122207)

>>> fluxes.actualvapourpressure = 2.0
>>> fluxes.tkor = -10.0, 5.0, 20.0, 35.0
>>> model.calc_landusesurfaceresistance_v1()
>>> fluxes.landusesurfaceresistance
landusesurfaceresistance(12214.027582, 488.561103, 195.424441,
                         195.424441)

>>> fluxes.tkor = -6.0, -5.0, -4.0, -3.0
>>> model.calc_landusesurfaceresistance_v1()
>>> fluxes.landusesurfaceresistance
landusesurfaceresistance(12214.027582, 12214.027582, 4885.611033,
                         2442.805516)

>>> fluxes.tkor = 18.0, 19.0, 20.0, 21.0
>>> model.calc_landusesurfaceresistance_v1()
>>> fluxes.landusesurfaceresistance
landusesurfaceresistance(212.417871, 203.567126, 195.424441, 195.424441)
class hydpy.models.lland.lland_model.Calc_ActualSurfaceResistance_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the total surface resistance. [4] (based on [11])

Requires the control parameters:

NHRU Lnk LAI

Requires the derived parameters:

MOY Hours

Requires the flux sequences:

SoilSurfaceResistance LanduseSurfaceResistance PossibleSunshineDuration

Calculates the flux sequence:

ActualSurfaceResistance

Basic equations:

\(ActualSurfaceResistance = \left(w \cdot \frac{1}{SRD} + (1-w) \cdot \frac{1}{SRN}\right)^{-1}\)

\(SRD = \left(\frac{1-0.7^{LAI}}{LanduseSurfaceResistance} + \frac{0.7^{LAI}}{SoilSurfaceResistance}\right)^{-1}\)

\(SRN = \left(\frac{LAI}{2500} + \frac{1}{SoilSurfaceResistance}\right)^{-1}\)

\(w = \frac{PossibleSunshineDuration}{Hours}\)

Examples:

For sealed surfaces and water areas, method Calc_ActualSurfaceResistance_V1 just uses the values of sequence LanduseSurfaceResistance as the effective surface resistance values:

>>> from hydpy import pub
>>> pub.timegrids = "2019-05-30", "2019-06-03", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(4)
>>> lnk(VERS, FLUSS, SEE, WASSER)
>>> derived.moy.update()
>>> derived.hours.update()
>>> fluxes.soilsurfaceresistance = nan
>>> fluxes.landusesurfaceresistance = 500.0, 0.0, 0.0, 0.0
>>> model.idx_sim = 1
>>> model.calc_actualsurfaceresistance_v1()
>>> fluxes.actualsurfaceresistance
actualsurfaceresistance(500.0, 0.0, 0.0, 0.0)

For all other landuse types, the final soil resistance is a combination of LanduseSurfaceResistance and SoilSurfaceResistance that depends on the leaf area index. We demonstrate this for the landuse types ACKER, OBSTB, LAUBW, and NADELW, for which we define different leaf area indices:

>>> lnk(ACKER, OBSTB, LAUBW, NADELW)
>>> lai.acker_mai = 0.0
>>> lai.obstb_mai = 2.0
>>> lai.laubw_mai = 5.0
>>> lai.nadelw_mai = 10.0

The soil and landuse surface resistance are identical for all four hydrological response units:

>>> fluxes.soilsurfaceresistance = 200.0
>>> fluxes.landusesurfaceresistance = 100.0

When we assume that the sun shines the whole day, the final resistance is identical with the soil surface resistance for zero leaf area indices (see the first response unit) and becomes closer to landuse surface resistance for when the leaf area index increases:

>>> fluxes.possiblesunshineduration = 24.0
>>> model.calc_actualsurfaceresistance_v1()
>>> fluxes.actualsurfaceresistance
actualsurfaceresistance(200.0, 132.450331, 109.174477, 101.43261)

For a polar night, there is a leaf area index-dependend interpolation between soil surface resistance and a fixed resistance value:

>>> fluxes.possiblesunshineduration = 0.0
>>> model.calc_actualsurfaceresistance_v1()
>>> fluxes.actualsurfaceresistance
actualsurfaceresistance(200.0, 172.413793, 142.857143, 111.111111)

For all days that are not polar nights or polar days, the values of the two examples above are weighted based on the possible sunshine duration of that day:

>>> fluxes.possiblesunshineduration = 12.0
>>> model.calc_actualsurfaceresistance_v1()
>>> fluxes.actualsurfaceresistance
actualsurfaceresistance(200.0, 149.812734, 123.765057, 106.051498)

The following examples demonstrate that method Calc_ActualSurfaceResistance_V1 works similar when applied on an hourly time basis during the daytime period (first example), during the nighttime (second example), and during dawn or dusk (third example):

>>> pub.timegrids = "2019-05-31 22:00", "2019-06-01 03:00", "1h"
>>> nhru(1)
>>> lnk(NADELW)
>>> fluxes.soilsurfaceresistance = 200.0
>>> fluxes.landusesurfaceresistance = 100.0
>>> derived.moy.update()
>>> derived.hours.update()
>>> lai.nadelw_jun = 5.0
>>> model.idx_sim = 2
>>> fluxes.possiblesunshineduration = 1.0
>>> model.calc_actualsurfaceresistance_v1()
>>> fluxes.actualsurfaceresistance
actualsurfaceresistance(109.174477)

>>> fluxes.possiblesunshineduration = 0.0
>>> model.calc_actualsurfaceresistance_v1()
>>> fluxes.actualsurfaceresistance
actualsurfaceresistance(142.857143)

>>> fluxes.possiblesunshineduration = 0.5
>>> model.calc_actualsurfaceresistance_v1()
>>> fluxes.actualsurfaceresistance
actualsurfaceresistance(123.765057)
class hydpy.models.lland.lland_model.Return_Penman_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the evaporation from water surfaces according to Penman [4] (based on [12]).

Required by the method:

Calc_EvPo_V2

Requires the derived parameter:

Days

Requires the fixed parameters:

LW Psy

Requires the flux sequences:

DailySaturationVapourPressureSlope DailyNetRadiation DailyWindSpeed2m DailySaturationVapourPressure DailyActualVapourPressure

Basic equation:

\(Days \cdot \frac{DailySaturationVapourPressureSlope \cdot \frac{DailyNetRadiation}{LW} + Psy \cdot (1.3 + 0.94 \cdot DailyWindSpeed2m) \cdot (DailySaturationVapourPressure-DailyActualVapourPressure)} {DailySaturationVapourPressureSlope + Psy}\)

Examples:

We initialise seven hydrological response units. In reponse units one to three, evaporation is due to radiative forcing only. In response units four to six, evaporation is due to aerodynamic forcing only. Response unit seven shows the combined effect of both forces:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep()
>>> nhru(7)
>>> derived.days.update()
>>> fluxes.dailynetradiation = 0.0, 3.5, 7.0, 0.0, 0.0, 0.0, 7.0
>>> fluxes.dailywindspeed2m = 2.0
>>> fluxes.dailysaturationvapourpressure = 1.2
>>> fluxes.dailysaturationvapourpressureslope = 0.08
>>> fluxes.dailyactualvapourpressure = 1.2, 1.2, 1.2, 1.2, 0.6, 0.0, 0.0
>>> from hydpy import print_values
>>> for hru in range(7):
...     deficit = (fluxes.dailysaturationvapourpressure[hru] -
...                fluxes.dailyactualvapourpressure[hru])
...     print_values([fluxes.dailynetradiation[hru],
...                   deficit,
...                   model.return_penman_v1(hru)])
0.0, 0.0, 0.0
3.5, 0.0, 0.781513
7.0, 0.0, 1.563027
0.0, 0.0, 0.0
0.0, 0.6, 0.858928
0.0, 1.2, 1.717856
7.0, 1.2, 3.280882

The above results apply for a daily simulation time step. The following example demonstrates that we get equivalent results for hourly time steps:

>>> simulationstep("1h")
>>> derived.days.update()
>>> for hru in range(7):
...     deficit = (fluxes.dailysaturationvapourpressure[hru] -
...                fluxes.dailyactualvapourpressure[hru])
...     print_values([fluxes.dailynetradiation[hru],
...                   deficit,
...                   24*model.return_penman_v1(hru)])
0.0, 0.0, 0.0
3.5, 0.0, 0.781513
7.0, 0.0, 1.563027
0.0, 0.0, 0.0
0.0, 0.6, 0.858928
0.0, 1.2, 1.717856
7.0, 1.2, 3.280882
class hydpy.models.lland.lland_model.Return_PenmanMonteith_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate and return the evapotranspiration according to Penman-Monteith. [4] (based on [7])

Required by the methods:

Calc_EvB_V2 Calc_EvPo_V2

Requires the control parameter:

Emissivity

Requires the derived parameter:

Seconds

Requires the fixed parameters:

Sigma LW CPLuft Psy

Requires the flux sequences:

NetRadiation G TKor SaturationVapourPressureSlope SaturationVapourPressure ActualVapourPressure DensityAir AerodynamicResistance

Basic equations:

\(\frac{SaturationVapourPressureSlope \cdot (NetRadiation + G) + Seconds \cdot C \cdot DensitiyAir \cdot CPLuft \cdot \frac{SaturationVapourPressure - ActualVapourPressure} {AerodynamicResistance^*}} {LW \cdot (SaturationVapourPressureSlope + Psy \cdot C \cdot (1 + \frac{actualsurfaceresistance}{AerodynamicResistance^*}))}\)

\(C = 1 + \frac{b' \cdot AerodynamicResistance^*}{DensitiyAir \cdot CPLuft}\)

\(b' = 4 \cdot Emissivity \cdot \frac{Sigma}{60 \cdot 60 \cdot 24} \cdot (273.15 + TKor)^3\)

\(AerodynamicResistance^* = min\Bigl(max\bigl(AerodynamicResistance, 10^{-6}\bigl), 10^6\Bigl)\)

Correction factor C takes the difference between measured temperature and actual surface temperature into account.

Example:

We build the following example on the first example of the documentation on method Return_Penman_V1. The total available energy (NetRadiation plus G) and the vapour saturation pressure deficit (SaturationVapourPressure minus ActualVapourPressure are identical. To make the results roughly comparable, we use resistances suitable for water surfaces through setting ActualSurfaceResistance to zero and AerodynamicResistance to a reasonable precalculated value of 106 s/m:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep()
>>> nhru(7)
>>> emissivity(0.96)
>>> derived.seconds.update()
>>> fluxes.netradiation = 1.0, 4.5, 8.0, 1.0, 1.0, 1.0, 8.0
>>> fluxes.g = -1.0
>>> fluxes.saturationvapourpressure = 1.2
>>> fluxes.saturationvapourpressureslope = 0.08
>>> fluxes.actualvapourpressure = 1.2, 1.2, 1.2, 1.2, 0.6, 0.0, 0.0
>>> fluxes.densityair = 1.24
>>> fluxes.actualsurfaceresistance = 0.0
>>> fluxes.aerodynamicresistance = 106.0
>>> fluxes.tkor = 10.0

For the first three hydrological response units with energy forcing only, there is a relatively small deviation to the results of method Return_Penman_V1 due to the correction factor C, which is only implemented by method Return_PenmanMonteith_V1. For response units four to six with dynamic forcing only, the results of method Return_PenmanMonteith_V1 are more than twice as large as those of method Return_Penman_V1:

>>> from hydpy import print_values
>>> for hru in range(7):
...     deficit = (fluxes.saturationvapourpressure[hru] -
...                fluxes.actualvapourpressure[hru])
...     print_values([fluxes.netradiation[hru]+fluxes.g[hru],
...                   deficit,
...                   model.return_penmanmonteith_v1(
...                       hru, fluxes.actualsurfaceresistance[hru])])
0.0, 0.0, 0.0
3.5, 0.0, 0.657142
7.0, 0.0, 1.314284
0.0, 0.0, 0.0
0.0, 0.6, 2.031724
0.0, 1.2, 4.063447
7.0, 1.2, 5.377732

Next, we repeat the above calculations using resistances relevant for vegetated surfaces (note that this also changes the results of the first three response units due to correction factor C depending on AerodynamicResistance):

>>> fluxes.actualsurfaceresistance = 80.0
>>> fluxes.aerodynamicresistance = 40.0
>>> for hru in range(7):
...     deficit = (fluxes.saturationvapourpressure[hru] -
...                fluxes.actualvapourpressure[hru])
...     print_values([fluxes.netradiation[hru]+fluxes.g[hru],
...                   deficit,
...                   model.return_penmanmonteith_v1(
...                       hru, fluxes.actualsurfaceresistance[hru])])
0.0, 0.0, 0.0
3.5, 0.0, 0.36958
7.0, 0.0, 0.739159
0.0, 0.0, 0.0
0.0, 0.6, 2.469986
0.0, 1.2, 4.939972
7.0, 1.2, 5.679131

The above results are sensitive to the relation of ActualSurfaceResistance and AerodynamicResistance. The following example demonstrates this sensitivity through varying ActualSurfaceResistance over a wide range:

>>> fluxes.netradiation = 8.0
>>> fluxes.actualvapourpressure = 0.0
>>> fluxes.actualsurfaceresistance = (
...     0.0, 20.0, 50.0, 100.0, 200.0, 500.0, 1000.0)
>>> for hru in range(7):
...     print_values([fluxes.actualsurfaceresistance[hru],
...                   model.return_penmanmonteith_v1(
...                       hru, fluxes.actualsurfaceresistance[hru])])
0.0, 11.208588
20.0, 9.014385
50.0, 6.968226
100.0, 5.055617
200.0, 3.263897
500.0, 1.581954
1000.0, 0.851033

One potential pitfall of the given Penman-Monteith equation is that AerodynamicResistance becomes infinite for zero windspeed. We protect method Return_PenmanMonteith_V1 against this problem (and the less likely problem of zero aerodynamic resistance) by limiting the value of AerodynamicResistance to the interval \([10^{-6}, 10^6]\):

>>> fluxes.actualvapourpressure = 0.6
>>> fluxes.actualsurfaceresistance = 80.0
>>> fluxes.aerodynamicresistance = (
...     0.0, 1e-6, 1e-3, 1.0, 1e3, 1e6, inf)
>>> for hru in range(7):
...     print_values([fluxes.aerodynamicresistance[hru],
...                   model.return_penmanmonteith_v1(
...                       hru, fluxes.actualsurfaceresistance[hru])])
0.0, 5.00683
0.000001, 5.00683
0.001, 5.006734
1.0, 4.91391
1000.0, 0.829364
1000000.0, 0.001275
inf, 0.001275

Now we change the simulation time step from one day to one hour to demonstrate that we can reproduce the results of the first example, which requires to adjust NetRadiation and WG:

>>> simulationstep("1h")
>>> derived.seconds.update()
>>> fluxes.netradiation = 1.0, 4.5, 8.0, 1.0, 1.0, 1.0, 8.0
>>> fluxes.netradiation /= 24
>>> fluxes.g = -1.0/24
>>> fluxes.actualvapourpressure = 1.2, 1.2, 1.2, 1.2, 0.6, 0.0, 0.0
>>> fluxes.actualsurfaceresistance = 0.0
>>> fluxes.aerodynamicresistance = 106.0
>>> for hru in range(7):
...     deficit = (fluxes.saturationvapourpressure[hru] -
...                fluxes.actualvapourpressure[hru])
...     print_values([24*(fluxes.netradiation[hru]+fluxes.g[hru]),
...                   deficit,
...                   24*model.return_penmanmonteith_v1(
...                       hru, fluxes.actualsurfaceresistance[hru])])
0.0, 0.0, 0.0
3.5, 0.0, 0.657142
7.0, 0.0, 1.314284
0.0, 0.0, 0.0
0.0, 0.6, 2.031724
0.0, 1.2, 4.063447
7.0, 1.2, 5.377732
class hydpy.models.lland.lland_model.Calc_EvPo_V2[source]

Bases: hydpy.core.modeltools.Method

Calculate the potential evaporation according to Penman or Penman-Monteith.

Required submethods:

Return_Penman_V1 Return_PenmanMonteith_V1

Requires the control parameters:

NHRU Lnk Emissivity

Requires the derived parameters:

Days Seconds

Requires the fixed parameters:

Sigma LW CPLuft Psy

Requires the flux sequences:

NetRadiation G TKor SaturationVapourPressureSlope SaturationVapourPressure ActualVapourPressure DensityAir AerodynamicResistance DailySaturationVapourPressureSlope DailyNetRadiation DailyWindSpeed2m DailySaturationVapourPressure DailyActualVapourPressure

Calculates the flux sequence:

EvPo

Method Calc_EvPo_V2 applies method Return_Penman_V1 on all water areas and method Return_PenmanMonteith_V1 on all other hydrological response units. For Penman-Monteith, we yield potential values by passing zero surface resistance values to method Return_PenmanMonteith_V1.

Example:

We recalculate the results for the seventh hydrological response unit of the first example of the documention on the methods Return_Penman_V1 and Return_PenmanMonteith_V1. The calculated potential values differ markedly:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep()
>>> nhru(2)
>>> lnk(WASSER, ACKER)
>>> emissivity(0.96)
>>> derived.nmblogentries.update()
>>> derived.seconds.update()
>>> derived.days.update()
>>> fluxes.netradiation = 8.0
>>> fluxes.dailynetradiation = 7.0
>>> fluxes.saturationvapourpressure = 1.2
>>> fluxes.dailysaturationvapourpressure = 1.2
>>> fluxes.saturationvapourpressureslope = 0.08
>>> fluxes.dailysaturationvapourpressureslope = 0.08
>>> fluxes.actualvapourpressure = 0.0
>>> fluxes.dailyactualvapourpressure = 0.0
>>> fluxes.windspeed2m = 2.0
>>> fluxes.dailywindspeed2m = 2.0
>>> fluxes.tkor = 10.0
>>> fluxes.g = -1.0
>>> fluxes.densityair = 1.24
>>> fluxes.aerodynamicresistance = 106.0
>>> model.calc_evpo_v2()
>>> fluxes.evpo
evpo(3.280882, 5.377732)
class hydpy.models.lland.lland_model.Calc_EvS_WAeS_WATS_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the evaporation from the snow layer, if any exists, and update the snow cover accordingly.

Requires the control parameters:

NHRU Lnk

Requires the fixed parameter:

LWE

Requires the flux sequence:

WLatSnow

Updates the state sequences:

WAeS WATS

Calculates the flux sequence:

EvS

Basic equations:

\(WAeS_{new} = f \cdot WAeS_{old}\)

\(WATS_{new} = f \cdot WATS_{old}\)

\(f = \frac{WAeS-EvS}{WAeS}\)

\(EvS = max\left(\frac{WLatSnow}{L}, WAeS\right)\)

Example:

The first hydrological response unit shows that method Calc_EvS_WAeS_WATS_V1 does calculate condensation and deposition if a negative flux of latent heat suggests so. We define the relative amounts of condensation and deposition so that the fraction between the frozen and the total water content of the snow layer does not change. The same holds for vaporisation and sublimation, as shown by response units to to seven. Note that method Calc_EvS_WAeS_WATS_V1 prevents negative water contents but does not prevent to high liquid water contents, which eventually needs to be corrected by another method called subsequentially. The last response unit shows that method Calc_EvS_WAeS_WATS_V1 sets EvS, WATS and WAeS to zero for water areas:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(8)
>>> lnk(ACKER, ACKER, ACKER, ACKER, ACKER, ACKER, ACKER, WASSER)
>>> fluxes.wlatsnow = -1.0, 0.0, 2.0, 4.0, 6.0, 6.0, 6.0, 6.0
>>> states.waes = 2.0, 2.0, 2.0, 2.0, 2.0, 1.5, 0.0, 2.0
>>> states.wats = 1.0, 1.0, 1.0, 1.0, 1.0, 0.5, 0.0, 1.0
>>> model.calc_evs_waes_wats_v1()
>>> fluxes.evs
evs(-0.37489, 0.0, 0.74978, 1.49956, 2.0, 1.5, 0.0, 0.0)
>>> states.waes
waes(2.37489, 2.0, 1.25022, 0.50044, 0.0, 0.0, 0.0, 0.0)
>>> states.wats
wats(1.187445, 1.0, 0.62511, 0.25022, 0.0, 0.0, 0.0, 0.0)
class hydpy.models.lland.lland_model.Calc_EvI_Inzp_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate interception evaporation and update the interception storage accordingly.

Requires the control parameters:

NHRU Lnk

Requires the flux sequence:

EvPo

Updates the state sequence:

Inzp

Calculates the flux sequence:

EvI

Basic equation:

\(\frac{dInzp}{dt} = -EvI\)

\[\begin{split}EvI = \begin{cases} EvPo &|\ Inzp > 0 \\ 0 &|\ Inzp = 0 \end{cases}\end{split}\]

Examples:

For all “land response units” like arable land (ACKER), interception evaporation (EvI) is identical with potential evapotranspiration (EvPo) as long as it is met by available intercepted water (Inzp):

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(3)
>>> lnk(ACKER)
>>> states.inzp = 0.0, 2.0, 4.0
>>> fluxes.evpo = 3.0
>>> model.calc_evi_inzp_v1()
>>> states.inzp
inzp(0.0, 0.0, 1.0)
>>> fluxes.evi
evi(0.0, 2.0, 3.0)

For water areas (WASSER, FLUSS and SEE), EvI is generally equal to EvPo (but this might be corrected by a method called after Calc_EvI_Inzp_V1 has been applied) and Inzp is set to zero:

>>> lnk(WASSER, FLUSS, SEE)
>>> states.inzp = 2.0
>>> fluxes.evpo = 3.0
>>> model.calc_evi_inzp_v1()
>>> states.inzp
inzp(0.0, 0.0, 0.0)
>>> fluxes.evi
evi(3.0, 3.0, 3.0)
class hydpy.models.lland.lland_model.Calc_EvI_Inzp_V2[source]

Bases: hydpy.core.modeltools.Method

Calculate interception evaporation and update the interception storage accordingly.

Requires the control parameters:

NHRU Lnk

Requires the flux sequence:

EvPo

Requires the state sequence:

WAeS

Updates the state sequence:

Inzp

Calculates the flux sequence:

EvI

Basic equation:

\(\frac{dInzp}{dt} = -EvI\)

\[\begin{split}EvI = \begin{cases} EvPo &|\ Inzp > 0 \land ( Forest \lor WAeS = 0 ) \\ 0 &|\ Inzp = 0 \lor ( \lnot Forest \land WAeS > 0 ) \end{cases}\end{split}\]

Examples:

For all forest land-use types (LAUBW, MISCHW, NADELW), interception evaporation (EvI) is identical with potential evapotranspiration (EvPo) as long as it is met by available intercepted water (Inzp):

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(3)
>>> lnk(LAUBW, MISCHW, NADELW)
>>> states.inzp = 0.0, 2.0, 4.0
>>> states.waes = 0.0, 0.0, 1.0
>>> fluxes.evpo = 3.0
>>> model.calc_evi_inzp_v2()
>>> states.inzp
inzp(0.0, 0.0, 1.0)
>>> fluxes.evi
evi(0.0, 2.0, 3.0)

For all other land areas, no interception evaporation occurs when a snow cover is present (indicated by a WAeS values larger zero):

>>> lnk(ACKER)
>>> states.inzp = 0.0, 2.0, 4.0
>>> model.calc_evi_inzp_v2()
>>> states.inzp
inzp(0.0, 0.0, 4.0)
>>> fluxes.evi
evi(0.0, 2.0, 0.0)

For water areas (WASSER, FLUSS and SEE), EvI is generally equal to EvPo (but this might be corrected by a method called after Calc_EvI_Inzp_V2 has been applied) and Inzp is set to zero:

>>> lnk(WASSER, FLUSS, SEE)
>>> states.inzp = 2.0
>>> fluxes.evpo = 3.0
>>> model.calc_evi_inzp_v1()
>>> states.inzp
inzp(0.0, 0.0, 0.0)
>>> fluxes.evi
evi(3.0, 3.0, 3.0)
class hydpy.models.lland.lland_model.Calc_EvI_Inzp_V3[source]

Bases: hydpy.core.modeltools.Method

Calculate interception evaporation and update the interception storage accordingly if the snow interception storage is empty.

Requires the control parameters:

NHRU Lnk

Requires the flux sequence:

EvPo

Requires the state sequences:

SInz WAeS

Updates the state sequence:

Inzp

Calculates the flux sequence:

EvI

Basic equation:

\(\frac{dInzp}{dt} = -EvI\)

\[\begin{split}EvI = \begin{cases} EvPo &|\ Inzp > 0 \land \big( ( Forest \land SInz = 0 ) \lor ( \lnot Forest \land WAeS = 0 ) \big) \\ 0 &|\ Inzp = 0 \lor \big( ( Forest \land SInz > 0) \lor ( \lnot Forest \land WAeS > 0 ) \big) \end{cases}\end{split}\]

Examples:

For all forest land-use types (LAUBW, MISCHW, NADELW), interception evaporation (EvI) is identical with potential evapotranspiration (EvPo) as long as it is met by available intercepted water (Inzp) and there is no intercepted snow (indicated by SInz values larger zero):

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(4)
>>> lnk(LAUBW, MISCHW, NADELW, NADELW)
>>> states.inzp = 2.0, 4.0, 4.0, 4.0
>>> states.sinz = 0.0, 0.0, 1.0, 0.0
>>> states.waes = 0.0, 0.0, 0.0, 1.0
>>> fluxes.evpo = 3.0
>>> model.calc_evi_inzp_v3()
>>> states.inzp
inzp(0.0, 1.0, 4.0, 1.0)
>>> fluxes.evi
evi(2.0, 3.0, 0.0, 3.0)

For all other land areas, no interception evaporation occurs when a snow cover is present (indicated by a WAeS values larger zero):

>>> lnk(ACKER)
>>> states.inzp = 2.0, 4.0, 4.0, 4.0
>>> model.calc_evi_inzp_v3()
>>> states.inzp
inzp(0.0, 1.0, 1.0, 4.0)
>>> fluxes.evi
evi(2.0, 3.0, 3.0, 0.0)

For water areas (WASSER, FLUSS and SEE), EvI is generally equal to EvPo (but this might be corrected by a method called after Calc_EvI_Inzp_V3 has been applied) and Inzp is set to zero:

>>> lnk(WASSER, FLUSS, SEE, SEE)
>>> states.inzp = 2.0
>>> fluxes.evpo = 3.0
>>> model.calc_evi_inzp_v3()
>>> states.inzp
inzp(0.0, 0.0, 0.0, 0.0)
>>> fluxes.evi
evi(3.0, 3.0, 3.0, 3.0)
class hydpy.models.lland.lland_model.Calc_EvB_V2[source]

Bases: hydpy.core.modeltools.Method

Calculate the actual evapotranspiration from the soil.

Required submethod:

Return_PenmanMonteith_V1

Requires the control parameters:

NHRU Lnk Emissivity

Requires the derived parameter:

Seconds

Requires the fixed parameters:

Sigma LW CPLuft Psy

Requires the flux sequences:

NetRadiation G TKor SaturationVapourPressureSlope SaturationVapourPressure ActualVapourPressure DensityAir AerodynamicResistance ActualSurfaceResistance EvPo EvI

Requires the state sequence:

WAeS

Calculates the flux sequence:

EvB

Basic equation:

\(EvB = \frac{EvPo - EvI}{EvPo} \cdot Return\_PenmanMonteith\_V1(ActualSurfaceResistance)\)

Example:

For sealed surfaces, water areas and snow-covered hydrological response units that are not forests, there is no soil evapotranspiration:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep()
>>> nhru(6)
>>> lnk(VERS, WASSER, FLUSS, SEE, ACKER, ACKER)
>>> states.waes = 0.0, 0.0, 0.0, 0.0, 0.1, 10.0
>>> model.calc_evb_v2()
>>> fluxes.evb
evb(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)

For all other cases, method Calc_EvB_V2 first applies method Return_PenmanMonteith_V1 (of which’s documentation we take most of the following test configuration) and adjusts the returned soil evapotranspiration to the (prioritised) interception evaporation in accordance with the base equation defined above:

>>> lnk(NADELW)
>>> emissivity(0.96)
>>> derived.seconds.update()
>>> fluxes.netradiation = 8.0, 8.0, 8.0, 8.0, 8.0, -30.0
>>> fluxes.g = -1.0
>>> fluxes.saturationvapourpressure = 1.2
>>> fluxes.saturationvapourpressureslope = 0.08
>>> fluxes.actualvapourpressure = 0.0
>>> fluxes.densityair = 1.24
>>> fluxes.actualsurfaceresistance = 0.0
>>> fluxes.aerodynamicresistance = 106.0
>>> fluxes.tkor = 10.0
>>> fluxes.evpo = 0.0, 6.0, 6.0, 6.0, 6.0, -6.0
>>> fluxes.evi = 0.0, 0.0, 2.0, 4.0, 6.0, -3.0
>>> model.calc_evb_v2()
>>> fluxes.evb
evb(0.0, 5.377732, 3.585154, 1.792577, 0.0, -0.878478)
class hydpy.models.lland.lland_model.Calc_QKap_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the capillary rise.

Requires the control parameters:

NHRU Lnk KapMax KapGrenz WMax

Requires the state sequence:

BoWa

Calculates the flux sequence:

QKap

Basic equation:

\(QKap = KapMax \cdot min\left(max\left(1 - \frac{BoWa-KapGrenz_1}{KapGrenz_2-KapGrenz_1}, 0 \right), 1 \right)\)

Examples:

We prepare six hydrological response units of landuse type ACKER with different soil water contents:

>>> from hydpy.models.lland import *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nhru(6)
>>> lnk(ACKER)
>>> wmax(100.0)
>>> states.bowa(0.0, 20.0, 40.0, 60.0, 80.0, 100.0)

The maximum capillary rise is 3 mm/d (which is 1.5 mm for the actual simulation time step of 12 hours):

>>> kapmax(3.0)

Please read the documentation on parameter KapGrenz, which gives some examples on how to configure the capillary rise thresholds. The following examples show the calculation results for with and without a range of linear transition:

>>> kapgrenz(20.0, 80.0)
>>> model.calc_qkap_v1()
>>> fluxes.qkap
qkap(1.5, 1.5, 1.0, 0.5, 0.0, 0.0)

>>> kapgrenz(40.0, 40.0)
>>> model.calc_qkap_v1()
>>> fluxes.qkap
qkap(1.5, 1.5, 1.5, 0.0, 0.0, 0.0)

You are allowed to set the lower threshold to values lower than zero and the larger one to values larger than WMax:

>>> kapgrenz(-50.0, 150.0)
>>> model.calc_qkap_v1()
>>> fluxes.qkap
qkap(1.125, 0.975, 0.825, 0.675, 0.525, 0.375)

For water areas and sealed surfaces, capillary rise is always zero:

>>> lnk(WASSER, FLUSS, SEE, VERS, VERS, VERS)
>>> model.calc_qkap_v1()
>>> fluxes.qkap
qkap(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
class hydpy.models.lland.lland_model.Calc_QBB_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the amount of base flow released from the soil.

Requires the control parameters:

NHRU Lnk WMax Beta FBeta RBeta PWP FK

Requires the state sequence:

BoWa

Calculates the flux sequence:

QBB

Basic equations:
\[\begin{split}QBB = \begin{cases} 0 &|\ BoWa \leq PWP \;\; \lor \;\; (BoWa \leq NFk \;\; \land \;\; RBeta) \\ Beta_{eff} \cdot (BoWa - PWP) &|\ BoWa > NFk \;\; \lor \;\; (BoWa > PWP \;\; \land \;\; \overline{RBeta}) \end{cases}\end{split}\]
\[\begin{split}Beta_{eff} = \begin{cases} Beta &|\ BoWa \leq FK \\ Beta \cdot \left(1+(FBeta-1)\cdot\frac{BoWa-FK}{WMax-FK}\right) &|\ BoWa > FK \end{cases}\end{split}\]

Examples:

For water and sealed areas, no base flow is calculated (see the first three hydrological response units of type VERS, FLUSS, and SEE). No principal distinction is made between the remaining land use classes (arable land ACKER has been selected for the last five HRUs arbitrarily):

>>> from hydpy.models.lland import *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nhru(8)
>>> lnk(FLUSS, SEE, VERS, ACKER, ACKER, ACKER, ACKER, ACKER)
>>> beta(0.04)
>>> fbeta(2.0)
>>> wmax(0.0, 0.0, 0.0, 0.0, 100.0, 100.0, 100.0, 200.0)
>>> fk(70.0)
>>> pwp(10.0)
>>> rbeta(False)

Note the time dependence of parameter Beta:

>>> beta
beta(0.04)
>>> beta.values
array([ 0.02,  0.02,  0.02,  0.02,  0.02,  0.02,  0.02,  0.02])

In the first example, the actual soil water content BoWa is set to low values. For values below the threshold PWP, no percolation occurs. Above PWP (but below FK), QBB increases linearly by an amount defined by parameter Beta:

>>> states.bowa = 20.0, 20.0, 20.0, 0.0, 0.0, 10.0, 20.0, 20.0
>>> model.calc_qbb_v1()
>>> fluxes.qbb
qbb(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.2)

Note that for the last two response units the same amount of base flow generation is determined, in spite of the fact that both exhibit different relative soil moistures.

If we set the reduction option RBeta to False, QBB is reduced to zero as long as BoWa does not exceed FK:

>>> rbeta(True)
>>> model.calc_qbb_v1()
>>> fluxes.qbb
qbb(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)

In the second example, we set the actual soil water content BoWa to high values. For values below threshold FK, the discussion above remains valid. For values above FK, percolation shows a nonlinear behaviour when factor FBeta is set to values larger than one:

>>> rbeta(False)
>>> wmax(0.0, 0.0, 0.0, 100.0, 100.0, 100.0, 100.0, 200.0)
>>> fk(70.0)
>>> pwp(10.0)
>>> states.bowa = 0.0, 0.0, 0.0, 60.0, 70.0, 80.0, 100.0, 200.0
>>> model.calc_qbb_v1()
>>> fluxes.qbb
qbb(0.0, 0.0, 0.0, 1.0, 1.2, 1.866667, 3.6, 7.6)

>>> rbeta(True)
>>> model.calc_qbb_v1()
>>> fluxes.qbb
qbb(0.0, 0.0, 0.0, 0.0, 0.0, 1.866667, 3.6, 7.6)
class hydpy.models.lland.lland_model.Calc_QIB1_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the first inflow component released from the soil.

Requires the control parameters:

NHRU Lnk DMin WMax PWP

Requires the state sequence:

BoWa

Calculates the flux sequence:

QIB1

Basic equation:

\(QIB1 = DMin \cdot \frac{BoWa}{WMax}\)

Examples:

For water and sealed areas, no interflow is calculated (the first three HRUs are of type FLUSS, SEE, and VERS, respectively). No principal distinction is made between the remaining land use classes (arable land ACKER has been selected for the last five HRUs arbitrarily):

>>> from hydpy.models.lland import *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nhru(8)
>>> lnk(FLUSS, SEE, VERS, ACKER, ACKER, ACKER, ACKER, ACKER)
>>> dmax(10.0)
>>> dmin(4.0)
>>> wmax(101.0, 101.0, 101.0, 0.0, 101.0, 101.0, 101.0, 202.0)
>>> pwp(10.0)
>>> states.bowa = 10.1, 10.1, 10.1, 0.0, 0.0, 10.0, 10.1, 10.1

Note the time dependence of parameter DMin:

>>> dmin
dmin(4.0)
>>> dmin.values
array([ 2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.])

Compared to the calculation of QBB, the following results show some relevant differences:

>>> model.calc_qib1_v1()
>>> fluxes.qib1
qib1(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.1)

Firstly, as demonstrated with the help of the seventh and the eight HRU, the generation of the first interflow component QIB1 depends on relative soil moisture. Secondly, as demonstrated with the help the sixth and seventh HRU, it starts abruptly whenever the slightest exceedance of the threshold parameter PWP occurs. Such sharp discontinuouties are a potential source of trouble.

class hydpy.models.lland.lland_model.Calc_QIB2_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the second inflow component released from the soil.

Requires the control parameters:

NHRU Lnk WMax DMax DMin FK

Requires the state sequence:

BoWa

Calculates the flux sequence:

QIB2

Basic equation:

\(QIB2 = (DMax-DMin) \cdot \left(\frac{BoWa-FK}{WMax-FK}\right)^\frac{3}{2}\)

Examples:

For water and sealed areas, no interflow is calculated (the first three HRUs are of type FLUSS, SEE, and VERS, respectively). No principal distinction is made between the remaining land use classes (arable land ACKER has been selected for the last five HRUs arbitrarily):

>>> from hydpy.models.lland import *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nhru(8)
>>> lnk(FLUSS, SEE, VERS, ACKER, ACKER, ACKER, ACKER, ACKER)
>>> dmax(10.0)
>>> dmin(4.0)
>>> wmax(100.0, 100.0, 100.0, 50.0, 100.0, 100.0, 100.0, 200.0)
>>> fk(50.0)
>>> states.bowa = 100.0, 100.0, 100.0, 50.1, 50.0, 75.0, 100.0, 100.0

Note the time dependence of parameters DMin (see the example above) and DMax:

>>> dmax
dmax(10.0)
>>> dmax.values
array([ 5.,  5.,  5.,  5.,  5.,  5.,  5.,  5.])

The following results show that he calculation of QIB2 both resembles those of QBB and QIB1 in some regards:

>>> model.calc_qib2_v1()
>>> fluxes.qib2
qib2(0.0, 0.0, 0.0, 0.0, 0.0, 1.06066, 3.0, 0.57735)

In the given example, the maximum rate of total interflow generation is 5 mm/12h (parameter DMax). For the seventh zone, which contains a saturated soil, the value calculated for the second interflow component (QIB2) is 3 mm/h. The “missing” value of 2 mm/12h is be calculated by method Calc_QIB1_V1.

(The fourth zone, which is slightly oversaturated, is only intended to demonstrate that zero division due to WMax = FK is circumvented.)

class hydpy.models.lland.lland_model.Calc_QDB_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate direct runoff released from the soil.

Requires the control parameters:

NHRU Lnk WMax BSf

Requires the flux sequence:

WaDa

Requires the state sequence:

BoWa

Calculates the flux sequence:

QDB

Basic equations:
\[\begin{split}QDB = \begin{cases} max\bigl(Exz, 0\bigl) &|\ SfA \leq 0 \\ max\bigl(Exz + WMax \cdot SfA^{BSf+1}, 0\bigl) &|\ SfA > 0 \end{cases}\end{split}\]

\(SFA = \left(1 - \frac{BoWa}{WMax}\right)^\frac{1}{BSf+1} - \frac{WaDa}{(BSf+1) \cdot WMax}\)

\(Exz = (BoWa + WaDa) - WMax\)

Examples:

For water areas (FLUSS and SEE), sealed areas (VERS), and areas without any soil storage capacity, all water is completely routed as direct runoff QDB (see the first four HRUs). No principal distinction is made between the remaining land use classes (arable land ACKER has been selected for the last five HRUs arbitrarily):

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(9)
>>> lnk(FLUSS, SEE, VERS, ACKER, ACKER, ACKER, ACKER, ACKER, ACKER)
>>> bsf(0.4)
>>> wmax(100.0, 100.0, 100.0, 0.0, 100.0, 100.0, 100.0, 100.0, 100.0)
>>> fluxes.wada = 10.0
>>> states.bowa = (
...     100.0, 100.0, 100.0, 0.0, -0.1, 0.0, 50.0, 100.0, 100.1)
>>> model.calc_qdb_v1()
>>> fluxes.qdb
qdb(10.0, 10.0, 10.0, 10.0, 0.142039, 0.144959, 1.993649, 10.0, 10.1)

With the common BSf value of 0.4, the discharge coefficient increases more or less exponentially with soil moisture. For soil moisture values slightly below zero or above usable field capacity, plausible amounts of generated direct runoff are ensured.

class hydpy.models.lland.lland_model.Update_QDB_V1[source]

Bases: hydpy.core.modeltools.Method

Update the direct runoff according to the degree of frost sealing.

Requires the control parameter:

NHRU

Requires the flux sequences:

WaDa FVG

Updates the flux sequence:

QDB

Basic equation:

\(QDB_{updated} = QDB + FVG \cdot (WaDa - QDB)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> fluxes.qdb(5.0)
>>> fluxes.wada(10.0)
>>> fluxes.fvg(0.2)
>>> model.update_qdb_v1()
>>> fluxes.qdb
qdb(6.0, 6.0, 6.0)
class hydpy.models.lland.lland_model.Calc_BoWa_V1[source]

Bases: hydpy.core.modeltools.Method

Update the soil moisture and, if necessary, correct the ingoing and outgoing fluxes.

Requires the control parameters:

NHRU Lnk WMax

Requires the flux sequence:

WaDa

Updates the flux sequences:

EvB QBB QIB1 QIB2 QDB QKap

Updates the state sequence:

BoWa

Basic equations:

\(\frac{dBoWa}{dt} = WaDa + Qkap - EvB - QBB - QIB1 - QIB2 - QDB\)

\(0 \leq BoWa \leq WMax\)

Examples:

For water areas and sealed surfaces, we simply set soil moisture BoWa to zero and do not need to perform any flux corrections:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(4)
>>> lnk(FLUSS, SEE, WASSER, VERS)
>>> states.bowa = 100.0
>>> model.calc_bowa_v1()
>>> states.bowa
bowa(0.0, 0.0, 0.0, 0.0)

We make no principal distinction between the remaining land use classes and select arable land (ACKER) for the following examples.

To prevent soil water contents increasing WMax, we might need to decrease WaDa and QKap:

>>> lnk(ACKER)
>>> wmax(100.0)
>>> states.bowa = 90.0
>>> fluxes.wada = 0.0, 5.0, 10.0, 15.0
>>> fluxes.qkap = 10.0
>>> fluxes.evb = 5.0
>>> fluxes.qbb = 0.0
>>> fluxes.qib1 = 0.0
>>> fluxes.qib2 = 0.0
>>> fluxes.qdb = 0.0
>>> model.calc_bowa_v1()
>>> states.bowa
bowa(95.0, 100.0, 100.0, 100.0)
>>> fluxes.wada
wada(0.0, 5.0, 2.5, 6.0)
>>> fluxes.qkap
qkap(10.0, 10.0, 2.5, 4.0)
>>> fluxes.evb
evb(5.0, 5.0, 5.0, 5.0)

Additionally, to prevent storage overlflows we might need to decrease EvB in case it is negative (meaning, condensation increases the soil water storage):

>>> states.bowa = 90.0
>>> fluxes.wada = 0.0, 5.0, 10.0, 15.0
>>> fluxes.qkap = 2.5
>>> fluxes.evb = -2.5
>>> model.calc_bowa_v1()
>>> states.bowa
bowa(95.0, 100.0, 100.0, 100.0)
>>> fluxes.wada
wada(0.0, 5.0, 3.333333, 7.5)
>>> fluxes.qkap
qkap(2.5, 2.5, 0.833333, 1.25)
>>> fluxes.evb
evb(-2.5, -2.5, -0.833333, -1.25)

To prevent negative BoWa value, we might need to decrease QBB, QIB1, QIB1, QBB, and EvB:

>>> states.bowa = 10.0
>>> fluxes.wada = 0.0
>>> fluxes.qkap = 0.0
>>> fluxes.evb = 0.0, 5.0, 10.0, 15.0
>>> fluxes.qbb = 1.25
>>> fluxes.qib1 = 1.25
>>> fluxes.qib2 = 1.25
>>> fluxes.qdb = 1.25
>>> model.calc_bowa_v1()
>>> states.bowa
bowa(5.0, 0.0, 0.0, 0.0)
>>> fluxes.evb
evb(0.0, 5.0, 6.666667, 7.5)
>>> fluxes.qbb
qbb(1.25, 1.25, 0.833333, 0.625)
>>> fluxes.qib1
qib1(1.25, 1.25, 0.833333, 0.625)
>>> fluxes.qib2
qib2(1.25, 1.25, 0.833333, 0.625)
>>> fluxes.qdb
qdb(1.25, 1.25, 0.833333, 0.625)

We do not to modify negative EvB values (condensation) to prevent negative BoWa values:

>>> states.bowa = 10.0
>>> fluxes.evb = -15.0, -10.0, -5.0, 0.0
>>> fluxes.qbb = 5.0
>>> fluxes.qib1 = 5.0
>>> fluxes.qib2 = 5.0
>>> fluxes.qdb = 5.0
>>> model.calc_bowa_v1()
>>> states.bowa
bowa(5.0, 0.0, 0.0, 0.0)
>>> fluxes.evb
evb(-15.0, -10.0, -5.0, 0.0)
>>> fluxes.qbb
qbb(5.0, 5.0, 3.75, 2.5)
>>> fluxes.qib1
qib1(5.0, 5.0, 3.75, 2.5)
>>> fluxes.qib2
qib2(5.0, 5.0, 3.75, 2.5)
>>> fluxes.qdb
qdb(5.0, 5.0, 3.75, 2.5)
class hydpy.models.lland.lland_model.Calc_QBGZ_V1[source]

Bases: hydpy.core.modeltools.Method

Aggregate the amount of base flow released by all “soil type” HRUs and the “net precipitation” above water areas of type SEE.

Requires the control parameters:

NHRU Lnk FHRU

Requires the flux sequences:

NKor EvI QBB QKap

Calculates the state sequence:

QBGZ

Water areas of type SEE are assumed to be directly connected with groundwater, but not with the stream network. This is modelled by adding their (positive or negative) “net input” (NKor-EvI) to the “percolation output” of the soil containing HRUs.

Basic equation:

\(QBGZ = \Sigma\bigl(FHRU \cdot \bigl(QBB-Qkap\bigl)\bigl) + \Sigma\bigl(FHRU \cdot \bigl(NKor_{SEE}-EvI_{SEE}\bigl)\bigl)\)

Examples:

The first example shows that QBGZ is the area weighted sum of QBB from “soil type” HRUs like arable land (ACKER) and of NKor-EvI from water areas of type SEE. All other water areas (WASSER and FLUSS) and also sealed surfaces (VERS) have no impact on QBGZ:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(6)
>>> lnk(ACKER, ACKER, VERS, WASSER, FLUSS, SEE)
>>> fhru(0.1, 0.2, 0.1, 0.1, 0.1, 0.4)
>>> fluxes.qbb = 2., 4.0, 300.0, 300.0, 300.0, 300.0
>>> fluxes.qkap = 1., 2.0, 150.0, 150.0, 150.0, 150.0
>>> fluxes.nkor = 200.0, 200.0, 200.0, 200.0, 200.0, 20.0
>>> fluxes.evi = 100.0, 100.0, 100.0, 100.0, 100.0, 10.0
>>> model.calc_qbgz_v1()
>>> states.qbgz
qbgz(4.5)

The second example shows that large evaporation values above a HRU of type SEE can result in negative values of QBGZ:

>>> fluxes.evi[5] = 30
>>> model.calc_qbgz_v1()
>>> states.qbgz
qbgz(-3.5)
class hydpy.models.lland.lland_model.Calc_QIGZ1_V1[source]

Bases: hydpy.core.modeltools.Method

Aggregate the amount of the first interflow component released by all HRUs.

Requires the control parameters:

NHRU FHRU

Requires the flux sequence:

QIB1

Calculates the state sequence:

QIGZ1

Basic equation:

\(QIGZ1 = \Sigma(FHRU \cdot QIB1)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(2)
>>> fhru(0.75, 0.25)
>>> fluxes.qib1 = 1.0, 5.0
>>> model.calc_qigz1_v1()
>>> states.qigz1
qigz1(2.0)
class hydpy.models.lland.lland_model.Calc_QIGZ2_V1[source]

Bases: hydpy.core.modeltools.Method

Aggregate the amount of the second interflow component released by all HRUs.

Requires the control parameters:

NHRU FHRU

Requires the flux sequence:

QIB2

Calculates the state sequence:

QIGZ2

Basic equation:

\(QIGZ2 = \Sigma(FHRU \cdot QIB2)\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(2)
>>> fhru(0.75, 0.25)
>>> fluxes.qib2 = 1.0, 5.0
>>> model.calc_qigz2_v1()
>>> states.qigz2
qigz2(2.0)
class hydpy.models.lland.lland_model.Calc_QDGZ_V1[source]

Bases: hydpy.core.modeltools.Method

Aggregate the amount of total direct flow released by all HRUs.

Requires the control parameters:

NHRU Lnk FHRU

Requires the flux sequences:

NKor EvI QDB

Calculates the flux sequence:

QDGZ

Basic equation:

\(QDGZ = \Sigma\bigl(FHRU \cdot QDB\bigl) + \Sigma\bigl(FHRU \cdot \bigl(NKor_{FLUSS}-EvI_{FLUSS}\bigl)\bigl)\)

Examples:

The first example shows that QDGZ is the area weighted sum of QDB from “land type” HRUs like arable land (ACKER) and sealed surfaces (VERS) as well as of NKor-EvI from water areas of type FLUSS. Water areas of type WASSER and SEE have no impact on QDGZ:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(5)
>>> lnk(ACKER, VERS, WASSER, SEE, FLUSS)
>>> fhru(0.1, 0.2, 0.1, 0.2, 0.4)
>>> fluxes.qdb = 2., 4.0, 300.0, 300.0, 300.0
>>> fluxes.nkor = 200.0, 200.0, 200.0, 200.0, 20.0
>>> fluxes.evi = 100.0, 100.0, 100.0, 100.0, 10.0
>>> model.calc_qdgz_v1()
>>> fluxes.qdgz
qdgz(5.0)

The second example shows that large evaporation values above a HRU of type FLUSS can result in negative values of QDGZ:

>>> fluxes.evi[4] = 30
>>> model.calc_qdgz_v1()
>>> fluxes.qdgz
qdgz(-3.0)
class hydpy.models.lland.lland_model.Calc_QDGZ1_QDGZ2_V1[source]

Bases: hydpy.core.modeltools.Method

Separate total direct flow into a slower and a faster component.

Requires the control parameters:

A2 A1

Requires the flux sequence:

QDGZ

Calculates the state sequences:

QDGZ2 QDGZ1

Basic equations:

\(QDGZ2 = \frac{(QDGZ-A2)^2}{QDGZ+A1-A2}\)

\(QDGZ1 = QDGZ - QDGZ2\)

Examples:

We borrowed the formula for calculating the amount of the faster component of direct flow from the well-known curve number approach. Parameter A2 would be the initial loss and parameter A1 the maximum storage, but one should not take this analogy too literally.

With the value of parameter A1 set to zero, parameter A2 defines the maximum amount of “slow” direct runoff per time step:

>>> from hydpy.models.lland import *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> a1(0.0)

Let us set the value of A2 to 4 mm/d, which is 2 mm/12h concerning the selected simulation step size:

>>> a2(4.0)
>>> a2
a2(4.0)
>>> a2.value
2.0

Define a test function and let it calculate QDGZ1 and QDGZ1 for values of QDGZ ranging from -10 to 100 mm/12h:

>>> from hydpy import UnitTest
>>> test = UnitTest(model,
...                 model.calc_qdgz1_qdgz2_v1,
...                 last_example=6,
...                 parseqs=(fluxes.qdgz,
...                          states.qdgz1,
...                          states.qdgz2))
>>> test.nexts.qdgz = -10.0, 0.0, 1.0, 2.0, 3.0, 100.0
>>> test()
| ex. |  qdgz | qdgz1 | qdgz2 |
-------------------------------
|   1 | -10.0 | -10.0 |   0.0 |
|   2 |   0.0 |   0.0 |   0.0 |
|   3 |   1.0 |   1.0 |   0.0 |
|   4 |   2.0 |   2.0 |   0.0 |
|   5 |   3.0 |   2.0 |   1.0 |
|   6 | 100.0 |   2.0 |  98.0 |

Setting A2 to zero and A1 to 4 mm/d (or 2 mm/12h) results in a smoother transition:

>>> a2(0.0)
>>> a1(4.0)
>>> test()
| ex. |  qdgz |    qdgz1 |     qdgz2 |
--------------------------------------
|   1 | -10.0 |    -10.0 |       0.0 |
|   2 |   0.0 |      0.0 |       0.0 |
|   3 |   1.0 | 0.666667 |  0.333333 |
|   4 |   2.0 |      1.0 |       1.0 |
|   5 |   3.0 |      1.2 |       1.8 |
|   6 | 100.0 | 1.960784 | 98.039216 |

Alternatively, one can mix these two configurations by setting the values of both parameters to 2 mm/h:

>>> a2(2.0)
>>> a1(2.0)
>>> test()
| ex. |  qdgz |    qdgz1 |    qdgz2 |
-------------------------------------
|   1 | -10.0 |    -10.0 |      0.0 |
|   2 |   0.0 |      0.0 |      0.0 |
|   3 |   1.0 |      1.0 |      0.0 |
|   4 |   2.0 |      1.5 |      0.5 |
|   5 |   3.0 | 1.666667 | 1.333333 |
|   6 | 100.0 |     1.99 |    98.01 |

Note the similarity of the results for very high values of total direct flow QDGZ in all three examples, which converge to the sum of the values of parameter A1 and A2, representing the maximum value of slow direct flow generation per simulation step

class hydpy.models.lland.lland_model.Calc_QBGA_V1[source]

Bases: hydpy.core.modeltools.Method

Perform the runoff concentration calculation for base flow.

Required by the method:

Update_QDGZ_QBGZ_QBGA_V2

Requires the derived parameter:

KB

Requires the state sequence:

QBGZ

Updates the state sequence:

QBGA

The working equation is the analytical solution of the linear storage equation under the assumption of constant change in inflow during the simulation time step.

Basic equation:

\(QBGA_{neu} = QBGA_{alt} + (QBGZ_{alt}-QBGA_{alt}) \cdot (1-exp(-KB^{-1})) + (QBGZ_{neu}-QBGZ_{alt}) \cdot (1-KB\cdot(1-exp(-KB^{-1})))\)

Examples:

A normal test case:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> derived.kb(0.1)
>>> states.qbgz.old = 2.0
>>> states.qbgz.new = 4.0
>>> states.qbga.old = 3.0
>>> model.calc_qbga_v1()
>>> states.qbga
qbga(3.800054)

First extreme test case (zero division is circumvented):

>>> derived.kb(0.0)
>>> model.calc_qbga_v1()
>>> states.qbga
qbga(4.0)

Second extreme test case (numerical overflow is circumvented):

>>> derived.kb(1e500)
>>> model.calc_qbga_v1()
>>> states.qbga
qbga(5.0)
class hydpy.models.lland.lland_model.Update_QDGZ_QBGZ_QBGA_V1[source]

Bases: hydpy.core.modeltools.Method

Redirect the inflow into the storage compartment for base flow into the storage compartments for direct flow upon exceedance of the groundwater aquifer’s limited volume [4].

Requires the derived parameters:

KB QBGAMax

Updates the flux sequence:

QDGZ

Updates the state sequences:

QBGA QBGZ

We gained the following equation for updating QBGZ by converting the equation used by method Calc_QBGA_V1.

Note that applying method Update_QDGZ_QBGZ_QBGA_V1 can result in some oscillation both of QBGZ and QDGZ. Due to the dampening effect of the runoff concentration storages for direct runoff, this oscillation should seldom be traced through to the resulting outflow values (QDGA1 and QDGA2). However, for long simulation time steps and short runoff concentration times, it is possible. Fixing this issue would probably require to solve the differential equation of the linear storage with a different approach. See the results of the integration test acre (limited groundwater volume) for an example.

Basic equations:

\(QBGA_{neu}^{final} = min \left ( QBGAMax, QBGA_{neu}^{orig} \right )\)

\(QBGZ_{neu}^{final} = QBGZ_{alt} + \frac{QBGA_{neu}^{final} - QBGA_{alt} - (QBGZ_{alt}-QBGA_{alt}) \cdot (1-exp(-KB^{-1})} {1-KB \cdot (1-exp(-KB^{-1})}\)

\(QDGZ^{final} = QDGZ^{orig} + QBGZ_{neu}^{orig} - QBGZ_{neu}^{final}\)

Examples:

We modify the first example of the documentation on method Calc_QBGA_V1 to show that both equations are consistent. The following setting is nearly identical, except for a higher recent inflow (6 mm/d instead of 4 mm/d). As a consequence, the recent outflow is also increased (5.6 mm/d instead of 3.8 mm/d):

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> derived.kb(0.1)
>>> fluxes.qdgz = 1.0
>>> states.qbgz.old = 2.0
>>> states.qbgz.new = 6.0
>>> states.qbga.old = 3.0
>>> states.qbga.new = 5.6000636

Now we set the highest allowed outflow (which is proportional to the maximum storage capacity, see the documentation on parameter QBGAMax) to 3.8 mm/d and apply method Update_QDGZ_QBGZ_QBGA_V1:

>>> derived.qbgamax(3.8000545)
>>> model.update_qdgz_qbgz_qbga_v1()

First, Update_QDGZ_QBGZ_QBGA_V1 resets the recent outflow to the highest value allowed:

>>> states.qbga
qbga(3.800054)

Second, it determines the recent inflow that results in the highest allowed outflow:

>>> states.qbgz
qbgz(4.0)

Third, it adds the excess of groundwater recharge (2 mm/d) to the to the already generated direct discharge:

>>> fluxes.qdgz
qdgz(3.0)

The final example deals with the edge case of zero storage capacity. Without any storage capacity, the aquifer can neither receive nor release any water. Here, method Update_QDGZ_QBGZ_QBGA_V1 needs to reset the recent inflow to a negative value to accomplish zero outflow, as the old inflow and outflow values are not consistent with our modification of parameter QBGAMax:

>>> derived.qbgamax(0.0)
>>> model.update_qdgz_qbgz_qbga_v1()
>>> states.qbga
qbga(0.0)
>>> states.qbgz
qbgz(-0.222261)
>>> fluxes.qdgz
qdgz(7.222261)
class hydpy.models.lland.lland_model.Update_QDGZ_QBGZ_QBGA_V2[source]

Bases: hydpy.core.modeltools.Method

Redirect (a portion of) the inflow into the storage compartment for base flow into the storage compartments for direct flow due to the groundwater table’s too fast rise [4].

Required submethod:

Calc_QBGA_V1

Requires the control parameters:

GSBGrad1 GSBGrad2

Requires the derived parameter:

KB

Updates the flux sequence:

QDGZ

Updates the state sequences:

QBGA QBGZ

In contrast to restricting an aquifer’s volume (implemented by the method Update_QDGZ_QBGZ_QBGA_V1), limiting the water table’s increase seems a litter counterintuitive. However, we provide both kinds of restrictions to fully capture the option “GS BASIS LIMITIERT” of the original LARSIM model.

The problem of oscillating time series for QBGZ and QDGZ discussed for method Update_QDGZ_QBGZ_QBGA_V1 also holds for method Update_QDGZ_QBGZ_QBGA_V2. The smaller the “transition area” (the difference between GSBGrad2 and GSBGrad1, the larger the oscillations. See the results of the integration test acre (limited groundwater rise) for an example.

Basic equations:

\(Grad = KB \cdot (QBGA_{neu}^{orig} - QBGA_{alt})\)

\(QBGZ_{neu}^{final} = QBGZ_{neu}^{orig} \cdot min \left( max \left( \frac{Grad-GSBGrad1}{GSBGrad2 - GSBGrad1}, 0 \right), 1 \right)\)

\(QBGA_{neu}^{final} = QBGA_{alt} + (QBGZ_{alt}-QBGA_{alt}) \cdot (1-exp(-KB^{-1})) + (QBGZ_{neu}^{final}-QBGZ_{alt}) \cdot (1-KB\cdot(1-exp(-KB^{-1})))\)

\(QDGZ^{final} = QDGZ^{orig} + QBGZ_{neu}^{orig} - QBGZ_{neu}^{final}\)

Examples:

We build our explanations on the first example of the documentation on method Calc_QBGA_V1:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> derived.kb(0.1)
>>> fluxes.qdgz = 1.0
>>> states.qbgz.old = 2.0
>>> states.qbgz.new = 4.0
>>> states.qbga.old = 3.0
>>> model.calc_qbga_v1()
>>> states.qbga
qbga(3.800054)

In this example, the old and the new outflow value of the groundwater storage is 3.0 mm/d and 3.8 mm/d, respectively, which corresponds to a storage increase of 0.08 mm/d:

>>> from hydpy import round_
>>> round_((states.qbga.new - states.qbga.old) * derived.kb)
0.080005

If we assign larger values to the threshold parameters GSBGrad1 (0.1 mm/d) and GSBGrad2 (0.2 mm/d), method Update_QDGZ_QBGZ_QBGA_V2 does not need to change anything:

>>> gsbgrad1(0.1)
>>> gsbgrad2(0.2)
>>> model.update_qdgz_qbgz_qbga_v2()
>>> states.qbga
qbga(3.800054)
>>> states.qbgz
qbgz(4.0)
>>> fluxes.qdgz
qdgz(1.0)

If we assign smaller values to both threshold parameters, method Update_QDGZ_QBGZ_QBGA_V2 redirects all groundwater inflow to direct runoff and recalculates groundwater outflow accordingly:

>>> gsbgrad1(0.01)
>>> gsbgrad2(0.05)
>>> model.update_qdgz_qbgz_qbga_v2()
>>> states.qbga
qbga(0.200036)
>>> states.qbgz
qbgz(0.0)
>>> fluxes.qdgz
qdgz(5.0)

For an actual rise (we first reset it to 0.08 mm/d) between both threshold values, method Update_QDGZ_QBGZ_QBGA_V2 interpolates the fraction of redirected groundwater inflow linearly:

>>> fluxes.qdgz = 1.0
>>> states.qbgz.new = 4.0
>>> model.calc_qbga_v1()
>>> gsbgrad1(0.01)
>>> gsbgrad2(0.1)
>>> model.update_qdgz_qbgz_qbga_v2()
>>> states.qbga
qbga(0.999822)
>>> states.qbgz
qbgz(0.888647)
>>> fluxes.qdgz
qdgz(4.111353)
class hydpy.models.lland.lland_model.Calc_QIGA1_V1[source]

Bases: hydpy.core.modeltools.Method

Perform the runoff concentration calculation for the first interflow component.

Requires the derived parameter:

KI1

Requires the state sequence:

QIGZ1

Updates the state sequence:

QIGA1

The working equation is the analytical solution of the linear storage equation under the assumption of constant change in inflow during the simulation time step.

Basic equation:

\(QIGA1_{neu} = QIGA1_{alt} + (QIGZ1_{alt}-QIGA1_{alt}) \cdot (1-exp(-KI1^{-1})) + (QIGZ1_{neu}-QIGZ1_{alt}) \cdot (1-KI1\cdot(1-exp(-KI1^{-1})))\)

Examples:

A normal test case:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> derived.ki1(0.1)
>>> states.qigz1.old = 2.0
>>> states.qigz1.new = 4.0
>>> states.qiga1.old = 3.0
>>> model.calc_qiga1_v1()
>>> states.qiga1
qiga1(3.800054)

First extreme test case (zero division is circumvented):

>>> derived.ki1(0.0)
>>> model.calc_qiga1_v1()
>>> states.qiga1
qiga1(4.0)

Second extreme test case (numerical overflow is circumvented):

>>> derived.ki1(1e500)
>>> model.calc_qiga1_v1()
>>> states.qiga1
qiga1(5.0)
class hydpy.models.lland.lland_model.Calc_QIGA2_V1[source]

Bases: hydpy.core.modeltools.Method

Perform the runoff concentration calculation for the second interflow component.

Requires the derived parameter:

KI2

Requires the state sequence:

QIGZ2

Updates the state sequence:

QIGA2

The working equation is the analytical solution of the linear storage equation under the assumption of constant change in inflow during the simulation time step.

Basic equation:

\(QIGA2_{neu} = QIGA2_{alt} + (QIGZ2_{alt}-QIGA2_{alt}) \cdot (1-exp(-KI2^{-1})) + (QIGZ2_{neu}-QIGZ2_{alt}) \cdot (1-KI2\cdot(1-exp(-KI2^{-1})))\)

Examples:

A normal test case:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> derived.ki2(0.1)
>>> states.qigz2.old = 2.0
>>> states.qigz2.new = 4.0
>>> states.qiga2.old = 3.0
>>> model.calc_qiga2_v1()
>>> states.qiga2
qiga2(3.800054)

First extreme test case (zero division is circumvented):

>>> derived.ki2(0.0)
>>> model.calc_qiga2_v1()
>>> states.qiga2
qiga2(4.0)

Second extreme test case (numerical overflow is circumvented):

>>> derived.ki2(1e500)
>>> model.calc_qiga2_v1()
>>> states.qiga2
qiga2(5.0)
class hydpy.models.lland.lland_model.Calc_QDGA1_V1[source]

Bases: hydpy.core.modeltools.Method

Perform the runoff concentration calculation for “slow” direct runoff.

Requires the derived parameter:

KD1

Requires the state sequence:

QDGZ1

Updates the state sequence:

QDGA1

The working equation is the analytical solution of the linear storage equation under the assumption of constant change in inflow during the simulation time step.

Basic equation:

\(QDGA1_{neu} = QDGA1_{alt} + (QDGZ1_{alt}-QDGA1_{alt}) \cdot (1-exp(-KD1^{-1})) + (QDGZ1_{neu}-QDGZ1_{alt}) \cdot (1-KD1\cdot(1-exp(-KD1^{-1})))\)

Examples:

A normal test case:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> derived.kd1(0.1)
>>> states.qdgz1.old = 2.0
>>> states.qdgz1.new = 4.0
>>> states.qdga1.old = 3.0
>>> model.calc_qdga1_v1()
>>> states.qdga1
qdga1(3.800054)

First extreme test case (zero division is circumvented):

>>> derived.kd1(0.0)
>>> model.calc_qdga1_v1()
>>> states.qdga1
qdga1(4.0)

Second extreme test case (numerical overflow is circumvented):

>>> derived.kd1(1e500)
>>> model.calc_qdga1_v1()
>>> states.qdga1
qdga1(5.0)
class hydpy.models.lland.lland_model.Calc_QDGA2_V1[source]

Bases: hydpy.core.modeltools.Method

Perform the runoff concentration calculation for “fast” direct runoff.

Requires the derived parameter:

KD2

Requires the state sequence:

QDGZ2

Updates the state sequence:

QDGA2

The working equation is the analytical solution of the linear storage equation under the assumption of constant change in inflow during the simulation time step.

Basic equation:

\(QDGA2_{neu} = QDGA2_{alt} + (QDGZ2_{alt}-QDGA2_{alt}) \cdot (1-exp(-KD2^{-1})) + (QDGZ2_{neu}-QDGZ2_{alt}) \cdot (1-KD2\cdot(1-exp(-KD2^{-1})))\)

Examples:

A normal test case:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> derived.kd2(0.1)
>>> states.qdgz2.old = 2.0
>>> states.qdgz2.new = 4.0
>>> states.qdga2.old = 3.0
>>> model.calc_qdga2_v1()
>>> states.qdga2
qdga2(3.800054)

First extreme test case (zero division is circumvented):

>>> derived.kd2(0.0)
>>> model.calc_qdga2_v1()
>>> states.qdga2
qdga2(4.0)

Second extreme test case (numerical overflow is circumvented):

>>> derived.kd2(1e500)
>>> model.calc_qdga2_v1()
>>> states.qdga2
qdga2(5.0)
class hydpy.models.lland.lland_model.Calc_QAH_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the final runoff in mm.

Requires the control parameters:

NegQ NHRU Lnk FHRU

Requires the flux sequences:

NKor QZH

Requires the state sequences:

QBGA QIGA1 QIGA2 QDGA1 QDGA2

Updates the flux sequence:

EvI

Calculates the flux sequence:

QAH

Basic equation:

\(QAH = QZH + QBGA + QIGA1 + QIGA2 + QDGA1 + QDGA2 + NKor_{WASSER} - EvI_{WASSER}\)

In case there are water areas of type WASSER, their NKor values are added and their EvPo values are subtracted from the “potential” runoff value, if possible. This can result in problematic modifications of simulated runoff series. It seems advisable to use the water types FLUSS and SEE instead.

Examples:

When there are no water areas in the respective subbasin (we choose arable land ACKER arbitrarily), the inflow (QZH) and the different runoff components (QBGA, QIGA1, QIGA2, QDGA1, and QDGA2) are simply summed up:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> lnk(ACKER, ACKER, ACKER)
>>> fhru(0.5, 0.2, 0.3)
>>> negq(False)
>>> states.qbga = 0.1
>>> states.qiga1 = 0.2
>>> states.qiga2 = 0.3
>>> states.qdga1 = 0.4
>>> states.qdga2 = 0.5
>>> fluxes.qzh = 1.0
>>> fluxes.nkor = 10.0
>>> fluxes.evi = 4.0, 5.0, 3.0
>>> model.calc_qah_v1()
>>> fluxes.qah
qah(2.5)
>>> fluxes.evi
evi(4.0, 5.0, 3.0)

The defined values of interception evaporation do not show any impact on the result of the given example, the predefined values for sequence EvI remain unchanged. But when we define the first hydrological as a water area (WASSER), Calc_QAH_V1 adds the adjusted precipitaton (NKor) to and subtracts the interception evaporation (EvI) from QAH:

>>> control.lnk(WASSER, VERS, NADELW)
>>> model.calc_qah_v1()
>>> fluxes.qah
qah(5.5)
>>> fluxes.evi
evi(4.0, 5.0, 3.0)

Note that only 5 mm are added (instead of the NKor value 10 mm) and that only 2 mm are substracted (instead of the EvI value 4 mm, as the first response unit area only accounts for 50 % of the total subbasin area.

Setting also the land use class of the second response unit to water type WASSER and resetting NKor to zero would result in overdrying. To avoid this, both actual water evaporation values stored in sequence EvI are reduced by the same factor:

>>> control.lnk(WASSER, WASSER, NADELW)
>>> fluxes.nkor = 0.0
>>> model.calc_qah_v1()
>>> fluxes.qah
qah(0.0)
>>> fluxes.evi
evi(3.333333, 4.166667, 3.0)

The handling of water areas of type FLUSS and SEE differs from those of type WASSER, as these do receive their net input before the runoff concentration routines are applied. This should be more realistic in most cases (especially for type SEE, representing lakes not directly connected to the stream network). But it could also, at least for very dry periods, result in negative outflow values. We avoid this by setting QAH to zero and adding the truncated negative outflow value to the EvI value of all response units of type FLUSS and SEE:

>>> control.lnk(FLUSS, SEE, NADELW)
>>> states.qbga = -1.0
>>> states.qdga2 = -1.9
>>> fluxes.evi = 4.0, 5.0, 3.0
>>> model.calc_qah_v1()
>>> fluxes.qah
qah(0.0)
>>> fluxes.evi
evi(2.571429, 3.571429, 3.0)

This adjustment of EvI is only correct regarding the total water balance. Neither spatial nor temporal consistency of the resulting EvI values are assured. In the most extreme case, even negative EvI values might occur. This seems acceptable, as long as the adjustment of EvI is rarely triggered. When in doubt about this, check sequences EvPo and EvI of all FLUSS and SEE units for possible discrepancies. Also note that QAH might perform unnecessary corrections when you combine water type WASSER with water type SEE or FLUSS.

For some model configurations, negative discharges for dry conditions are acceptable or even preferable, which is possible through setting parameter NegQ to True:

>>> negq(True)
>>> fluxes.evi = 4.0, 5.0, 3.0
>>> model.calc_qah_v1()
>>> fluxes.qah
qah(-1.0)
>>> fluxes.evi
evi(4.0, 5.0, 3.0)
class hydpy.models.lland.lland_model.Calc_QA_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the final runoff in m³/s.

Requires the derived parameter:

QFactor

Requires the flux sequence:

QAH

Calculates the flux sequence:

QA

Basic equation:

\(QA = QFactor \cdot QAH\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> derived.qfactor(2.0)
>>> fluxes.qah = 3.0
>>> model.calc_qa_v1()
>>> fluxes.qa
qa(6.0)
class hydpy.models.lland.lland_model.Pass_QA_V1[source]

Bases: hydpy.core.modeltools.Method

Update the outlet link sequence.

Requires the flux sequence:

QA

Calculates the outlet sequence:

Q

Basic equation:

\(Q_{outlets} = QA\)

class hydpy.models.lland.lland_model.PegasusESnowInz(model: hydpy.core.modeltools.Model)[source]

Bases: hydpy.auxs.roottools.Pegasus

Pegasus iterator for finding the correct energy content of the intercepted snow.

METHODS: ClassVar[Tuple[Type[Method], …]] = (<class 'hydpy.models.lland.lland_model.Return_BackwardEulerErrorInz_V1'>,)
name = 'pegasusesnowinz'
class hydpy.models.lland.lland_model.PegasusESnow(model: hydpy.core.modeltools.Model)[source]

Bases: hydpy.auxs.roottools.Pegasus

Pegasus iterator for finding the correct snow energy content.

METHODS: ClassVar[Tuple[Type[Method], …]] = (<class 'hydpy.models.lland.lland_model.Return_BackwardEulerError_V1'>,)
name = 'pegasusesnow'
class hydpy.models.lland.lland_model.PegasusTempSSurface(model: hydpy.core.modeltools.Model)[source]

Bases: hydpy.auxs.roottools.Pegasus

Pegasus iterator for finding the correct snow surface temperature.

METHODS: ClassVar[Tuple[Type[Method], …]] = (<class 'hydpy.models.lland.lland_model.Return_EnergyGainSnowSurface_V1'>,)
name = 'pegasustempssurface'

Parameter Features

Parameter tools

class hydpy.models.lland.lland_parameters.ParameterComplete(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Base class for 1-dimensional parameters relevant for all types of landuse.

Class ParameterComplete of base model lland basically works like class ParameterComplete of base model hland, but references lland specific parameters and constants, as shown in the following examples based on parameter KG (for explanations, see the documentation on class ParameterComplete):

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(5)
>>> lnk(ACKER, VERS, GLETS, SEE, ACKER)
>>> kg(acker=2.0, vers=1.0, glets=4.0, see=3.0)
>>> kg
kg(acker=2.0, glets=4.0, see=3.0, vers=1.0)
>>> kg.values
array([ 2.,  1.,  4.,  3.,  2.])
>>> kg(5.0, 4.0, 3.0, 2.0, 1.0)
>>> derived.absfhru(0.0, 0.1, 0.2, 0.3, 0.4)
>>> from hydpy import round_
>>> round_(kg.average_values())
2.0
MODEL_CONSTANTS: Dict[str, int] = {'ACKER': 4, 'BAUMB': 12, 'BODEN': 7, 'FEUCHT': 10, 'FLUSS': 17, 'GLETS': 8, 'GRUE_E': 11, 'GRUE_I': 9, 'LAUBW': 14, 'MISCHW': 15, 'NADELW': 13, 'OBSTB': 6, 'SEE': 18, 'SIED_D': 1, 'SIED_L': 2, 'VERS': 3, 'WASSER': 16, 'WEINB': 5}
mask
property refweights

Alias for the associated instance of FHRU for calculating areal mean values.

name: str = 'parametercomplete'
unit: str = '?'
class hydpy.models.lland.lland_parameters.ParameterLand(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Base class for 1-dimensional parameters relevant for all hydrological response units except those of type WASSER, FLUSS, and SEE.

ParameterLand works similar to ParameterComplete. Some examples based on parameter TGr:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(5)
>>> lnk(WASSER, ACKER, FLUSS, VERS, ACKER)
>>> tgr(wasser=2.0, acker=1.0, fluss=4.0, vers=3.0)
>>> tgr
tgr(acker=1.0, vers=3.0)
>>> tgr(acker=2.0, default=8.0)
>>> tgr
tgr(acker=2.0, vers=8.0)
>>> derived.absfhru(nan, 1.0, nan, 1.0, 1.0)
>>> from hydpy import round_
>>> round_(tgr.average_values())
4.0
mask
name: str = 'parameterland'
unit: str = '?'
TIME: Optional[bool]
TYPE: Type
fastaccess: FastAccessType
subvars: SubVariablesType
class hydpy.models.lland.lland_parameters.ParameterSoil(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Base class for 1-dimensional parameters relevant for all hydrological response units except those of type WASSER, FLUSS, SEE, and VERS.

ParameterLand works similar to ParameterComplete. Some examples based on parameter WMax:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(5)
>>> lnk(WASSER, ACKER, LAUBW, VERS, ACKER)
>>> wmax(wasser=300.0, acker=200.0, laubw=400.0, vers=300.0)
>>> wmax
wmax(acker=200.0, laubw=400.0)
>>> wmax(acker=200.0, default=800.0)
>>> wmax
wmax(acker=200.0, laubw=800.0)
>>> derived.absfhru(nan, 1.0, 1.0, nan, 1.0)
>>> from hydpy import round_
>>> round_(wmax.average_values())
400.0
mask
name: str = 'parametersoil'
unit: str = '?'
TIME: Optional[bool]
TYPE: Type
fastaccess: FastAccessType
subvars: SubVariablesType
class hydpy.models.lland.lland_parameters.ParameterSoilThreshold(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Base class for defining threshold parameters related to WMax.

Base class ParameterSoilThreshold provides the convenience to define thresholds via the keyword argument relative. For example, you can define the value of parameter PWP as a portion of the current value of WMax:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(2)
>>> lnk(ACKER, LAUBW)
>>> wmax(100.0, 200.0)
>>> pwp(relative=0.2)
>>> pwp
pwp(acker=20.0, laubw=40.0)

Trimming works as to be expected:

>>> pwp(relative=-0.2)
>>> pwp
pwp(0.0)

You can also use the common ways to define soil parameter values:

>>> pwp(acker=30.0, laubw=60.0)
>>> pwp
pwp(acker=30.0, laubw=60.0)
>>> pwp(10.0)
>>> pwp
pwp(10.0)

We do not allow to combine the keyword argument relative with other ones:

>>> pwp(relative=True, acker=10.0)
Traceback (most recent call last):
...
TypeError: While trying to set the values of parameter `pwp` of element `?` with arguments `relative and acker`:  It is not allowed to use keyword `relative` and other keywords at the same time.

Other possible errors related to the usage of ParameterSoil are reported as usual:

>>> pwp(feld=20.0, acker=10.0)
Traceback (most recent call last):
...
TypeError: While trying to set the values of parameter `pwp` of element `?` based on keyword arguments `feld and acker`, the following error occurred: Keyword `feld` is not among the available model constants.
name: str = 'parametersoilthreshold'
unit: str = '?'
TIME: Optional[bool]
TYPE: Type
fastaccess: FastAccessType
subvars: SubVariablesType
class hydpy.models.lland.lland_parameters.LanduseMonthParameter(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Base class for parameters which values depend both an the actual land use class and the actual month.

COLNAMES: ClassVar[Tuple[str, …]] = ('jan', 'feb', 'mar', 'apr', 'mai', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec')
ROWNAMES: ClassVar[Tuple[str, …]] = ('sied_d', 'sied_l', 'vers', 'acker', 'weinb', 'obstb', 'boden', 'glets', 'grue_i', 'feucht', 'grue_e', 'baumb', 'nadelw', 'laubw', 'mischw', 'wasser', 'fluss', 'see')
name: str = 'landusemonthparameter'
unit: str = '?'

Constants

The HydPy-L-Land model (lland) allows for the subdivision of subbasins into hydrological response units (hru). Some processes, e.g. interception, are calculated separately for each zone. This is why some parameters (e.g. the usable field capacity NFk) and some sequences (e.g. the actual soil water storage BoWa) are 1-dimensional. Each entry represents the value of a different hru.

In contrasts to the original LARSIM model, the HydPy-L-Land model allows for arbitrary definitions of units. Nevertheless, the original distinction in accordance with sixteen different landuse types is still supported. The parameter Lnk defines which entry of e.g. parameter NFk is related to which land use type via integer values. Note that for the units of the most land use types, the same equations are applied. Only units of type VERS, WASSER, FLUSS, and SEE are partly connected to different process equations.

For comprehensibility, this module introduces the relevant integer constants. Through performing a wildcard import

>>> from hydpy.models.lland import *

these are available in your local namespace:

>>> (SIED_D, SIED_L, VERS, ACKER, WEINB, OBSTB, BODEN, GLETS, GRUE_I,
...  FEUCHT, GRUE_E, BAUMB, NADELW, LAUBW, MISCHW, WASSER, FLUSS, SEE)
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)
hydpy.models.lland.lland_constants.SIED_D = 1

Constant for Siedlung, dicht (settlement, dense).

hydpy.models.lland.lland_constants.SIED_L = 2

Constant for Siedlung, locker (settlement, light).

hydpy.models.lland.lland_constants.VERS = 3

Constant for versiegelt (sealed).

hydpy.models.lland.lland_constants.ACKER = 4

Constant for Acker (fields).

hydpy.models.lland.lland_constants.WEINB = 5

Constant for Weinbau (viniculture).

hydpy.models.lland.lland_constants.OBSTB = 6

Constant for Obstbau (intensive orchards).

hydpy.models.lland.lland_constants.BODEN = 7

Constant for unbewachsener Boden (unsealed soil, not overgrown).

hydpy.models.lland.lland_constants.GLETS = 8

Constant for Gletscher (glacier).

hydpy.models.lland.lland_constants.GRUE_I = 9

Constant for Grünland, intensiv (intensive pasture).

hydpy.models.lland.lland_constants.FEUCHT = 10

Constant for Feuchtflächen (wetlands).

hydpy.models.lland.lland_constants.GRUE_E = 11

Constant for Grünland, extensiv (extensive pasture).

hydpy.models.lland.lland_constants.BAUMB = 12

Constant for lockerer Baumbestand (sparsely populated forest).

hydpy.models.lland.lland_constants.NADELW = 13

Constant for Nadelwald (coniferous forest).

hydpy.models.lland.lland_constants.LAUBW = 14

Constant for Laubwald (deciduous forest).

hydpy.models.lland.lland_constants.MISCHW = 15

Constant for Mischwald (mixed forest).

hydpy.models.lland.lland_constants.WASSER = 16

Constant for Wasser (water areas).

hydpy.models.lland.lland_constants.FLUSS = 17

Constant for Fluss (river surface).

hydpy.models.lland.lland_constants.SEE = 18

Constant for See (lake surface).

Control parameters

class hydpy.models.lland.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 lland.

The following classes are selected:

  • Latitude() The latitude [decimal degrees].

  • Longitude() The longitude [decimal degrees].

  • FT() Teileinzugsgebietsfläche (subbasin area) [km²].

  • NHRU() Anzahl der Hydrotope (number of hydrological response units) [-].

  • Lnk() Landnutzungsklasse (land use class) [-].

  • FHRU() Flächenanteile der Hydrotope (area percentages of the respective HRUs) [-].

  • HNN() Höhe über Normal-Null (height above sea level) [m].

  • KG() Niederschlagskorrekturfaktor (adjustment factor for precipitation) [-].

  • KT() Temperaturkorrektursummand (adjustment summand for air temperature) [°C].

  • KE() Grasreferenzverdunstungskorrekturfaktor (adjustment factor for reference evapotranspiration) [-].

  • AngstromConstant() The Ångström “a” coefficient for calculating global radiation [-].

  • AngstromFactor() The Ångström “b” coefficient for calculating global radiation [-].

  • AngstromAlternative() An alternative Ångström coefficient replacing coefficient “c” (AngstromConstant) on days without any direct sunshine [-].

  • P1Strahl() Konstante der Globalstrahlungsreduktion für Wald (constant for reducing the global radiation in forests) [-].

  • P2Strahl() Faktor der Globalstrahlungsreduktion für Wald (factor for reducing the global radiation in forests) [-].

  • Albedo() Albedo [-].

  • Albedo0Snow() Albedo von Neuschnee (albedo of fresh snow) [-].

  • SnowAgingFactor() Wichtungsfaktor für die Sensitivität der Albedo für die Alterung des Schnees (weighting factor of albedo sensitivity for snow aging) [-].

  • Turb0() Parameter des Übergangskoeffizienten des turbulenten Wärmestroms (parameter of transition coefficient for turbulent heat flux) [MJ/m²/K/T].

  • Turb1() Parameter des Übergangskoeffizienten des turbulenten Wärmestroms (parameter of transition coefficient for turbulent heat flux) [(MJ*s)/m³/K/T].

  • Emissivity() Emissivität der Oberfläche (emissivity) [-]

  • MeasuringHeightWindSpeed() The height above ground of the wind speed measurements [m].

  • P1Wind() Konstante der Windgeschwindigkeitsreduktion für Wald (constant for reducing the wind speed in forests) [-].

  • P2Wind() Faktor der Windgeschwindigkeitsreduktion für Wald (factor for reducing the wind speed in forests) [-].

  • LAI() Blattflächenindex (leaf area index) [-].

  • HInz() Interzeptionskapazität bezogen auf die Blattoberfläche (interception capacity normalized to the leaf surface area) [mm].

  • P1SIMax() Konstante zur Berechnung der maximalen Schneeinterzeptionskapazität basierend auf dem Blattflächenindex (constant for calculating the maximum snow interception capacity based on the leaf area index) [mm].

  • P2SIMax() Faktor zur Berechnung der maximalen Schneeinterzeptionskapazität basierend auf dem Blattflächenindex (factor for calculating the maximum snow interception capacity based on the leaf area index) [mm].

  • P1SIRate() Konstante zur Berechnung des Verhältnisses von Schneeinerzeptionsrate und Niederschlagsintensität basierend auf dem Blattflächenindex (constant for calculating the ratio of the snow interception rate and the precipitation intensity based on the leaf area index) [-].

  • P2SIRate() Faktor zur Berechnung des Verhältnisses von Schneeinerzeptionsrate und Niederschlagsintensität basierend auf dem Blattflächenindex (factor for calculating the ratio of the snow interception rate and precipitation intensity based on the leaf area index) [-].

  • P3SIRate() Faktor zur Berechnung des Verhältnisses von Schneeinerzeptionsrate und Niederschlagsintensität basierend auf der bereits interzipierten Schneemenge (factor for calculating the ratio of the snow interception rate and precipitation intensity based on the amount of already intercepted snow) [1/mm].

  • TRefT() Lufttemperaturgrenzwert des Grad-Tag-Verfahrens (air temperature threshold of the degree-day method) [°C].

  • TRefN() Niederschlagstemperaturgrenzwert des zur Berechnung des Wärmeeintrags durch Regen (precipitation temperature threshold to calculate heat flux caused by liquid precipitation on snow) [°C].

  • TGr() Temperaturgrenzwert flüssiger/fester Niederschlag (threshold temperature liquid/frozen precipitation) [°C].

  • TSp() Temperaturspanne flüssiger/fester Niederschlag (temperature range with mixed precipitation) [°C].

  • GTF() Grad-Tag-Faktor (factor of the degree-day method) [mm/°C/T].

  • PWMax() Maximalverhältnis Gesamt- zu Trockenschnee (maximum ratio of the total and the frozen water equivalent stored in the snow cover) [-].

  • RefreezeFlag() Flag um wiedergefrieren zu aktivieren (flag to activate refreezing) [-].

  • KTSchnee() Effektive Wärmeleitfähigkeit der obersten Schneeschicht (effective thermal conductivity of the top snow layer) [MJ/m²/K/T].

  • WG2Z() Bodenwärmestrom in der Tiefe 2z (soil heat flux at depth 2z) [MJ/m²/d].

  • KF() Küstenfaktor (“coast factor” of Turc-Wendling’s evaporation equation [-].

  • WfET0() Zeitlicher Wichtungsfaktor der Grasreferenzverdunsung (temporal weighting factor for reference evapotranspiration).

  • FLn() Landnutzungsabhängiger Verdunstungsfaktor (factor for adjusting reference evapotranspiration to different land use classes) [-].

  • GrasRef_R() Bodenfeuchte-Verdunstung-Parameter (soil moisture-dependent evaporation factor) [-].

  • CropHeight() Crop height [m].

  • SurfaceResistance() Surface Resistance [s/m].

  • WMax() Maximaler Bodenwasserspeicher (maximum soil water storage) [mm].

  • FK() Feldkapazität / Mindestbodenfeuchte für die Interflowentstehung (field capacity / threshold value of soil moisture for interflow generation) [mm].

  • PWP() Permanenter Welkepunkt / Mindestbodenfeuchte für die Basisabflussentstehung (permanent wilting point threshold value of soil moisture for base flow generation) [mm].

  • PY() Permanenter Welkepunkt / Schwellenwert für den Anteil des für Pflanzen gebundenen Bodenwassers (permanent wilting point) [mm].

  • BSf() Bodenfeuchte-Sättigungsfläche-Parameter (shape parameter for the relation between the avarage soil moisture and the relative saturated area of a subbasin) [-].

  • FVF() Frostversiegelungsfaktor zur Ermittelung des Frostversiegelungsgrades (frost sealing factor for determination of the degree of frost sealing FVG) [-].

  • BSFF() Exponent zur Ermittelung des Frostversieglungsgrades (frost sealing exponent for determination of degree of frost sealing FVG) [-].

  • DMin() Drainageindex des mittleren Bodenspeichers (flux rate for releasing interflow from the middle soil compartment) [mm/T].

  • DMax() Drainageindex des oberen Bodenspeichers (additional flux rate for releasing interflow from the upper soil compartment) [mm/T].

  • Beta() Drainageindex des tiefen Bodenspeichers (storage coefficient for releasing base flow from the lower soil compartment) [1/T].

  • FBeta() Faktor zur Erhöhung der Perkolation im Grobporenbereich (factor for increasing percolation under wet conditions) [-].

  • KapMax() Maximale kapillare Aufstiegsrate (maximum capillary rise) [mm/T].

  • KapGrenz() Grenzwerte für den kapillaren Aufstieg (threshold values related to the capillary rise) [mm].

  • RBeta() Boolscher Parameter der steuert, ob the Perkolation unterhalb der Feldkapazität auf Null reduziert wird (flag to indicate if seepage is reduced to zero below field capacity) [-].

  • VolBMax() Maximaler Inhalt des Gebietsspeichers für Basisabfluss (maximum value of the storage compartment for base flow) [mm].

  • GSBMax() Faktor zur Anpassung von VolBMax (factor for adjusting VolBMax) [-].

  • GSBGrad1() Höchste Volumenzunahme des Gebietsspeichers für Basisabfluss ohne Begrenzung des Zuflusses (highest possible storage increase of the compartment for base flow without inflow reductions) [mm/T].

  • GSBGrad2() Volumenzunahme des Gebietsspeichers für Basisabfluss, oberhalb der jeglicher Zufluss ausgeschlossen ist (highest possible storage increase of the compartment for base flow) [mm/T].

  • A1() Parameter für die kontinuierliche Aufteilung der Direktabflusskomponenten (threshold value for the continuous seperation of direct runoff in a slow and a fast component) [mm/T]

  • A2() Parameter für die diskontinuierliche Aufteilung der Direktabflusskomponenten (threshold value for the discontinuous seperation of direct runoff in a slow and a fast component) [mm/T]

  • TInd() Fließzeitindex (factor related to the time of concentration) [T].

  • EQB() Kalibrierfaktor für die Basisabflusskonzentration (factor for adjusting the concentration time of baseflow). [-].

  • EQI1() Kalibrierfaktor für die “untere” Zwischenabflusskonzentration (factor for adjusting the concentration time of the first interflow component) [-].

  • EQI2() Kalibrierfaktor für die “obere” Zwischenabflusskonzentration (factor for adjusting the concentration time of the second interflow component) [-].

  • EQD1() Kalibrierfaktor für die langsamere Direktabflusskonzentration (factor for adjusting the concentration time of the slower component of direct runoff). [-].

  • EQD2() Kalibrierfaktor für die schnellere Direktabflusskonzentration (factor for adjusting the concentration time of the faster component of direct runoff). [-].

  • NegQ() Option: sind negative Abflüsse erlaubt (flag that indicated wether negative discharge values are allowed or not) [-].

class hydpy.models.lland.lland_control.Latitude(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The latitude [decimal degrees].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (-90.0, 90.0)
INIT: Union[int, float, bool, None] = 0.0
name: str = 'latitude'
unit: str = 'decimal degrees'
class hydpy.models.lland.lland_control.Longitude(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The longitude [decimal degrees].

Required by the method:

Calc_TSA_TSU_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (-180.0, 180.0)
INIT: Union[int, float, bool, None] = 0.0
name: str = 'longitude'
unit: str = 'decimal degrees'
class hydpy.models.lland.lland_control.FT(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Teileinzugsgebietsfläche (subbasin area) [km²].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (1e-10, None)
name: str = 'ft'
unit: str = 'km²'
class hydpy.models.lland.lland_control.NHRU(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Anzahl der Hydrotope (number of hydrological response units) [-].

Required by the methods:

Calc_ActualAlbedoInz_V1 Calc_ActualAlbedo_V1 Calc_ActualSurfaceResistance_V1 Calc_ActualVapourPressure_V1 Calc_AerodynamicResistance_V1 Calc_BoWa_V1 Calc_DailyActualVapourPressure_V1 Calc_DailyNetLongwaveRadiation_V1 Calc_DailyNetRadiation_V1 Calc_DailyNetShortwaveRadiation_V1 Calc_DailySaturationVapourPressureSlope_V1 Calc_DailySaturationVapourPressure_V1 Calc_DensityAir_V1 Calc_DryAirPressure_V1 Calc_ET0_V1 Calc_ET0_WET0_V1 Calc_EvB_V1 Calc_EvB_V2 Calc_EvI_Inzp_V1 Calc_EvI_Inzp_V2 Calc_EvI_Inzp_V3 Calc_EvPo_V1 Calc_EvPo_V2 Calc_EvSInz_SInz_STInz_V1 Calc_EvS_WAeS_WATS_V1 Calc_FVG_V1 Calc_G_V1 Calc_G_V2 Calc_GefrInz_STInz_V1 Calc_GefrPotInz_V1 Calc_GefrPot_V1 Calc_Gefr_WATS_V1 Calc_LanduseSurfaceResistance_V1 Calc_NBesInz_V1 Calc_NBes_Inzp_V1 Calc_NKor_V1 Calc_NetRadiation_V1 Calc_NetShortwaveRadiationInz_V1 Calc_NetShortwaveRadiationSnow_V1 Calc_NetShortwaveRadiation_V1 Calc_QAH_V1 Calc_QBB_V1 Calc_QBGZ_V1 Calc_QDB_V1 Calc_QDGZ_V1 Calc_QIB1_V1 Calc_QIB2_V1 Calc_QIGZ1_V1 Calc_QIGZ2_V1 Calc_QKap_V1 Calc_RLAtm_V1 Calc_ReducedWindSpeed2m_V1 Calc_SBesInz_V1 Calc_SBes_V1 Calc_SFF_V1 Calc_SNRatio_V1 Calc_STInz_V1 Calc_SaturationVapourPressureSlope_V1 Calc_SaturationVapourPressure_V1 Calc_SchmInz_STInz_V1 Calc_SchmPotInz_V1 Calc_SchmPot_V1 Calc_SchmPot_V2 Calc_Schm_WATS_V1 Calc_SnowIntMax_V1 Calc_SnowIntRate_V1 Calc_SoilSurfaceResistance_V1 Calc_TKorTag_V1 Calc_TKor_V1 Calc_TZ_V1 Calc_TempSInz_V1 Calc_TempS_V1 Calc_WATS_V1 Calc_WATS_V2 Calc_WGTF_V1 Calc_WG_V1 Calc_WNiedInz_ESnowInz_V1 Calc_WNied_ESnow_V1 Calc_WNied_V1 Calc_WaDaInz_SInz_V1 Calc_WaDa_WAeS_V1 Calc_WaDa_WAeS_V2 Update_ASInz_V1 Update_EBdn_V1 Update_ESnowInz_V1 Update_ESnowInz_V2 Update_ESnow_V1 Update_ESnow_V2 Update_QDB_V1 Update_TauS_V1 Update_WaDaInz_SInz_V1 Update_WaDa_WAeS_V1

Note that NHRU determines the length of most 1-dimensional HydPy-L-Land parameters and sequences as well the shape of 2-dimensional log sequences with a predefined length of one axis (see WET0). This requires that the value of the respective NHRU instance is set before any of the values of these 1-dimensional parameters or sequences are set. Changing the value of the NHRU instance necessitates setting their values again:

Examples:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(5)
>>> control.kg.shape
(5,)
>>> fluxes.tkor.shape
(5,)
>>> logs.wet0.shape
(1, 5)
>>> control.angstromfactor.shape
(12,)
NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (1, None)
name: str = 'nhru'
unit: str = '-'
class hydpy.models.lland.lland_control.Lnk(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Landnutzungsklasse (land use class) [-].

Required by the methods:

Calc_ActualAlbedo_V1 Calc_ActualSurfaceResistance_V1 Calc_AerodynamicResistance_V1 Calc_BoWa_V1 Calc_EvB_V1 Calc_EvB_V2 Calc_EvI_Inzp_V1 Calc_EvI_Inzp_V2 Calc_EvI_Inzp_V3 Calc_EvPo_V1 Calc_EvPo_V2 Calc_EvSInz_SInz_STInz_V1 Calc_EvS_WAeS_WATS_V1 Calc_FVG_V1 Calc_G_V1 Calc_G_V2 Calc_GefrInz_STInz_V1 Calc_Gefr_WATS_V1 Calc_LanduseSurfaceResistance_V1 Calc_NBesInz_V1 Calc_NBes_Inzp_V1 Calc_NetShortwaveRadiationInz_V1 Calc_NetShortwaveRadiationSnow_V1 Calc_QAH_V1 Calc_QBB_V1 Calc_QBGZ_V1 Calc_QDB_V1 Calc_QDGZ_V1 Calc_QIB1_V1 Calc_QIB2_V1 Calc_QKap_V1 Calc_ReducedWindSpeed2m_V1 Calc_SBesInz_V1 Calc_SFF_V1 Calc_STInz_V1 Calc_SchmInz_STInz_V1 Calc_Schm_WATS_V1 Calc_SnowIntMax_V1 Calc_SnowIntRate_V1 Calc_SoilSurfaceResistance_V1 Calc_TZ_V1 Calc_WATS_V1 Calc_WATS_V2 Calc_WGTF_V1 Calc_WG_V1 Calc_WNiedInz_ESnowInz_V1 Calc_WNied_ESnow_V1 Calc_WNied_V1 Calc_WaDaInz_SInz_V1 Calc_WaDa_WAeS_V1 Calc_WaDa_WAeS_V2 Return_BackwardEulerErrorInz_V1 Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_NetLongwaveRadiationInz_V1 Return_NetLongwaveRadiationSnow_V1 Return_TempSSurface_V1 Return_WSurfInz_V1 Update_EBdn_V1 Update_ESnowInz_V1 Update_ESnowInz_V2 Update_ESnow_V1 Update_ESnow_V2 Update_WaDaInz_SInz_V1 Update_WaDa_WAeS_V1

For increasing legibility, the HydPy-L-Land constants are used for string representions of Lnk objects:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> lnk
lnk(?)
>>> nhru(4)
>>> lnk(ACKER, ACKER, WASSER, MISCHW)
>>> lnk.values
array([ 4,  4, 16, 15])
>>> lnk
lnk(ACKER, ACKER, WASSER, MISCHW)
>>> lnk(ACKER)
>>> lnk
lnk(ACKER)
NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (1, 18)
CONSTANTS: hydpy.core.parametertools.Constants = {'ACKER': 4, 'BAUMB': 12, 'BODEN': 7, 'FEUCHT': 10, 'FLUSS': 17, 'GLETS': 8, 'GRUE_E': 11, 'GRUE_I': 9, 'LAUBW': 14, 'MISCHW': 15, 'NADELW': 13, 'OBSTB': 6, 'SEE': 18, 'SIED_D': 1, 'SIED_L': 2, 'VERS': 3, 'WASSER': 16, 'WEINB': 5}
name: str = 'lnk'
unit: str = '-'
class hydpy.models.lland.lland_control.FHRU(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Flächenanteile der Hydrotope (area percentages of the respective HRUs) [-].

Required by the methods:

Calc_QAH_V1 Calc_QBGZ_V1 Calc_QDGZ_V1 Calc_QIGZ1_V1 Calc_QIGZ2_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
name: str = 'fhru'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.HNN(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Höhe über Normal-Null (height above sea level) [m].

Required by the method:

Calc_ET0_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'hnn'
unit: str = 'm'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.KG(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Niederschlagskorrekturfaktor (adjustment factor for precipitation) [-].

Required by the method:

Calc_NKor_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 1.0
name: str = 'kg'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.KT(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Temperaturkorrektursummand (adjustment summand for air temperature) [°C].

Required by the methods:

Calc_TKorTag_V1 Calc_TKor_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
INIT: Union[int, float, bool, None] = 0.0
name: str = 'kt'
unit: str = '°C'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.KE(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Grasreferenzverdunstungskorrekturfaktor (adjustment factor for reference evapotranspiration) [-].

Required by the methods:

Calc_ET0_V1 Calc_ET0_WET0_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 1.0
name: str = 'ke'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.AngstromConstant(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The Ångström “a” coefficient for calculating global radiation [-].

Required by the methods:

Calc_DailyGlobalRadiation_V1 Calc_GlobalRadiation_V1 Return_DailyGlobalRadiation_V1

TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
INIT: Union[int, float, bool, None] = 0.25
trim(lower=None, upper=None)[source]

Trim values following \(AngstromConstant \leq 1 - AngstromFactor\) or at least following \(AngstromConstant \leq 1\).

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> angstromfactor(0.4, 0.4, nan, 0.4, 0.4, 0.4,
...                0.6, 0.8, 1.0, 1.0, nan, nan)
>>> angstromconstant(-0.2, 0.0, 0.2, 0.4, 0.6, 0.8,
...                   1.0, 1.2, 1.4, 1.6, 1.8, 2.0)
>>> angstromconstant
angstromconstant(jan=0.0, feb=0.0, mar=0.2, apr=0.4, may=0.6, jun=0.6,
                 jul=0.4, aug=0.2, sep=0.0, oct=0.0, nov=1.0, dec=1.0)
>>> angstromfactor(None)
>>> angstromconstant(0.6)
>>> angstromconstant
angstromconstant(0.6)
name: str = 'angstromconstant'
unit: str = '-'
class hydpy.models.lland.lland_control.AngstromFactor(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The Ångström “b” coefficient for calculating global radiation [-].

Required by the methods:

Calc_DailyGlobalRadiation_V1 Calc_GlobalRadiation_V1 Return_DailyGlobalRadiation_V1

TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.5
trim(lower=None, upper=None)[source]

Trim values in accordance with \(AngstromFactor \leq 1 - AngstromConstant\) or at least in accordance with \(AngstromFactor \leq 1\).

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> angstromconstant(0.4, 0.4, nan, 0.4, 0.4, 0.4,
...                  0.6, 0.8, 1.0, 1.0, nan, nan)
>>> angstromfactor(-0.2, 0.0, 0.2, 0.4, 0.6, 0.8,
...                1.0, 1.2, 1.4, 1.6, 1.8, 2.0)
>>> angstromfactor
angstromfactor(jan=0.0, feb=0.0, mar=0.2, apr=0.4, may=0.6, jun=0.6,
               jul=0.4, aug=0.2, sep=0.0, oct=0.0, nov=1.0, dec=1.0)
>>> angstromconstant(None)
>>> angstromfactor(0.6)
>>> angstromfactor
angstromfactor(0.6)
name: str = 'angstromfactor'
unit: str = '-'
class hydpy.models.lland.lland_control.AngstromAlternative(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

An alternative Ångström coefficient replacing coefficient “c” (AngstromConstant) on days without any direct sunshine [-].

Required by the methods:

Calc_DailyGlobalRadiation_V1 Calc_GlobalRadiation_V1 Return_DailyGlobalRadiation_V1

TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
INIT: Union[int, float, bool, None] = 0.15
name: str = 'angstromalternative'
unit: str = '-'
class hydpy.models.lland.lland_control.P1Strahl(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Konstante der Globalstrahlungsreduktion für Wald (constant for reducing the global radiation in forests) [-].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
INIT: Union[int, float, bool, None] = 0.5
name: str = 'p1strahl'
unit: str = '-'
class hydpy.models.lland.lland_control.P2Strahl(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Faktor der Globalstrahlungsreduktion für Wald (factor for reducing the global radiation in forests) [-].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
INIT: Union[int, float, bool, None] = 0.02857142857142857
name: str = 'p2strahl'
unit: str = '-'
class hydpy.models.lland.lland_control.Albedo(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Albedo [-].

Required by the method:

Calc_ActualAlbedo_V1

NDIM: int = 2
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
INIT: Union[int, float, bool, None] = 0.0
name: str = 'albedo'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.Albedo0Snow(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Albedo von Neuschnee (albedo of fresh snow) [-].

Required by the methods:

Calc_ActualAlbedoInz_V1 Calc_ActualAlbedo_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
INIT: Union[int, float, bool, None] = 0.8
name: str = 'albedo0snow'
unit: str = '-'
class hydpy.models.lland.lland_control.SnowAgingFactor(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Wichtungsfaktor für die Sensitivität der Albedo für die Alterung des Schnees (weighting factor of albedo sensitivity for snow aging) [-].

Required by the methods:

Calc_ActualAlbedoInz_V1 Calc_ActualAlbedo_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
INIT: Union[int, float, bool, None] = 0.35
name: str = 'snowagingfactor'
unit: str = '-'
class hydpy.models.lland.lland_control.Turb0(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Parameter des Übergangskoeffizienten des turbulenten Wärmestroms (parameter of transition coefficient for turbulent heat flux) [MJ/m²/K/T].

Required by the methods:

Return_BackwardEulerErrorInz_V1 Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_TempSSurface_V1 Return_WLatInz_V1 Return_WLatSnow_V1 Return_WSensInz_V1 Return_WSensSnow_V1 Return_WSurfInz_V1 Update_ESnowInz_V1 Update_ESnow_V1

Parameter Turb0 corresponds to the LARSIM parameter A0.

NDIM: int = 0
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.1728
name: str = 'turb0'
unit: str = 'MJ/m²/K/T'
class hydpy.models.lland.lland_control.Turb1(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Parameter des Übergangskoeffizienten des turbulenten Wärmestroms (parameter of transition coefficient for turbulent heat flux) [(MJ*s)/m³/K/T].

Required by the methods:

Return_BackwardEulerErrorInz_V1 Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_TempSSurface_V1 Return_WLatInz_V1 Return_WLatSnow_V1 Return_WSensInz_V1 Return_WSensSnow_V1 Return_WSurfInz_V1 Update_ESnowInz_V1 Update_ESnow_V1

Parameter Turb0 corresponds to the LARSIM parameter A1.

NDIM: int = 0
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.1728
name: str = 'turb1'
unit: str = '(MJ*s)/m³/K/T'
class hydpy.models.lland.lland_control.Emissivity(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Emissivität der Oberfläche (emissivity) [-]

Required by the methods:

Calc_DailyNetLongwaveRadiation_V1 Calc_EvB_V2 Calc_EvPo_V2 Return_PenmanMonteith_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
INIT: Union[int, float, bool, None] = 0.95
name: str = 'emissivity'
unit: str = '-'
class hydpy.models.lland.lland_control.MeasuringHeightWindSpeed(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The height above ground of the wind speed measurements [m].

Required by the methods:

Calc_WindSpeed10m_V1 Calc_WindSpeed2m_V1 Return_AdjustedWindSpeed_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0, None)
INIT: Union[int, float, bool, None] = 10.0
name: str = 'measuringheightwindspeed'
unit: str = 'm'
class hydpy.models.lland.lland_control.P1Wind(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Konstante der Windgeschwindigkeitsreduktion für Wald (constant for reducing the wind speed in forests) [-].

Required by the method:

Calc_ReducedWindSpeed2m_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
INIT: Union[int, float, bool, None] = 0.6
name: str = 'p1wind'
unit: str = '-'
class hydpy.models.lland.lland_control.P2Wind(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Faktor der Windgeschwindigkeitsreduktion für Wald (factor for reducing the wind speed in forests) [-].

Required by the method:

Calc_ReducedWindSpeed2m_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
INIT: Union[int, float, bool, None] = 0.014285714285714285
name: str = 'p2wind'
unit: str = '-'
class hydpy.models.lland.lland_control.LAI(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Blattflächenindex (leaf area index) [-].

Required by the methods:

Calc_ActualSurfaceResistance_V1 Calc_G_V1 Calc_ReducedWindSpeed2m_V1 Calc_SnowIntMax_V1 Calc_SnowIntRate_V1

NDIM: int = 2
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 5.0
name: str = 'lai'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.HInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Interzeptionskapazität bezogen auf die Blattoberfläche (interception capacity normalized to the leaf surface area) [mm].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.2
name: str = 'hinz'
unit: str = 'mm'
class hydpy.models.lland.lland_control.P1SIMax(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Konstante zur Berechnung der maximalen Schneeinterzeptionskapazität basierend auf dem Blattflächenindex (constant for calculating the maximum snow interception capacity based on the leaf area index) [mm].

Required by the method:

Calc_SnowIntMax_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 8.0
name: str = 'p1simax'
unit: str = 'mm'
class hydpy.models.lland.lland_control.P2SIMax(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Faktor zur Berechnung der maximalen Schneeinterzeptionskapazität basierend auf dem Blattflächenindex (factor for calculating the maximum snow interception capacity based on the leaf area index) [mm].

Required by the method:

Calc_SnowIntMax_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 1.5
name: str = 'p2simax'
unit: str = 'mm'
class hydpy.models.lland.lland_control.P1SIRate(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Konstante zur Berechnung des Verhältnisses von Schneeinerzeptionsrate und Niederschlagsintensität basierend auf dem Blattflächenindex (constant for calculating the ratio of the snow interception rate and the precipitation intensity based on the leaf area index) [-].

Required by the method:

Calc_SnowIntRate_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
INIT: Union[int, float, bool, None] = 0.2
name: str = 'p1sirate'
unit: str = '-'
class hydpy.models.lland.lland_control.P2SIRate(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Faktor zur Berechnung des Verhältnisses von Schneeinerzeptionsrate und Niederschlagsintensität basierend auf dem Blattflächenindex (factor for calculating the ratio of the snow interception rate and precipitation intensity based on the leaf area index) [-].

Required by the method:

Calc_SnowIntRate_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
INIT: Union[int, float, bool, None] = 0.02
name: str = 'p2sirate'
unit: str = '-'
class hydpy.models.lland.lland_control.P3SIRate(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Faktor zur Berechnung des Verhältnisses von Schneeinerzeptionsrate und Niederschlagsintensität basierend auf der bereits interzipierten Schneemenge (factor for calculating the ratio of the snow interception rate and precipitation intensity based on the amount of already intercepted snow) [1/mm].

Required by the method:

Calc_SnowIntRate_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 0.05)
INIT: Union[int, float, bool, None] = 0.003
name: str = 'p3sirate'
unit: str = '1/mm'
class hydpy.models.lland.lland_control.TRefT(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Lufttemperaturgrenzwert des Grad-Tag-Verfahrens (air temperature threshold of the degree-day method) [°C].

Required by the method:

Calc_WGTF_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
INIT: Union[int, float, bool, None] = 0.0
name: str = 'treft'
unit: str = '°C'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.TRefN(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Niederschlagstemperaturgrenzwert des zur Berechnung des Wärmeeintrags durch Regen (precipitation temperature threshold to calculate heat flux caused by liquid precipitation on snow) [°C].

Required by the methods:

Calc_WNiedInz_ESnowInz_V1 Calc_WNied_ESnow_V1 Calc_WNied_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
INIT: Union[int, float, bool, None] = 0.0
name: str = 'trefn'
unit: str = '°C'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.TGr(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Temperaturgrenzwert flüssiger/fester Niederschlag (threshold temperature liquid/frozen precipitation) [°C].

Required by the method:

Calc_SNRatio_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
INIT: Union[int, float, bool, None] = 0.0
name: str = 'tgr'
unit: str = '°C'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.TSp(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Temperaturspanne flüssiger/fester Niederschlag (temperature range with mixed precipitation) [°C].

Required by the method:

Calc_SNRatio_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.0
name: str = 'tsp'
unit: str = '°C'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.GTF(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Grad-Tag-Faktor (factor of the degree-day method) [mm/°C/T].

Required by the method:

Calc_WGTF_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 3.0
name: str = 'gtf'
unit: str = 'mm/°C/T'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.PWMax(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Maximalverhältnis Gesamt- zu Trockenschnee (maximum ratio of the total and the frozen water equivalent stored in the snow cover) [-].

Required by the methods:

Calc_WaDaInz_SInz_V1 Calc_WaDa_WAeS_V1 Calc_WaDa_WAeS_V2 Update_WaDaInz_SInz_V1 Update_WaDa_WAeS_V1

In addition to the parametertools call method, it is possible to set the value of parameter PWMax in accordance to the keyword arguments rhot0 and rhodkrit.

Basic Equation:

\(PWMax = \frac{1.474 \cdot rhodkrit} {rhot0 + 0.474 \cdot rhodkrit}\)

Example:

Using the common values for both rhot0 and rhodkrit…

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(1)
>>> lnk(ACKER)
>>> pwmax(rhot0=0.2345, rhodkrit=0.42)

…results in:

>>> pwmax
pwmax(1.427833)

This is also the default value of PWMax, meaning the relative portion of liquid water in the snow cover cannot exceed 30 %.

Additional error messages try to clarify how to pass parameters:

>>> pwmax(rhot0=0.2345)
Traceback (most recent call last):
...
ValueError: For the calculating parameter `pwmax`, both keyword arguments `rhot0` and `rhodkrit` are required.

>>> pwmax(rho_t_0=0.2345)
Traceback (most recent call last):
...
ValueError: Parameter `pwmax` can be set by directly passing a single value or a list of values, by assigning single values to landuse keywords, or by calculating a value based on the keyword arguments `rhot0` and `rhodkrit`.

Passing landuse specific parameter values is also supported (but not in combination with rhot0 and rhodkrit):

>>> pwmax(acker=2.0, vers=3.0)
>>> pwmax
pwmax(2.0)

The “normal” input error management still works:

>>> pwmax()
Traceback (most recent call last):
...
ValueError: For parameter `pwmax` of element `?` neither a positional nor a keyword argument is given.
NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (1.0, None)
INIT: Union[int, float, bool, None] = 1.4278333871488538
name: str = 'pwmax'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.RefreezeFlag(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Flag um wiedergefrieren zu aktivieren (flag to activate refreezing) [-].

Required by the methods:

Calc_GefrInz_STInz_V1 Calc_Gefr_WATS_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (False, True)
INIT: Union[int, float, bool, None] = 0
name: str = 'refreezeflag'
unit: str = '-'
class hydpy.models.lland.lland_control.KTSchnee(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Effektive Wärmeleitfähigkeit der obersten Schneeschicht (effective thermal conductivity of the top snow layer) [MJ/m²/K/T].

Required by the methods:

Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_TempSSurface_V1 Return_WSurf_V1 Update_ESnow_V1

Note that, at least for application model lland_v3, it is fine to set the value of parameter KTSchnee to inf to disable the explicite modelling of the top snow layer. As a result, the top layer does not dampen the effects of atmospheric influences like radiative heating. Another aspect is that the snow surface temperature does not need to be determined iteratively, as it is always identical with the the snow bulk temperature, which decreases computation times.

NDIM: int = 0
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, inf)
INIT: Union[int, float, bool, None] = 0.432
name: str = 'ktschnee'
unit: str = 'MJ/m²/K/T'
class hydpy.models.lland.lland_control.WG2Z(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Bodenwärmestrom in der Tiefe 2z (soil heat flux at depth 2z) [MJ/m²/d].

Required by the methods:

Calc_G_V1 Calc_G_V2 Update_EBdn_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
INIT: Union[int, float, bool, None] = 0.0
name: str = 'wg2z'
unit: str = 'MJ/m²/d'
class hydpy.models.lland.lland_control.KF(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Küstenfaktor (“coast factor” of Turc-Wendling’s evaporation equation [-].

Required by the method:

Calc_ET0_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.6, 1.0)
INIT: Union[int, float, bool, None] = 1.0
name: str = 'kf'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.WfET0(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Zeitlicher Wichtungsfaktor der Grasreferenzverdunsung (temporal weighting factor for reference evapotranspiration).

Required by the method:

Calc_ET0_WET0_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
name: str = 'wfet0'
unit: str = '?'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.FLn(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Landnutzungsabhängiger Verdunstungsfaktor (factor for adjusting reference evapotranspiration to different land use classes) [-].

Required by the method:

Calc_EvPo_V1

NDIM: int = 2
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 1.0
name: str = 'fln'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.GrasRef_R(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Bodenfeuchte-Verdunstung-Parameter (soil moisture-dependent evaporation factor) [-].

Required by the method:

Calc_EvB_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 5.0
name: str = 'grasref_r'
unit: str = '-'
class hydpy.models.lland.lland_control.CropHeight(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Crop height [m].

Required by the method:

Calc_AerodynamicResistance_V1

NDIM: int = 2
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.0
name: str = 'cropheight'
unit: str = 'm'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.SurfaceResistance(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Surface Resistance [s/m].

Required by the method:

Calc_LanduseSurfaceResistance_V1

NDIM: int = 2
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.0
name: str = 'surfaceresistance'
unit: str = 's/m'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.WMax(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Maximaler Bodenwasserspeicher (maximum soil water storage) [mm].

Required by the methods:

Calc_BoWa_V1 Calc_EvB_V1 Calc_QBB_V1 Calc_QDB_V1 Calc_QIB1_V1 Calc_QIB2_V1 Calc_QKap_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 100.0
trim(lower=None, upper=None)[source]

Trim values in accordance with \(PWP \leq FK \leq WMax\).

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> lnk(ACKER)

>>> pwp(20.0)
>>> wmax(10.0, 50.0, 90.0)
>>> wmax
wmax(20.0, 50.0, 90.0)

>>> fk.values = 60.0
>>> wmax.trim()
>>> wmax
wmax(60.0, 60.0, 90.0)
name: str = 'wmax'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.FK(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Feldkapazität / Mindestbodenfeuchte für die Interflowentstehung (field capacity / threshold value of soil moisture for interflow generation) [mm].

Required by the methods:

Calc_QBB_V1 Calc_QIB2_V1

Note that one can define the values of parameter FK via the keyword argument relative, as explained in the documentation on class ParameterSoilThreshold.

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.0
trim(lower=None, upper=None)[source]

Trim upper values in accordance with \(PWP \leq FK \leq WMax\).

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> lnk(ACKER)
>>> pwp(20.0)
>>> wmax(80.0)
>>> fk(10.0, 50.0, 90.0)
>>> fk
fk(20.0, 50.0, 80.0)
name: str = 'fk'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.PWP(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Permanenter Welkepunkt / Mindestbodenfeuchte für die Basisabflussentstehung (permanent wilting point threshold value of soil moisture for base flow generation) [mm].

Required by the methods:

Calc_QBB_V1 Calc_QIB1_V1 Calc_SoilSurfaceResistance_V1

Note that one can define the values of parameter PWP via the keyword argument relative, as explained in the documentation on class ParameterSoilThreshold.

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.0
trim(lower=None, upper=None)[source]

Trim values in accordance with \(PWP \leq FK \leq WMax\).

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> lnk(ACKER)
>>> wmax(100.0)
>>> pwp(-10.0, 50.0, 110.0)
>>> pwp
pwp(0.0, 50.0, 100.0)

>>> fk.values = 80.0
>>> pwp.trim()
>>> pwp
pwp(0.0, 50.0, 80.0)
name: str = 'pwp'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.PY(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Permanenter Welkepunkt / Schwellenwert für den Anteil des für Pflanzen gebundenen Bodenwassers (permanent wilting point) [mm].

Required by the method:

Calc_LanduseSurfaceResistance_V1

Note that one can define the values of parameter PY via the keyword argument relative, as explained in the documentation on class ParameterSoilThreshold.

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.0
trim(lower=None, upper=None)[source]

Trim values in accordance with \(PY \leq WMax\).

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> lnk(ACKER)
>>> wmax(100.0)
>>> py(-10.0, 50.0, 110.0)
>>> py
py(0.0, 50.0, 100.0)
name: str = 'py'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.BSf(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Bodenfeuchte-Sättigungsfläche-Parameter (shape parameter for the relation between the avarage soil moisture and the relative saturated area of a subbasin) [-].

Required by the method:

Calc_QDB_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.4
name: str = 'bsf'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.FVF(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Frostversiegelungsfaktor zur Ermittelung des Frostversiegelungsgrades (frost sealing factor for determination of the degree of frost sealing FVG) [-].

Required by the method:

Calc_FVG_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.5
name: str = 'fvf'
unit: str = '-'
class hydpy.models.lland.lland_control.BSFF(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Exponent zur Ermittelung des Frostversieglungsgrades (frost sealing exponent for determination of degree of frost sealing FVG) [-].

Required by the method:

Calc_FVG_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 2.0
name: str = 'bsff'
unit: str = '-'
class hydpy.models.lland.lland_control.DMin(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Drainageindex des mittleren Bodenspeichers (flux rate for releasing interflow from the middle soil compartment) [mm/T].

Required by the methods:

Calc_QIB1_V1 Calc_QIB2_V1

In addition to the ParameterSoil __call__ method, it is possible to set the value of parameter DMin in accordance to the keyword argument r_dmin due to compatibility reasons with the original LARSIM implementation:

\(Dmin = 0.001008 \cdot hours \cdot r_dmin\)

Example:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep("1h")
>>> nhru(1)
>>> lnk(ACKER)
>>> dmin(r_dmin=10.0)
>>> dmin
dmin(0.01008)
>>> dmin.values
array([ 0.24192])

A wrong keyword results in the right answer:

>>> dmin(rdmin=10.0)
Traceback (most recent call last):
...
TypeError: While trying to set the values of parameter `dmin` of element `?` based on keyword arguments `rdmin`, the following error occurred: Keyword `rdmin` is not among the available model constants.
NDIM: int = 1
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.0
trim(lower=None, upper=None)[source]

Trim upper values in accordance with \(DMin \leq DMax\).

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> simulationstep("12h")
>>> nhru(5)
>>> lnk(ACKER)
>>> dmax.values = 2.0
>>> dmin(-2.0, 0.0, 2.0, 4.0, 6.0)
>>> dmin
dmin(0.0, 0.0, 2.0, 4.0, 4.0)
name: str = 'dmin'
unit: str = 'mm/T'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.DMax(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Drainageindex des oberen Bodenspeichers (additional flux rate for releasing interflow from the upper soil compartment) [mm/T].

Required by the method:

Calc_QIB2_V1

In addition to the ParameterSoil __call__ method, it is possible to set the value of parameter DMax in accordance to the keyword argument r_dmax due to compatibility reasons with the original LARSIM implemetation.

Basic Equation:

\(Dmax = 2.4192 \cdot r_dmax\)

Example:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> from hydpy.models.lland import *
>>> parameterstep("1h")
>>> nhru(1)
>>> lnk(ACKER)
>>> dmax(r_dmax=10.0)
>>> dmax
dmax(1.008)
>>> dmax.values
array([ 24.192])

A wrong keyword results in the right answer:

>>> dmax(rdmax=10.0)
Traceback (most recent call last):
...
TypeError: While trying to set the values of parameter `dmax` of element `?` based on keyword arguments `rdmax`, the following error occurred: Keyword `rdmax` is not among the available model constants.
NDIM: int = 1
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
INIT: Union[int, float, bool, None] = 1.0
trim(lower=None, upper=None)[source]

Trim upper values in accordance with \(DMax \geq DMin\).

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> simulationstep("12h")
>>> nhru(3)
>>> lnk(ACKER)
>>> dmin.values = 2.0
>>> dmax(2.0, 4.0, 6.0)
>>> dmax
dmax(4.0, 4.0, 6.0)
name: str = 'dmax'
unit: str = 'mm/T'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.Beta(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Drainageindex des tiefen Bodenspeichers (storage coefficient for releasing base flow from the lower soil compartment) [1/T].

Required by the method:

Calc_QBB_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.01
name: str = 'beta'
unit: str = '1/T'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.FBeta(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Faktor zur Erhöhung der Perkolation im Grobporenbereich (factor for increasing percolation under wet conditions) [-].

Required by the method:

Calc_QBB_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (1.0, None)
INIT: Union[int, float, bool, None] = 1.0
name: str = 'fbeta'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.KapMax(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Maximale kapillare Aufstiegsrate (maximum capillary rise) [mm/T].

Required by the method:

Calc_QKap_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.0
name: str = 'kapmax'
unit: str = 'mm/T'
subvars: SubVariablesType
class hydpy.models.lland.lland_control.KapGrenz(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Grenzwerte für den kapillaren Aufstieg (threshold values related to the capillary rise) [mm].

Required by the method:

Calc_QKap_V1

Parameter KapGrenz actually consists of two types of parameter values. Both are thresholds and related to the soil water content. If the actual soil water content is smaller than or equal to the first threshold, capillary rise reaches its maximum value. If the actual water content is larger than or equal to the second threshold, there is no capillary rise at all. In between, the soil water content and the capillary rise are inversely related (linear interpolation).

In the following example, the we set the lower threshold of all three hydrological response units to 10 mm and the upper one to 40 mm:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> simulationstep ("12h")
>>> nhru(3)
>>> kapgrenz(10.0, 40.0)
>>> kapgrenz
kapgrenz([[10.0, 40.0],
          [10.0, 40.0],
          [10.0, 40.0]])

The next example shows how assign different threshold pairs to each response unit:

>>> kapgrenz([10.0, 40.0], [20., 60.0], [30., 80.0])
>>> kapgrenz
kapgrenz([[10.0, 40.0],
          [20.0, 60.0],
          [30.0, 80.0]])

It works equally well to pass a complete matrix, of course:

>>> kapgrenz([[10.0, 40.0],
...           [20.0, 60.0],
...           [30.0, 80.0]])
>>> kapgrenz
kapgrenz([[10.0, 40.0],
          [20.0, 60.0],
          [30.0, 80.0]])

It is also fine to pass a single value, in case you prefer a sharp transition between zero and maximum capillary rise:

>>> kapgrenz(30.0)
>>> kapgrenz
kapgrenz(30.0)

For convenience and better compatibility with the original LARSIM model, we provide the keyword argument option. Simply pass an option name and then parameter KapGrenz itself calculates suitable threshold values based on soil properties.

The first possible string is FK. When passing this string, the current value of parameter FK serves both as the lower and the upper threshold, which is in agreement with the LARSIM option KAPILLARER AUFSTIEG:

>>> fk(60.0, 120.0, 180.0)
>>> kapgrenz(option="FK")
>>> kapgrenz
kapgrenz([[60.0, 60.0],
          [120.0, 120.0],
          [180.0, 180.0]])

The second possible string is 0_WMax/10, which corresponds to the LARSIM option KOPPELUNG BODEN/GRUNDWASSER, where the lower and upper threshold are zero and 10 % of the current value of parameter WMax, respectively:

>>> wmax(100.0, 150.0, 200.0)
>>> kapgrenz(option="0_WMax/10")
>>> kapgrenz
kapgrenz([[0.0, 10.0],
          [0.0, 15.0],
          [0.0, 20.0]])

The third possible string is FK/2_FK where the lower and the upper threshold are 50 % and 100 % of the value of parameter NFk, which does not correspond to any available LARSIM option:

>>> kapgrenz(option="FK/2_FK")
>>> kapgrenz
kapgrenz([[30.0, 60.0],
          [60.0, 120.0],
          [90.0, 180.0]])

Wrong keyword arguments result in errors like the following:

>>> kapgrenz(option1="FK", option2="0_WMax/10")
Traceback (most recent call last):
...
ValueError: Parameter `kapgrenz` of element `?` does not accept multiple keyword arguments, but the following are given: option1 and option2

>>> kapgrenz(option1="FK")
Traceback (most recent call last):
...
ValueError: Besides the standard keyword arguments, parameter `kapgrenz` of element `?` does only support the keyword argument `option`, but `option1` is given.

>>> kapgrenz(option="NFk")
Traceback (most recent call last):
...
ValueError: Parameter `kapgrenz` of element `?` supports the options `FK`, `0_WMax/10`, and `FK/2_FK`, but `NFk` is given.
NDIM: int = 2
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
INIT: Union[int, float, bool, None] = 0.0
name: str = 'kapgrenz'
unit: str = 'mm'
class hydpy.models.lland.lland_control.RBeta(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Boolscher Parameter der steuert, ob the Perkolation unterhalb der Feldkapazität auf Null reduziert wird (flag to indicate if seepage is reduced to zero below field capacity) [-].

Required by the method:

Calc_QBB_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (False, True)
INIT: Union[int, float, bool, None] = False
name: str = 'rbeta'
unit: str = '-'
class hydpy.models.lland.lland_control.VolBMax(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Maximaler Inhalt des Gebietsspeichers für Basisabfluss (maximum value of the storage compartment for base flow) [mm].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = inf
name: str = 'volbmax'
unit: str = 'mm'
class hydpy.models.lland.lland_control.GSBMax(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Faktor zur Anpassung von VolBMax (factor for adjusting VolBMax) [-].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 1.0
name: str = 'gsbmax'
unit: str = '-'
class hydpy.models.lland.lland_control.GSBGrad1(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Höchste Volumenzunahme des Gebietsspeichers für Basisabfluss ohne Begrenzung des Zuflusses (highest possible storage increase of the compartment for base flow without inflow reductions) [mm/T].

Required by the method:

Update_QDGZ_QBGZ_QBGA_V2

NDIM: int = 0
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
INIT: Union[int, float, bool, None] = inf
trim(lower=None, upper=None)[source]

Trim upper values in accordance with \(GSBGrad1 \leq GSBGrad2\).

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep("1d")
>>> gsbgrad2(1.0)
>>> gsbgrad1(0.0)
>>> gsbgrad1
gsbgrad1(0.0)
>>> gsbgrad1(1.0)
>>> gsbgrad1
gsbgrad1(1.0)
>>> gsbgrad1(2.0)
>>> gsbgrad1
gsbgrad1(1.0)
name: str = 'gsbgrad1'
unit: str = 'mm/T'
class hydpy.models.lland.lland_control.GSBGrad2(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Volumenzunahme des Gebietsspeichers für Basisabfluss, oberhalb der jeglicher Zufluss ausgeschlossen ist (highest possible storage increase of the compartment for base flow) [mm/T].

Required by the method:

Update_QDGZ_QBGZ_QBGA_V2

NDIM: int = 0
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
INIT: Union[int, float, bool, None] = inf
trim(lower=None, upper=None)[source]

Trim upper values in accordance with \(GSBGrad1 \leq GSBGrad2\).

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep("1d")
>>> gsbgrad1(1.0)
>>> gsbgrad2(2.0)
>>> gsbgrad2
gsbgrad2(2.0)
>>> gsbgrad2(1.0)
>>> gsbgrad2
gsbgrad2(1.0)
>>> gsbgrad2(0.0)
>>> gsbgrad2
gsbgrad2(1.0)
name: str = 'gsbgrad2'
unit: str = 'mm/T'
class hydpy.models.lland.lland_control.A1(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Parameter für die kontinuierliche Aufteilung der Direktabflusskomponenten (threshold value for the continuous seperation of direct runoff in a slow and a fast component) [mm/T]

Required by the method:

Calc_QDGZ1_QDGZ2_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = inf
name: str = 'a1'
unit: str = 'mm/T'
class hydpy.models.lland.lland_control.A2(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Parameter für die diskontinuierliche Aufteilung der Direktabflusskomponenten (threshold value for the discontinuous seperation of direct runoff in a slow and a fast component) [mm/T]

Required by the method:

Calc_QDGZ1_QDGZ2_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.0
name: str = 'a2'
unit: str = 'mm/T'
class hydpy.models.lland.lland_control.TInd(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Fließzeitindex (factor related to the time of concentration) [T].

In addition to the Parameter call method, it is possible to set the value of parameter TInd in accordance to the keyword arguments tal (talweg, [km]), hot (higher reference altitude, [m]), and hut (lower reference altitude, [m]). This is supposed to decrease the time of runoff concentration in small and/or steep catchments. Note that TInd does not only affect direct runoff, but interflow and base flow as well. Hence it seems advisable to use this regionalization strategy with caution.

Basic Equation:

\(TInd[h] = (0.868 \cdot \frac{Tal^3}{HOT-HUT})^{0.385}\)

Examples:

Using typical values:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> simulationstep("12h")
>>> tind(tal=5.0, hot=210.0, hut=200.0)
>>> tind
tind(0.104335)

Note that this result is related to the selected parameter step size of one day. The value related to the selected simulation step size of 12 hours is:

>>> from hydpy import round_
>>> round_(tind.value)
0.20867

Unplausible input values lead to the following exceptions:

>>> tind(tal=5.0, hot=200.0, hut=200.0)
Traceback (most recent call last):
...
ValueError: For the alternative calculation of parameter `tind`, the value assigned to keyword argument `tal` must be greater then zero and the one of `hot` must be greater than the one of `hut`.  However, for element ?, the values `5.0`, `200.0` and `200.0` were given respectively.

>>> tind(tal=0.0, hot=210.0, hut=200.0)
Traceback (most recent call last):
...
ValueError: For the alternative calculation of parameter `tind`, the value assigned to keyword argument `tal` must be greater then zero and the one of `hot` must be greater than the one of `hut`.  However, for element ?, the values `0.0`, `210.0` and `200.0` were given respectively.

However, it is hard to define exact bounds for the value of TInd itself. Whenever it is below 0.001 or above 1000 days, the following warning is given:

>>> tind(tal=0.001, hot=210.0, hut=200.0)
Traceback (most recent call last):
...
UserWarning: Due to the given values for the keyword arguments `tal` (0.001), `hot` (210.0) and `hut` (200.0), parameter `tind` of element `?` has been set to an unrealistic value of 0.000134 hours.

Additionally, exceptions for missing (or wrong) keywords are implemented

>>> tind(tal=5.0, hot=210.0)
Traceback (most recent call last):
...
ValueError: For the alternative calculation of parameter `tind`, values for all three keyword keyword arguments `tal`, `hot`, and `hut` must be given.
NDIM: int = 0
TYPE
TIME: Optional[bool] = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 1.0
name: str = 'tind'
unit: str = 'T'
class hydpy.models.lland.lland_control.EQB(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Kalibrierfaktor für die Basisabflusskonzentration (factor for adjusting the concentration time of baseflow). [-].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 5000.0
name: str = 'eqb'
unit: str = '-'
class hydpy.models.lland.lland_control.EQI1(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Kalibrierfaktor für die “untere” Zwischenabflusskonzentration (factor for adjusting the concentration time of the first interflow component) [-].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 2000.0
trim(lower=None, upper=None)[source]

Trim upper values in accordance with \(EQI2 \leq EQI1\).

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> eqi2.value = 1.0
>>> eqi1(0.0)
>>> eqi1
eqi1(1.0)
>>> eqi1(1.0)
>>> eqi1
eqi1(1.0)
>>> eqi1(2.0)
>>> eqi1
eqi1(2.0)
name: str = 'eqi1'
unit: str = '-'
class hydpy.models.lland.lland_control.EQI2(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Kalibrierfaktor für die “obere” Zwischenabflusskonzentration (factor for adjusting the concentration time of the second interflow component) [-].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 1000.0
trim(lower=None, upper=None)[source]

Trim upper values in accordance with \(EQI2 \leq EQI1\).

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> eqi1.value = 3.0
>>> eqi2(2.0)
>>> eqi2
eqi2(2.0)
>>> eqi2(3.0)
>>> eqi2
eqi2(3.0)
>>> eqi2(4.0)
>>> eqi2
eqi2(3.0)
name: str = 'eqi2'
unit: str = '-'
class hydpy.models.lland.lland_control.EQD1(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Kalibrierfaktor für die langsamere Direktabflusskonzentration (factor for adjusting the concentration time of the slower component of direct runoff). [-].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 100.0
trim(lower=None, upper=None)[source]

Trim upper values in accordance with \(EQD2 \leq EQD1\).

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> eqd2.value = 1.0
>>> eqd1(0.0)
>>> eqd1
eqd1(1.0)
>>> eqd1(1.0)
>>> eqd1
eqd1(1.0)
>>> eqd1(2.0)
>>> eqd1
eqd1(2.0)
name: str = 'eqd1'
unit: str = '-'
class hydpy.models.lland.lland_control.EQD2(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Kalibrierfaktor für die schnellere Direktabflusskonzentration (factor for adjusting the concentration time of the faster component of direct runoff). [-].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 50.0
trim(lower=None, upper=None)[source]

Trim upper values in accordance with \(EQD2 \leq EQD1\).

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> eqd1.value = 3.0
>>> eqd2(2.0)
>>> eqd2
eqd2(2.0)
>>> eqd2(3.0)
>>> eqd2
eqd2(3.0)
>>> eqd2(4.0)
>>> eqd2
eqd2(3.0)
name: str = 'eqd2'
unit: str = '-'
class hydpy.models.lland.lland_control.NegQ(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Option: sind negative Abflüsse erlaubt (flag that indicated wether negative discharge values are allowed or not) [-].

Required by the method:

Calc_QAH_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = False
name: str = 'negq'
unit: str = '-'

Derived parameters

class hydpy.models.lland.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 lland.

The following classes are selected:

  • MOY() References the “global” month of the year index array [-].

  • DOY() References the “global” day of the year index array [-].

  • Seconds() The length of the actual simulation step size in seconds [s].

  • Hours() The length of the actual simulation step size in hours [h].

  • Days() The length of the actual simulation step size in days [d].

  • SCT() References the “global” standard clock time array [-].

  • UTCLongitude() Longitude of the centre of the local time zone [°].

  • NmbLogEntries() The number of log entries required for a memory duration of 24 hours [-].

  • LatitudeRad() The latitude [rad].

  • AbsFHRU() Flächen der Hydrotope (areas of the respective HRUs) [km²].

  • KInz() Interzeptionskapazität bezogen auf die Bodenoberfläche (interception capacity normalized to the soil surface area) [mm].

  • HeatOfFusion() Heat which is necessary to melt the frozen soil water content.

  • Fr() Reduktionsfaktor für Strahlung [4] (basierend auf [6]) (reduction factor for short- and long wave radiation) [4] (based on [6]) [-].

  • NFk() Nutzbare Feldkapazität (usable field capacity) [mm].

  • KB() Konzentrationszeit des Basisabflusses (concentration time of baseflow) [T].

  • KI1() Konzentrationszeit des “unteren” Zwischenabflusses (concentration time of the first interflow component) [T].

  • KI2() Konzentrationszeit des “oberen” Zwischenabflusses” (concentration time of the second interflow component) [T].

  • KD1() Konzentrationszeit des “langsamen” Direktabflusses (concentration time of the slower component of direct runoff) [T].

  • KD2() Konzentrationszeit des “schnellen” Direktabflusses (concentration time of the faster component of direct runoff) [T].

  • QBGAMax() Maximaler Abfluss aus dem Basisabfluss-Gebietsspeicher (maximum outflow from the storage compartment for base flow) [mm/T].

  • QFactor() Factor for converting mm/stepsize to m³/s.

class hydpy.models.lland.lland_derived.MOY(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

References the “global” month of the year index array [-].

Required by the methods:

Calc_ActualAlbedo_V1 Calc_ActualSurfaceResistance_V1 Calc_AerodynamicResistance_V1 Calc_DailyGlobalRadiation_V1 Calc_EvPo_V1 Calc_G_V1 Calc_G_V2 Calc_GlobalRadiation_V1 Calc_LanduseSurfaceResistance_V1 Calc_NBes_Inzp_V1 Calc_NetShortwaveRadiationInz_V1 Calc_NetShortwaveRadiationSnow_V1 Calc_ReducedWindSpeed2m_V1 Calc_SnowIntMax_V1 Calc_SnowIntRate_V1 Return_BackwardEulerErrorInz_V1 Return_BackwardEulerError_V1 Return_DailyGlobalRadiation_V1 Return_EnergyGainSnowSurface_V1 Return_NetLongwaveRadiationInz_V1 Return_NetLongwaveRadiationSnow_V1 Return_TempSSurface_V1 Return_WSurfInz_V1 Update_EBdn_V1 Update_ESnowInz_V1 Update_ESnow_V1

name: str = 'moy'
unit: str = '-'
class hydpy.models.lland.lland_derived.DOY(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

References the “global” day of the year index array [-].

Required by the methods:

Calc_EarthSunDistance_V1 Calc_SolarDeclination_V1

name: str = 'doy'
unit: str = '-'
class hydpy.models.lland.lland_derived.Seconds(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The length of the actual simulation step size in seconds [s].

Required by the methods:

Calc_EvB_V2 Calc_EvPo_V2 Return_PenmanMonteith_V1 Update_ASInz_V1 Update_TauS_V1

name: str = 'seconds'
unit: str = 's'
class hydpy.models.lland.lland_derived.Hours(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The length of the actual simulation step size in hours [h].

Required by the methods:

Calc_ActualSurfaceResistance_V1 Calc_G_V1 Calc_PossibleSunshineDuration_V1 Calc_SP_V1

name: str = 'hours'
unit: str = 'h'
class hydpy.models.lland.lland_derived.Days(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The length of the actual simulation step size in days [d].

Required by the methods:

Calc_DailyGlobalRadiation_V1 Calc_EvPo_V2 Calc_G_V2 Calc_GlobalRadiation_V1 Calc_NetRadiation_V1 Calc_RLAtm_V1 Return_BackwardEulerErrorInz_V1 Return_BackwardEulerError_V1 Return_DailyGlobalRadiation_V1 Return_EnergyGainSnowSurface_V1 Return_NetLongwaveRadiationInz_V1 Return_NetLongwaveRadiationSnow_V1 Return_Penman_V1 Return_TempSSurface_V1 Return_WSurfInz_V1 Update_EBdn_V1 Update_ESnowInz_V1 Update_ESnow_V1

name: str = 'days'
unit: str = 'd'
class hydpy.models.lland.lland_derived.SCT(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

References the “global” standard clock time array [-].

Required by the methods:

Calc_PossibleSunshineDuration_V1 Calc_SP_V1

name: str = 'sct'
unit: str = '-'
class hydpy.models.lland.lland_derived.UTCLongitude(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Longitude of the centre of the local time zone [°].

Required by the method:

Calc_TSA_TSU_V1

name: str = 'utclongitude'
unit: str = '°'
class hydpy.models.lland.lland_derived.NmbLogEntries(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The number of log entries required for a memory duration of 24 hours [-].

Required by the methods:

Calc_AdjustedGlobalRadiation_V1 Calc_DailyRelativeHumidity_V1 Calc_DailySunshineDuration_V1 Calc_DailyWindSpeed2m_V1 Calc_TemLTag_V1 Update_LoggedGlobalRadiation_V1 Update_LoggedRelativeHumidity_V1 Update_LoggedSunshineDuration_V1 Update_LoggedTemL_V1 Update_LoggedWindSpeed2m_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (1, None)
update()[source]

Calculate the number of entries and adjust the shape of all relevant log sequences.

The aimed memory duration is one day. Hence, the number of the required log entries depends on the simulation step size:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> from hydpy import pub
>>> nhru(2)
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1h"
>>> derived.nmblogentries.update()
>>> derived.nmblogentries
nmblogentries(24)
>>> logs
wet0([[nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
       nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]])
loggedteml(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
           nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan)
loggedrelativehumidity(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
                       nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
                       nan, nan, nan, nan)
loggedsunshineduration(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
                       nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
                       nan, nan, nan, nan)
loggedglobalradiation(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
                      nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
                      nan, nan, nan, nan)
loggedwindspeed2m(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
                  nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
                  nan, nan)

To prevent from loosing information, updating parameter NmbLogEntries resets the shape of the relevant log sequences only when necessary:

>>> logs.wet0 = 1.0
>>> logs.loggedteml = 2.0
>>> logs.loggedrelativehumidity.shape = (6,)
>>> logs.loggedrelativehumidity = 3.0
>>> derived.nmblogentries.update()
>>> logs   
wet0([[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
       1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]])
loggedteml(2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0,
           2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0)
loggedrelativehumidity(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
                       nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
                       nan, nan, nan, nan)
...

There is an explicit check for inappropriate simulation step sizes:

>>> pub.timegrids = "2000-01-01 00:00", "2000-01-01 10:00", "5h"
>>> derived.nmblogentries.update()
Traceback (most recent call last):
...
ValueError: The value of parameter `nmblogentries` of element `?` cannot be determined for a the current simulation step size.  The fraction of the memory period (1d) and the simulation step size (5h) leaves a remainder.
name: str = 'nmblogentries'
unit: str = '-'
class hydpy.models.lland.lland_derived.LatitudeRad(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The latitude [rad].

Required by the methods:

Calc_ExtraterrestrialRadiation_V1 Calc_TSA_TSU_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (-1.5708, 1.5708)
update()[source]

Update LatitudeRad based on parameter Latitude.

>>> from hydpy import round_
>>> from hydpy.models.lland import *
>>> parameterstep()
>>> for value in (-90.0, -45.0, 0.0, 45.0, 90.0):
...     latitude(value)
...     derived.latituderad.update()
...     round_(latitude.value, end=": ")
...     round_(derived.latituderad.value)
-90.0: -1.570796
-45.0: -0.785398
0.0: 0.0
45.0: 0.785398
90.0: 1.570796
name: str = 'latituderad'
unit: str = 'rad'
class hydpy.models.lland.lland_derived.AbsFHRU(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Flächen der Hydrotope (areas of the respective HRUs) [km²].

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
update()[source]

Update AbsFHRU based on FT and FHRU.

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(2)
>>> lnk(ACKER)
>>> ft(100.0)
>>> fhru(0.2, 0.8)
>>> derived.absfhru.update()
>>> derived.absfhru
absfhru(20.0, 80.0)
name: str = 'absfhru'
unit: str = 'km²'
subvars: SubVariablesType
class hydpy.models.lland.lland_derived.KInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Interzeptionskapazität bezogen auf die Bodenoberfläche (interception capacity normalized to the soil surface area) [mm].

Required by the method:

Calc_NBes_Inzp_V1

NDIM: int = 2
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
update()[source]

Update KInz based on HInz and LAI [4] (based on [16]).

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(2)
>>> hinz(0.2)
>>> lai.acker_jun = 1.0
>>> lai.vers_dec = 2.0
>>> derived.kinz.update()
>>> from hydpy import round_
>>> round_(derived.kinz.acker_jun)
0.2
>>> round_(derived.kinz.vers_dec)
0.4
name: str = 'kinz'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_derived.HeatOfFusion(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Heat which is necessary to melt the frozen soil water content.

Required by the method:

Calc_TZ_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
update()[source]

Update HeatOfFusion based on RSchmelz and BoWa2Z.

Basic equation:

\(HeatOfFusion = RSchmelz \cdot BoWa2Z\)

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(2)
>>> lnk(ACKER, LAUBW)
>>> derived.heatoffusion.update()
>>> derived.heatoffusion
heatoffusion(26.72)
name: str = 'heatoffusion'
unit: str = '?'
subvars: SubVariablesType
class hydpy.models.lland.lland_derived.Fr(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Reduktionsfaktor für Strahlung [4] (basierend auf [6]) (reduction factor for short- and long wave radiation) [4] (based on [6]) [-].

Required by the methods:

Calc_NetShortwaveRadiationInz_V1 Calc_NetShortwaveRadiationSnow_V1 Return_BackwardEulerErrorInz_V1 Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_NetLongwaveRadiationInz_V1 Return_NetLongwaveRadiationSnow_V1 Return_TempSSurface_V1 Return_WSurfInz_V1 Update_ESnowInz_V1 Update_ESnow_V1

NDIM: int = 2
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
update()[source]

Update Fr based on LAI, P1Strahl and P2Strahl.

Basic equation for forests:

\(Fr = P1Strahl - P2Strahl \cdot LAI\)

Note that Fr is one for all other land use classes than LAUBW, MISCHW, and NADELW, and that we do not trim Fr to prevent negative values for large leaf area index values:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> p1strahl(0.5)
>>> p2strahl(0.1)
>>> lai.acker_jan = 1.0
>>> lai.laubw_feb = 3.0
>>> lai.mischw_mar = 5.0
>>> lai.nadelw_apr = 7.0
>>> derived.fr.update()
>>> from hydpy import round_
>>> round_(derived.fr.acker_jan)
1.0
>>> round_(derived.fr.laubw_feb)
0.2
>>> round_(derived.fr.mischw_mar)
0.0
>>> round_(derived.fr.nadelw_apr)
-0.2
name: str = 'fr'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_derived.NFk(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Nutzbare Feldkapazität (usable field capacity) [mm].

Required by the method:

Calc_SoilSurfaceResistance_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
update()[source]

Update NFk based on PWP and FK.

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(1)
>>> lnk(ACKER)
>>> fk(100.0)
>>> pwp(20.0)
>>> derived.nfk.update()
>>> derived.nfk
nfk(80.0)
name: str = 'nfk'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_derived.KB(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Konzentrationszeit des Basisabflusses (concentration time of baseflow) [T].

Required by the methods:

Calc_QBGA_V1 Update_QDGZ_QBGZ_QBGA_V1 Update_QDGZ_QBGZ_QBGA_V2

NDIM: int = 0
TYPE
TIME: Optional[bool] = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
update()[source]

Update KB based on EQB and TInd.

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep("1d")
>>> eqb(10.0)
>>> tind(10.0)
>>> derived.kb.update()
>>> derived.kb
kb(100.0)
name: str = 'kb'
unit: str = 'T'
class hydpy.models.lland.lland_derived.KI1(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Konzentrationszeit des “unteren” Zwischenabflusses (concentration time of the first interflow component) [T].

Required by the method:

Calc_QIGA1_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
update()[source]

Update KI1 based on EQI1 and TInd.

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep("1d")
>>> eqi1(5.0)
>>> tind(10.0)
>>> derived.ki1.update()
>>> derived.ki1
ki1(50.0)
name: str = 'ki1'
unit: str = 'T'
class hydpy.models.lland.lland_derived.KI2(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Konzentrationszeit des “oberen” Zwischenabflusses” (concentration time of the second interflow component) [T].

Required by the method:

Calc_QIGA2_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
update()[source]

Update KI2 based on EQI2 and TInd.

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep("1d")
>>> eqi2(1.0)
>>> tind(10.0)
>>> derived.ki2.update()
>>> derived.ki2
ki2(10.0)
name: str = 'ki2'
unit: str = 'T'
class hydpy.models.lland.lland_derived.KD1(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Konzentrationszeit des “langsamen” Direktabflusses (concentration time of the slower component of direct runoff) [T].

Required by the method:

Calc_QDGA1_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
update()[source]

Update KD1 based on EQD1 and TInd.

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep("1d")
>>> eqd1(0.5)
>>> tind(10.0)
>>> derived.kd1.update()
>>> derived.kd1
kd1(5.0)
name: str = 'kd1'
unit: str = 'T'
class hydpy.models.lland.lland_derived.KD2(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Konzentrationszeit des “schnellen” Direktabflusses (concentration time of the faster component of direct runoff) [T].

Required by the method:

Calc_QDGA2_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
update()[source]

Update KD2 based on EQD2 and TInd.

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep("1d")
>>> eqd2(0.1)
>>> tind(10.0)
>>> derived.kd2.update()
>>> derived.kd2
kd2(1.0)
name: str = 'kd2'
unit: str = 'T'
class hydpy.models.lland.lland_derived.QBGAMax(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Maximaler Abfluss aus dem Basisabfluss-Gebietsspeicher (maximum outflow from the storage compartment for base flow) [mm/T].

Required by the method:

Update_QDGZ_QBGZ_QBGA_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
update()[source]

Update based on \(QBGAMax = (GSBMax \cdot VolBMax) / KB\).

>>> from hydpy.models.lland import *
>>> simulationstep("1h")
>>> parameterstep("1d")
>>> volbmax(100.0)
>>> gsbmax(2.0)
>>> derived.kb(50.0)
>>> derived.qbgamax.update()
>>> derived.qbgamax
qbgamax(4.0)

For zero runoff concentration time, we generally set QBGAMax to zero, even if VolBMax is also to zero:

>>> volbmax(0.0)
>>> derived.kb(0.0)
>>> derived.qbgamax.update()
>>> derived.qbgamax
qbgamax(inf)
name: str = 'qbgamax'
unit: str = 'mm/T'
class hydpy.models.lland.lland_derived.QFactor(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Factor for converting mm/stepsize to m³/s.

Required by the methods:

Calc_QA_V1 Calc_QZH_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
update()[source]

Update QFactor based on FT and the current simulation step size.

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> simulationstep("1d")
>>> ft(10.0)
>>> derived.qfactor.update()
>>> derived.qfactor
qfactor(0.115741)
name: str = 'qfactor'
unit: str = '?'

Fixed parameters

class hydpy.models.lland.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 lland.

The following classes are selected:

  • CPWasser() Spezifische Wärmekapazität von Wasser (specific heat capacity of water) [MJ/mm/K].

  • CPEis() Spezifische Wärmekapazität von Eis bei 0 °C (specific heat capacity of ice at a temperature of 0 °C) [MJ/mm/K].

  • RSchmelz() Spezifische Schmelzwärme von Wasser (specific melt heat of water) [MJ/mm].

  • Pi() π [-].

  • Z() Halbe Mächtigkeit der in der Temperaturmodellierung betrachteten Bodensäule (the half thickness of the surface soil layer relevant for modelling soil temperature) [m].

  • BoWa2Z() Bodenwassergehalt der Bodenschicht bis zu einer Tiefe 2z (soil water content of the soil layer down two a depth of 2z) [mm].

  • LambdaG() Wärmeleitfähigkeit des Bodens (thermal conductivity of the top soil layer) [MJ/m/K/T].

  • Sigma() Stefan-Boltzmann-Konstante (Stefan-Boltzmann constant) [MJ/m²/K/d].

  • RDryAir() Gaskonstante für trockene Luft (gas constant for dry air) [MJ/kg/K].

  • RWaterVapour() Gaskonstante für Wasserdampf (gas constant for water vapour) [MJ/kg/K].

  • LW() Latente Verdunstungswärme bei 15°C (heat of condensation at at temperature of 15°C) [MJ/m²/mm].

  • LWE() Mittlere latente Verdunstungswärme für Wasser und Eis (average heat of condensation for water and ice) [MJ/m²/mm].

  • CPLuft() Spezifische Wärmekapazität Luft (heat of condensation for a water temperature of 15°C) [MJ/kg/K].

  • Psy() Psychrometerkonstante bei Normaldruck (psychrometric constant at normal pressure) [kPa/°C].

  • PsyInv() Kehrwert der Psychrometerkonstante über Schnee und Eis bei 0°C (inverse psychrometric constant for ice and snow at 0°C) [°C/kPa].

  • Z0() Rauhigkeitslänge für Wiese (roughness length for short grass) [m].

  • Sol() Solarkonstante (solar constant) [m].

  • FrAtm() Empirischer Faktor zur Berechnung der atmosphärischen Gegenstrahlung (empirical factor for the calculation of atmospheric radiation) [-]

  • CG() Volumetrische Wärmekapazität des Bodens (volumetric heat capacity of soil) [MJ/m³/°C].

class hydpy.models.lland.lland_fixed.CPWasser(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Spezifische Wärmekapazität von Wasser (specific heat capacity of water) [MJ/mm/K].

Required by the methods:

Calc_TempSInz_V1 Calc_TempS_V1 Calc_WNiedInz_ESnowInz_V1 Calc_WNied_ESnow_V1 Calc_WNied_V1 Return_BackwardEulerErrorInz_V1 Return_BackwardEulerError_V1 Return_ESnowInz_V1 Return_ESnow_V1 Return_TempSInz_V1 Return_TempS_V1 Update_ESnowInz_V1 Update_ESnow_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.0041868
name: str = 'cpwasser'
unit: str = 'MJ/mm/K'
class hydpy.models.lland.lland_fixed.CPEis(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Spezifische Wärmekapazität von Eis bei 0 °C (specific heat capacity of ice at a temperature of 0 °C) [MJ/mm/K].

Required by the methods:

Calc_TempSInz_V1 Calc_TempS_V1 Calc_WNiedInz_ESnowInz_V1 Calc_WNied_ESnow_V1 Calc_WNied_V1 Return_BackwardEulerErrorInz_V1 Return_BackwardEulerError_V1 Return_ESnowInz_V1 Return_ESnow_V1 Return_TempSInz_V1 Return_TempS_V1 Update_ESnowInz_V1 Update_ESnow_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.00209
name: str = 'cpeis'
unit: str = 'MJ/mm/K'
class hydpy.models.lland.lland_fixed.RSchmelz(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Spezifische Schmelzwärme von Wasser (specific melt heat of water) [MJ/mm].

Required by the methods:

Calc_GefrPotInz_V1 Calc_GefrPot_V1 Calc_SFF_V1 Calc_SchmPotInz_V1 Calc_SchmPot_V1 Calc_SchmPot_V2 Calc_WGTF_V1 Update_ESnowInz_V2 Update_ESnow_V2

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.334
name: str = 'rschmelz'
unit: str = 'MJ/mm'
class hydpy.models.lland.lland_fixed.Pi(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

π [-].

Required by the methods:

Calc_EarthSunDistance_V1 Calc_ExtraterrestrialRadiation_V1 Calc_SP_V1 Calc_SolarDeclination_V1 Calc_TSA_TSU_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 3.141592653589793
name: str = 'pi'
unit: str = '-'
class hydpy.models.lland.lland_fixed.Z(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Halbe Mächtigkeit der in der Temperaturmodellierung betrachteten Bodensäule (the half thickness of the surface soil layer relevant for modelling soil temperature) [m].

Required by the methods:

Calc_TZ_V1 Calc_WG_V1 Return_BackwardEulerError_V1 Return_WG_V1 Update_ESnow_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.1
name: str = 'z'
unit: str = 'm'
class hydpy.models.lland.lland_fixed.BoWa2Z(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Bodenwassergehalt der Bodenschicht bis zu einer Tiefe 2z (soil water content of the soil layer down two a depth of 2z) [mm].

Required by the method:

Calc_SFF_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0, None)
INIT: Union[int, float, bool, None] = 80.0
name: str = 'bowa2z'
unit: str = 'mm'
class hydpy.models.lland.lland_fixed.LambdaG(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Wärmeleitfähigkeit des Bodens (thermal conductivity of the top soil layer) [MJ/m/K/T].

Required by the methods:

Calc_WG_V1 Return_BackwardEulerError_V1 Return_WG_V1 Update_ESnow_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.05184
name: str = 'lambdag'
unit: str = 'MJ/m/K/T'
class hydpy.models.lland.lland_fixed.Sigma(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Stefan-Boltzmann-Konstante (Stefan-Boltzmann constant) [MJ/m²/K/d].

Required by the methods:

Calc_DailyNetLongwaveRadiation_V1 Calc_EvB_V2 Calc_EvPo_V2 Calc_RLAtm_V1 Return_BackwardEulerErrorInz_V1 Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_NetLongwaveRadiationInz_V1 Return_NetLongwaveRadiationSnow_V1 Return_PenmanMonteith_V1 Return_TempSSurface_V1 Return_WSurfInz_V1 Update_ESnowInz_V1 Update_ESnow_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 4.89888e-09
name: str = 'sigma'
unit: str = 'MJ/m²/K/d'
class hydpy.models.lland.lland_fixed.RDryAir(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Gaskonstante für trockene Luft (gas constant for dry air) [MJ/kg/K].

Required by the method:

Calc_DensityAir_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.287058
name: str = 'rdryair'
unit: str = 'MJ/kg/K'
class hydpy.models.lland.lland_fixed.RWaterVapour(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Gaskonstante für Wasserdampf (gas constant for water vapour) [MJ/kg/K].

Required by the method:

Calc_DensityAir_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.461495
name: str = 'rwatervapour'
unit: str = 'MJ/kg/K'
class hydpy.models.lland.lland_fixed.LW(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Latente Verdunstungswärme bei 15°C (heat of condensation at at temperature of 15°C) [MJ/m²/mm].

Required by the methods:

Calc_EvB_V2 Calc_EvPo_V2 Return_PenmanMonteith_V1 Return_Penman_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 2.4624
name: str = 'lw'
unit: str = 'MJ/m²/mm'
class hydpy.models.lland.lland_fixed.LWE(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Mittlere latente Verdunstungswärme für Wasser und Eis (average heat of condensation for water and ice) [MJ/m²/mm].

Required by the methods:

Calc_EvSInz_SInz_STInz_V1 Calc_EvS_WAeS_WATS_V1

Following the equations given on the Wikipedia page on latent heat, we calculate the latent heat of water and the latent heat of sublimation both at a temperature of 0°C…

>>> from hydpy import round_
>>> t = 0.0
>>> round_((2500.8-2.36*t+0.0016*t**2-0.00006*t**3)/1000)
2.5008
>>> round_((2834.1-0.29*t-0.004*t**2)/1000)
2.8341

… and use their average as the default value for parameter LWE:

>>> round_((2.8341+2.5008)/2)
2.66745
>>> from hydpy.models.lland.lland_fixed import LWE
>>> round_(LWE.INIT)
2.66745
NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 2.66745
name: str = 'lwe'
unit: str = 'MJ/m²/mm'
class hydpy.models.lland.lland_fixed.CPLuft(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Spezifische Wärmekapazität Luft (heat of condensation for a water temperature of 15°C) [MJ/kg/K].

Required by the methods:

Calc_EvB_V2 Calc_EvPo_V2 Return_PenmanMonteith_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.001005
name: str = 'cpluft'
unit: str = 'MJ/kg/K'
class hydpy.models.lland.lland_fixed.Psy(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Psychrometerkonstante bei Normaldruck (psychrometric constant at normal pressure) [kPa/°C].

Required by the methods:

Calc_EvB_V2 Calc_EvPo_V2 Return_PenmanMonteith_V1 Return_Penman_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.0655
name: str = 'psy'
unit: str = 'kPa/°C'
class hydpy.models.lland.lland_fixed.PsyInv(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Kehrwert der Psychrometerkonstante über Schnee und Eis bei 0°C (inverse psychrometric constant for ice and snow at 0°C) [°C/kPa].

Required by the methods:

Return_BackwardEulerErrorInz_V1 Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_TempSSurface_V1 Return_WLatInz_V1 Return_WLatSnow_V1 Return_WSurfInz_V1 Update_ESnowInz_V1 Update_ESnow_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 17.6
name: str = 'psyinv'
unit: str = '°C/kPa'
class hydpy.models.lland.lland_fixed.Z0(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Rauhigkeitslänge für Wiese (roughness length for short grass) [m].

Required by the methods:

Calc_WindSpeed10m_V1 Calc_WindSpeed2m_V1 Return_AdjustedWindSpeed_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.003
name: str = 'z0'
unit: str = 'm'
class hydpy.models.lland.lland_fixed.Sol(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Solarkonstante (solar constant) [m].

Required by the method:

Calc_ExtraterrestrialRadiation_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 118.1088
name: str = 'sol'
unit: str = 'm'
class hydpy.models.lland.lland_fixed.FrAtm(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Empirischer Faktor zur Berechnung der atmosphärischen Gegenstrahlung (empirical factor for the calculation of atmospheric radiation) [-]

Required by the methods:

Calc_DailyNetLongwaveRadiation_V1 Calc_RLAtm_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 1.28
name: str = 'fratm'
unit: str = '-'
class hydpy.models.lland.lland_fixed.CG(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Volumetrische Wärmekapazität des Bodens (volumetric heat capacity of soil) [MJ/m³/°C].

Required by the method:

Calc_TZ_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
INIT: Union[int, float, bool, None] = 1.5
name: str = 'cg'
unit: str = 'MJ/m³/°C'

Sequence Features

Sequence tools

class hydpy.models.lland.lland_sequences.Flux1DSequence(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Base class for 1-dimensional flux subclasses that support aggregation with respect to AbsFHRU.

All Flux1DSequence subclasses should stick to the mask Complete.

The following example shows how subclass NKor works:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(4)
>>> lnk(ACKER, GLETS, VERS, SEE)
>>> derived.absfhru(10.0, 20.0, 30.0, 40.0)
>>> fluxes.nkor(5.0, 2.0, 4.0, 1.0)
>>> from hydpy import round_
>>> round_(fluxes.nkor.average_values())
2.5
DERIVEDPARAMETERS = (<class 'hydpy.models.lland.lland_derived.AbsFHRU'>,)
property refweights

Alias for the associated instance of AbsFHRU for calculating areal values.

name: str = 'flux1dsequence'
unit: str = '?'
class hydpy.models.lland.lland_sequences.State1DSequence(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Base class for 1-dimensional state subclasses that support aggregation with respect to AbsFHRU.

All State1DSequence subclasses must implement fitting mask objects individually.

The following example shows how subclass BoWa works, which implements mask Land:

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(4)
>>> lnk(ACKER, GLETS, VERS, SEE)
>>> wmax(100.0)
>>> derived.absfhru(10.0, 20.0, 30.0, 40.0)
>>> states.bowa(50.0, 20.0, 40.0, 10.0)
>>> from hydpy import round_
>>> round_(states.bowa.average_values())
30.0
DERIVEDPARAMETERS = (<class 'hydpy.models.lland.lland_derived.AbsFHRU'>,)
property refweights

Alias for the associated instance of AbsFHRU for calculating areal values.

name: str = 'state1dsequence'
unit: str = '?'
fastaccess_new: hydpy.core.sequencetools.FastAccessOutputSequence
fastaccess_old: hydpy.core.variabletools.FastAccess

Input sequences

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

Bases: hydpy.core.sequencetools.ModelIOSequences[InputSequence, hydpy.core.sequencetools.FastAccessInputSequence]

Input sequences of model lland.

The following classes are selected:
class hydpy.models.lland.lland_inputs.Nied(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelIOSequence[hydpy.core.sequencetools.InputSequences, hydpy.core.sequencetools.FastAccessInputSequence]

Niederschlag (precipitation) [mm].

Required by the method:

Calc_NKor_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'nied'
unit: str = 'mm'
class hydpy.models.lland.lland_inputs.TemL(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelIOSequence[hydpy.core.sequencetools.InputSequences, hydpy.core.sequencetools.FastAccessInputSequence]

Lufttemperatur (air temperature) [°C].

Required by the methods:

Calc_TKor_V1 Update_LoggedTemL_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'teml'
unit: str = '°C'
class hydpy.models.lland.lland_inputs.SunshineDuration(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelIOSequence[hydpy.core.sequencetools.InputSequences, hydpy.core.sequencetools.FastAccessInputSequence]

Sonnenscheindauer (sunshine duration) [h].

Required by the methods:

Calc_GlobalRadiation_V1 Update_LoggedSunshineDuration_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'sunshineduration'
unit: str = 'h'
class hydpy.models.lland.lland_inputs.Glob(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelIOSequence[hydpy.core.sequencetools.InputSequences, hydpy.core.sequencetools.FastAccessInputSequence]

Globalstrahlung (global radiation) [W/m²].

Required by the method:

Calc_ET0_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'glob'
unit: str = 'W/m²'
class hydpy.models.lland.lland_inputs.RelativeHumidity(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelIOSequence[hydpy.core.sequencetools.InputSequences, hydpy.core.sequencetools.FastAccessInputSequence]

Relative humidity [%].

Required by the methods:

Calc_ActualVapourPressure_V1 Update_LoggedRelativeHumidity_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'relativehumidity'
unit: str = '%'
class hydpy.models.lland.lland_inputs.WindSpeed(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelIOSequence[hydpy.core.sequencetools.InputSequences, hydpy.core.sequencetools.FastAccessInputSequence]

Windgeschwindigkeit (wind speed) [m/s].

Required by the methods:

Calc_WindSpeed10m_V1 Calc_WindSpeed2m_V1 Return_AdjustedWindSpeed_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'windspeed'
unit: str = 'm/s'
class hydpy.models.lland.lland_inputs.PET(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelIOSequence[hydpy.core.sequencetools.InputSequences, hydpy.core.sequencetools.FastAccessInputSequence]

Potenzielle Verdunstung (potential evapotranspiration) [mm].

Required by the method:

Calc_ET0_WET0_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'pet'
unit: str = 'mm'
class hydpy.models.lland.lland_inputs.AtmosphericPressure(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelIOSequence[hydpy.core.sequencetools.InputSequences, hydpy.core.sequencetools.FastAccessInputSequence]

Luftdruck (atmospheric pressure) [kPa].

Required by the method:

Calc_DryAirPressure_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'atmosphericpressure'
unit: str = 'kPa'

Flux sequences

class hydpy.models.lland.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 lland.

The following classes are selected:

  • QZ() Zufluss in das Teilgebiet (inflow into the subcatchment) [m³/s].

  • QZH() Abflussspende in das Teilgebiet (inflow into the subcatchment) [mm].

  • TemLTag() Tageswert der Lufttemperatur (daily air temperature) [°C].

  • DailyRelativeHumidity() Daily relative humidity [%].

  • DailySunshineDuration() Daily sunshine duration [h/d].

  • NKor() Korrigierter Niederschlag (corrected precipitation) [mm].

  • TKor() Korrigierte Lufttemperatur (corrected air temperature) [°C].

  • TKorTag() Tageswert der korrigierten Lufttemperatur (corrected daily air temperature) [°C].

  • WindSpeed2m() Wind speed at a height of 2 m above the ground for grass [m/s].

  • DailyWindSpeed2m() Daily wind speed 2 meters above ground [m/s].

  • ReducedWindSpeed2m() Land-use-specific wind speed at a height of 2 m above the ground [m/s].

  • WindSpeed10m() Wind speed at a height of 10 m above the ground for grass [m/s].

  • SaturationVapourPressure() Saturation vapour pressure [kPa].

  • DailySaturationVapourPressure() Daily satuarion vapour pressure [kPa].

  • SaturationVapourPressureInz() Sättigungsdampdruck unmittelbar oberhalb der Oberfläche des interzepierten Schnees (saturation vapour pressure directly above the surface of the intercepted snow) [kPa].

  • SaturationVapourPressureSnow() Saturation vapour pressure snow [kPa].

  • SaturationVapourPressureSlope() The slope of the saturation vapour pressure curve [kPa/°C].

  • DailySaturationVapourPressureSlope() Daily satuarion vapour pressure [kPa].

  • ActualVapourPressure() Actual vapour pressure [kPa].

  • DailyActualVapourPressure() Daily actual vapour pressure [kPa].

  • DryAirPressure() Dry air pressure [kPa].

  • DensityAir() Air density [kg/m³]

  • SolarDeclination() Solar declination [-].

  • TSA() Zeitpunkt Sonnenaufgang (time of sunrise) [h].

  • TSU() Zeitpunkt Sonnenuntergang (time of sunset) [h].

  • EarthSunDistance() The relative inverse distance between the earth and the sun [-].

  • ExtraterrestrialRadiation() Extraterrestial radiation [MJ/m²/d].

  • PossibleSunshineDuration() Possible astronomical sunshine duration [h].

  • DailyPossibleSunshineDuration() Possible daily astronomical sunshine duration [h/d].

  • DailyGlobalRadiation() Daily sum of global radiation [MJ/m²/d].

  • SP() Anteil an der Tagesstrahlungsmenge (relative amount of the daily radiation sum) [%].

  • GlobalRadiation() Global Radiation [MJ/m²].

  • AdjustedGlobalRadiation() Adjusted global Radiation [MJ/m²].

  • G() “MORECS” Bodenwärmestrom (“MORECS” soil heat flux) [MJ/m²].

  • TZ() Bodentemperatur in der Tiefe z (soil temperature at depth z) [°C].

  • WG() “Dynamischer” Bodenwärmestrom (“dynamic” soil heat flux) [MJ/m²].

  • NetShortwaveRadiation() Netto kurzwellige Strahlungsbilanz (net shortwave radiation) [MJ/m²].

  • NetShortwaveRadiationInz() Kurzwellige Netto-Strahlungsbilanz für den interzipierten Schnee (net shortwave radiation for intercepted snow) [MJ/m²].

  • NetShortwaveRadiationSnow() Kurzwellige Netto-Strahlungsbilanz für Schneeoberflächen (net shortwave radiation for snow surfaces) [MJ/m²].

  • DailyNetShortwaveRadiation() Daily not shortwave radiation [MJ/m²/d].

  • DailyNetLongwaveRadiation() Daily net longwave radiation [MJ/m²/d].

  • NetLongwaveRadiationInz() Langwellige Nettostrahlung des interzepierten Schnees (net longwave radiation of the intercepted snow [MJ/m²].

  • NetLongwaveRadiationSnow() Net longwave radiation for snow-surfaces [MJ/m²].

  • NetRadiation() Total net radiation [MJ/m²].

  • NetRadiationInz() Nettostrahlung des interzepierten Schnees (total net radiation of the intercepted snow [MJ/m²].

  • NetRadiationSnow() Total net radiation for snow-surfaces [MJ/m²].

  • DailyNetRadiation() Daily not radiation [MJ/m²/d].

  • AerodynamicResistance() Aerodynamischer Widerstand (aerodynamic resistance) [s/m].

  • SoilSurfaceResistance() Oberflächenwiderstand (surface resistance) [s/m].

  • LanduseSurfaceResistance() Oberflächenwiderstand (surface resistance) [s/m].

  • ActualSurfaceResistance() Oberflächenwiderstand (surface resistance) [s/m].

  • NBes() Gesamter Bestandsniederschlag (total stand precipitation) [mm].

  • SBes() Schneeanteil Bestandsniederschlag (frozen stand precipitation) [mm].

  • SnowIntMax() Schneeinterzeptionsspeicherkapazität (capacity of the snow interception storage) [mm].

  • SnowIntRate() Anteil des im Schneeinterzeptionsspeicher zurückgehaltenen Niederschlags (ratio between the snow interception rate and precipitation) [-].

  • NBesInz() Gesamter Bestandsniederschlag, der den Schneeinterzeptionsspeicher erreicht (total stand precipitation reaching the snow interception storage) [mm].

  • SBesInz() Gefrorener Bestandsniederschlag, der den Schneeinterzeptionsspeicher erreicht (frozen amount of stand precipitation reaching the snow interception storage) [mm].

  • WNiedInz() Niederschlagsbedingter Wärmestrom in den Schneeinterzeptionsspeicher (heat flux into the snow interception storage due to precipitation) [MJ/m²].

  • ActualAlbedoInz() Aktuelle Albedo der Oberfläche des interzeptierten Schnees (the current albedo of the surface of the intercepted snow) [-].

  • WaDaInz() Wasserdargebot des Schneeinterzeptionsspeichers (water leaving the snow interception storage) [mm].

  • SchmPotInz() Potentielle Schmelze des interzepierten Schnees (potential amount of snow melting within the snow interception storage) [mm].

  • SchmInz() Tatsächliche Schmelze des interzepierten Schnees (actual amount of snow melting within the snow cover) [mm].

  • GefrPotInz() Potentielles Wiedergefrieren des interzipierten Schnees (potential amount of water refreezing within the snow interception storage) [mm].

  • GefrInz() Tatsächliche Wiedergefrieren des interzipierten Schnees (actual amount of water refreezing within the snow interception storage) [mm].

  • EvSInz() Tatsächliche Verdunstung des interzepierten Schnees (actual evaporation of the intercepted snow) [mm].

  • ET0() Grasreferenzverdunstung (reference evapotranspiration) [mm].

  • EvPo() Evapotranspiration (evapotranspiration) [mm].

  • EvI() Tatsächliche Interzeptionsverdunstung (actual evaporation of intercepted water) [mm].

  • EvB() Tatsächliche Verdunstung von Bodenwasser (actual evaporation of soil water) [mm].

  • EvS() Tatsächliche Schneeverdunstung (actual evaporation of snow-water) [mm].

  • WGTF() Mit dem Grad-Tag-Verfahren berechneter Wärmeestrom in die Schneedecke (heat flux into the snow layer calculated with the degree-day method) [MJ/m²].

  • WNied() Niederschlagsbedingter Wärmestrom in die Schneedecke (heat flux into the snow layer due to precipitation) [MJ/m²].

  • TempSSurface() Schneetemperatur an der Schneeoberfläche (the snow temperature at the snow surface) [°C].

  • ActualAlbedo() Aktuelle Albedo der relevanten Oberfläche (the current albedo of the relevant surface) [-].

  • SchmPot() Potentielle Schneeschmelze (potential amount of water melting within the snow cover) [mm].

  • Schm() Tatsächliche Schneeschmelze (actual amount of water melting within the snow cover) [mm].

  • GefrPot() Potentielles Schnee-Wiedergefrieren (potential amount of water refreezing within the snow cover) [mm].

  • Gefr() Tatsächliche Schnee-Wiedergefrieren (actual amount of water refreezing within the snow cover) [mm].

  • WLatInz() Latente Wärmestrom interzepierter Schnee/Atmosphäre (latent heat flux between the intercepted snow and the atmosphere) [MJ/m²].

  • WLatSnow() Latente Wärmestrom Schnee/Atmosphäre (latent heat flux between the snow-layer and the atmosphere) [MJ/m²].

  • WSensInz() Fühlbare Wärmestrom interzipierter Schnee/Atmosphäre (sensible heat flux between the intercepted snow and the atmosphere) [MJ/m²].

  • WSensSnow() Fühlbare Wärmestrom Schnee/Atmosphäre (sensible heat flux between the snow-layer and the atmosphere) [MJ/m²].

  • WSurfInz() Wärmestrom vom Körper des interzepierten Schnees bis zu dessen Schneeoberfläche (heat flux from the body of the intercepted snow to its surface) [MJ/m²].

  • WSurf() Wärmestrom von der Schneedecke zur Schneeoberfläche (heat flux from the snow layer to the snow surface) [MJ/m²].

  • SFF() Relativer Anteil des gefrorenen Bodenwassers bis zu einer Tiefe von 2z (relative proportion of frozen soil water) [-].

  • FVG() Frostversiegelungsgrad (degree of frost sealing) [-].

  • WaDa() Wasserdargebot (water reaching the soil routine) [mm].

  • QDB() Direktabfluss-Abgabe aus dem Bodenspeicher (direct runoff release from the soil storage) [mm].

  • QIB1() Erste Komponente der Interflow-Abgabe aus dem Bodenspeicher (first component of the interflow release from the soil storage) [mm].

  • QIB2() Zweite Komponente der Interflow-Abgabe aus dem Bodenspeicher (second component of the interflow release from the soil storage) [mm].

  • QBB() Basisabfluss-Abgabe aus dem Bodenspeicher (base flow release from the soil storage) [mm].

  • QKap() Kapillarer Aufstieg in den Bodenspeicher (capillary rise to soil storage) [mm].

  • QDGZ() Gesamtzufluss in beide Direktabfluss-Gebietsspeicher (total inflow into both storage compartments for direct runoff) [mm].

  • QAH() Abflussspende des Teilgebiets (runoff at the catchment outlet) [mm].

  • QA() Abfluss des Teilgebiets (runoff at the catchment outlet) [m³/s].

class hydpy.models.lland.lland_fluxes.QZ(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Zufluss in das Teilgebiet (inflow into the subcatchment) [m³/s].

Calculated by the method:

Pick_QZ_V1

Required by the method:

Calc_QZH_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'qz'
unit: str = 'm³/s'
class hydpy.models.lland.lland_fluxes.QZH(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Abflussspende in das Teilgebiet (inflow into the subcatchment) [mm].

Calculated by the method:

Calc_QZH_V1

Required by the method:

Calc_QAH_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'qzh'
unit: str = 'mm'
class hydpy.models.lland.lland_fluxes.TemLTag(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Tageswert der Lufttemperatur (daily air temperature) [°C].

Updated by the method:

Calc_TemLTag_V1

Required by the method:

Calc_TKorTag_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'temltag'
unit: str = '°C'
class hydpy.models.lland.lland_fluxes.DailyRelativeHumidity(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Daily relative humidity [%].

Updated by the method:

Calc_DailyRelativeHumidity_V1

Required by the method:

Calc_DailyActualVapourPressure_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'dailyrelativehumidity'
unit: str = '%'
class hydpy.models.lland.lland_fluxes.DailySunshineDuration(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Daily sunshine duration [h/d].

Updated by the method:

Calc_DailySunshineDuration_V1

Required by the methods:

Calc_DailyGlobalRadiation_V1 Calc_DailyNetLongwaveRadiation_V1 Calc_GlobalRadiation_V1 Calc_RLAtm_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'dailysunshineduration'
unit: str = 'h/d'
class hydpy.models.lland.lland_fluxes.NKor(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Korrigierter Niederschlag (corrected precipitation) [mm].

Calculated by the method:

Calc_NKor_V1

Required by the methods:

Calc_NBes_Inzp_V1 Calc_QAH_V1 Calc_QBGZ_V1 Calc_QDGZ_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'nkor'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.TKor(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Korrigierte Lufttemperatur (corrected air temperature) [°C].

Calculated by the method:

Calc_TKor_V1

Required by the methods:

Calc_DensityAir_V1 Calc_ET0_V1 Calc_EvB_V2 Calc_EvPo_V2 Calc_LanduseSurfaceResistance_V1 Calc_RLAtm_V1 Calc_SNRatio_V1 Calc_SaturationVapourPressureSlope_V1 Calc_SaturationVapourPressure_V1 Calc_SnowIntMax_V1 Calc_WGTF_V1 Calc_WG_V1 Calc_WNiedInz_ESnowInz_V1 Calc_WNied_ESnow_V1 Calc_WNied_V1 Return_BackwardEulerErrorInz_V1 Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_NetLongwaveRadiationSnow_V1 Return_PenmanMonteith_V1 Return_TempSSurface_V1 Return_WG_V1 Return_WSensInz_V1 Return_WSensSnow_V1 Return_WSurfInz_V1 Update_ESnowInz_V1 Update_ESnow_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'tkor'
unit: str = '°C'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.TKorTag(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Tageswert der korrigierten Lufttemperatur (corrected daily air temperature) [°C].

Calculated by the method:

Calc_TKorTag_V1

Required by the methods:

Calc_DailyNetLongwaveRadiation_V1 Calc_DailySaturationVapourPressureSlope_V1 Calc_DailySaturationVapourPressure_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'tkortag'
unit: str = '°C'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.WindSpeed2m(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Wind speed at a height of 2 m above the ground for grass [m/s].

Calculated by the method:

Calc_WindSpeed2m_V1

Required by the methods:

Calc_ReducedWindSpeed2m_V1 Update_LoggedWindSpeed2m_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'windspeed2m'
unit: str = 'm/s'
class hydpy.models.lland.lland_fluxes.DailyWindSpeed2m(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Daily wind speed 2 meters above ground [m/s].

Updated by the method:

Calc_DailyWindSpeed2m_V1

Required by the methods:

Calc_EvPo_V2 Return_Penman_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'dailywindspeed2m'
unit: str = 'm/s'
class hydpy.models.lland.lland_fluxes.ReducedWindSpeed2m(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Land-use-specific wind speed at a height of 2 m above the ground [m/s].

Calculated by the method:

Calc_ReducedWindSpeed2m_V1

Required by the methods:

Return_BackwardEulerErrorInz_V1 Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_TempSSurface_V1 Return_WLatInz_V1 Return_WLatSnow_V1 Return_WSensInz_V1 Return_WSensSnow_V1 Return_WSurfInz_V1 Update_ESnowInz_V1 Update_ESnow_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'reducedwindspeed2m'
unit: str = 'm/s'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.WindSpeed10m(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Wind speed at a height of 10 m above the ground for grass [m/s].

Calculated by the method:

Calc_WindSpeed10m_V1

Required by the method:

Calc_AerodynamicResistance_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'windspeed10m'
unit: str = 'm/s'
class hydpy.models.lland.lland_fluxes.SaturationVapourPressure(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Saturation vapour pressure [kPa].

Calculated by the method:

Calc_SaturationVapourPressure_V1

Required by the methods:

Calc_ActualVapourPressure_V1 Calc_EvB_V2 Calc_EvPo_V2 Calc_LanduseSurfaceResistance_V1 Return_PenmanMonteith_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'saturationvapourpressure'
unit: str = 'kPa'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.DailySaturationVapourPressure(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Daily satuarion vapour pressure [kPa].

Calculated by the method:

Calc_DailySaturationVapourPressure_V1

Required by the methods:

Calc_DailyActualVapourPressure_V1 Calc_EvPo_V2 Return_Penman_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'dailysaturationvapourpressure'
unit: str = 'kPa'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.SaturationVapourPressureInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Sättigungsdampdruck unmittelbar oberhalb der Oberfläche des interzepierten Schnees (saturation vapour pressure directly above the surface of the intercepted snow) [kPa].

Calculated by the methods:

Return_BackwardEulerErrorInz_V1 Return_WSurfInz_V1 Update_ESnowInz_V1

Required by the method:

Return_WLatInz_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'saturationvapourpressureinz'
unit: str = 'kPa'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.SaturationVapourPressureSnow(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Saturation vapour pressure snow [kPa].

Calculated by the methods:

Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_TempSSurface_V1 Update_ESnow_V1

Required by the method:

Return_WLatSnow_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'saturationvapourpressuresnow'
unit: str = 'kPa'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.SaturationVapourPressureSlope(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

The slope of the saturation vapour pressure curve [kPa/°C].

Calculated by the method:

Calc_SaturationVapourPressureSlope_V1

Required by the methods:

Calc_EvB_V2 Calc_EvPo_V2 Return_PenmanMonteith_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'saturationvapourpressureslope'
unit: str = 'kPa/°C'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.DailySaturationVapourPressureSlope(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Daily satuarion vapour pressure [kPa].

Calculated by the method:

Calc_DailySaturationVapourPressureSlope_V1

Required by the methods:

Calc_EvPo_V2 Return_Penman_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'dailysaturationvapourpressureslope'
unit: str = 'kPa'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.ActualVapourPressure(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Actual vapour pressure [kPa].

Calculated by the method:

Calc_ActualVapourPressure_V1

Required by the methods:

Calc_DensityAir_V1 Calc_DryAirPressure_V1 Calc_EvB_V2 Calc_EvPo_V2 Calc_LanduseSurfaceResistance_V1 Calc_RLAtm_V1 Return_BackwardEulerErrorInz_V1 Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_PenmanMonteith_V1 Return_TempSSurface_V1 Return_WLatInz_V1 Return_WLatSnow_V1 Return_WSurfInz_V1 Update_ESnowInz_V1 Update_ESnow_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'actualvapourpressure'
unit: str = 'kPa'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.DailyActualVapourPressure(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Daily actual vapour pressure [kPa].

Calculated by the method:

Calc_DailyActualVapourPressure_V1

Required by the methods:

Calc_DailyNetLongwaveRadiation_V1 Calc_EvPo_V2 Return_Penman_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'dailyactualvapourpressure'
unit: str = 'kPa'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.DryAirPressure(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Dry air pressure [kPa].

Calculated by the method:

Calc_DryAirPressure_V1

Required by the method:

Calc_DensityAir_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'dryairpressure'
unit: str = 'kPa'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.DensityAir(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Air density [kg/m³]

Calculated by the method:

Calc_DensityAir_V1

Required by the methods:

Calc_EvB_V2 Calc_EvPo_V2 Return_PenmanMonteith_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'densityair'
unit: str = 'kg/m³'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.SolarDeclination(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Solar declination [-].

Calculated by the method:

Calc_SolarDeclination_V1

Required by the methods:

Calc_ExtraterrestrialRadiation_V1 Calc_TSA_TSU_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'solardeclination'
unit: str = '-'
class hydpy.models.lland.lland_fluxes.TSA(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Zeitpunkt Sonnenaufgang (time of sunrise) [h].

Calculated by the method:

Calc_TSA_TSU_V1

Required by the methods:

Calc_DailyPossibleSunshineDuration_V1 Calc_ExtraterrestrialRadiation_V1 Calc_PossibleSunshineDuration_V1 Calc_SP_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'tsa'
unit: str = 'h'
class hydpy.models.lland.lland_fluxes.TSU(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Zeitpunkt Sonnenuntergang (time of sunset) [h].

Calculated by the method:

Calc_TSA_TSU_V1

Required by the methods:

Calc_DailyPossibleSunshineDuration_V1 Calc_ExtraterrestrialRadiation_V1 Calc_PossibleSunshineDuration_V1 Calc_SP_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'tsu'
unit: str = 'h'
class hydpy.models.lland.lland_fluxes.EarthSunDistance(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

The relative inverse distance between the earth and the sun [-].

Calculated by the method:

Calc_EarthSunDistance_V1

Required by the method:

Calc_ExtraterrestrialRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'earthsundistance'
unit: str = '-'
class hydpy.models.lland.lland_fluxes.ExtraterrestrialRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Extraterrestial radiation [MJ/m²/d].

Calculated by the method:

Calc_ExtraterrestrialRadiation_V1

Required by the methods:

Calc_DailyGlobalRadiation_V1 Calc_GlobalRadiation_V1 Return_DailyGlobalRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'extraterrestrialradiation'
unit: str = 'MJ/m²/d'
class hydpy.models.lland.lland_fluxes.PossibleSunshineDuration(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Possible astronomical sunshine duration [h].

Calculated by the method:

Calc_PossibleSunshineDuration_V1

Required by the methods:

Calc_ActualSurfaceResistance_V1 Calc_G_V1 Calc_GlobalRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'possiblesunshineduration'
unit: str = 'h'
class hydpy.models.lland.lland_fluxes.DailyPossibleSunshineDuration(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Possible daily astronomical sunshine duration [h/d].

Calculated by the method:

Calc_DailyPossibleSunshineDuration_V1

Required by the methods:

Calc_DailyGlobalRadiation_V1 Calc_DailyNetLongwaveRadiation_V1 Calc_G_V1 Calc_GlobalRadiation_V1 Calc_RLAtm_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'dailypossiblesunshineduration'
unit: str = 'h/d'
class hydpy.models.lland.lland_fluxes.DailyGlobalRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Daily sum of global radiation [MJ/m²/d].

Updated by the method:

Calc_DailyGlobalRadiation_V1

Required by the methods:

Calc_AdjustedGlobalRadiation_V1 Calc_DailyNetShortwaveRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'dailyglobalradiation'
unit: str = 'MJ/m²/d'
class hydpy.models.lland.lland_fluxes.SP(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Anteil an der Tagesstrahlungsmenge (relative amount of the daily radiation sum) [%].

Calculated by the method:

Calc_SP_V1

Required by the method:

Calc_GlobalRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'sp'
unit: str = '%'
class hydpy.models.lland.lland_fluxes.GlobalRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Global Radiation [MJ/m²].

Calculated by the method:

Calc_GlobalRadiation_V1

Required by the methods:

Calc_AdjustedGlobalRadiation_V1 Update_LoggedGlobalRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'globalradiation'
unit: str = 'MJ/m²'
class hydpy.models.lland.lland_fluxes.AdjustedGlobalRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Adjusted global Radiation [MJ/m²].

Updated by the method:

Calc_AdjustedGlobalRadiation_V1

Required by the methods:

Calc_NetShortwaveRadiationInz_V1 Calc_NetShortwaveRadiationSnow_V1 Calc_NetShortwaveRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'adjustedglobalradiation'
unit: str = 'MJ/m²'
class hydpy.models.lland.lland_fluxes.G(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

“MORECS” Bodenwärmestrom (“MORECS” soil heat flux) [MJ/m²].

Calculated by the methods:

Calc_G_V1 Calc_G_V2

Required by the methods:

Calc_EvB_V2 Calc_EvPo_V2 Return_PenmanMonteith_V1

With positive values, the soil looses heat to the atmosphere or the snow-layer.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'g'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.TZ(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Bodentemperatur in der Tiefe z (soil temperature at depth z) [°C].

Calculated by the method:

Calc_TZ_V1

Required by the methods:

Calc_WG_V1 Return_BackwardEulerError_V1 Return_WG_V1 Update_ESnow_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'tz'
unit: str = '°C'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.WG(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

“Dynamischer” Bodenwärmestrom (“dynamic” soil heat flux) [MJ/m²].

Calculated by the methods:

Calc_WG_V1 Return_BackwardEulerError_V1 Update_ESnow_V1

Required by the method:

Update_EBdn_V1

With positive values, the soil looses heat to the atmosphere or the snow-layer.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'wg'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.NetShortwaveRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Netto kurzwellige Strahlungsbilanz (net shortwave radiation) [MJ/m²].

Calculated by the method:

Calc_NetShortwaveRadiation_V1

Required by the method:

Calc_NetRadiation_V1

With positive values, the soil gains heat from radiation.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'netshortwaveradiation'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.NetShortwaveRadiationInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Kurzwellige Netto-Strahlungsbilanz für den interzipierten Schnee (net shortwave radiation for intercepted snow) [MJ/m²].

Calculated by the method:

Calc_NetShortwaveRadiationInz_V1

Required by the methods:

Return_BackwardEulerErrorInz_V1 Return_WSurfInz_V1 Update_ESnowInz_V1

With positive values, the soil gains heat from radiation. Without intercepted snow, NetShortwaveRadiationInz is nan.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'netshortwaveradiationinz'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.NetShortwaveRadiationSnow(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Kurzwellige Netto-Strahlungsbilanz für Schneeoberflächen (net shortwave radiation for snow surfaces) [MJ/m²].

Calculated by the method:

Calc_NetShortwaveRadiationSnow_V1

Required by the methods:

Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_TempSSurface_V1 Update_ESnow_V1

With positive values, the soil gains heat from radiation.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'netshortwaveradiationsnow'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.DailyNetShortwaveRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Daily not shortwave radiation [MJ/m²/d].

Calculated by the method:

Calc_DailyNetShortwaveRadiation_V1

Required by the method:

Calc_DailyNetRadiation_V1

With positive values, the soil gains heat from radiation.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'dailynetshortwaveradiation'
unit: str = 'MJ/m²/d'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.DailyNetLongwaveRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Daily net longwave radiation [MJ/m²/d].

Calculated by the method:

Calc_DailyNetLongwaveRadiation_V1

Required by the methods:

Calc_DailyNetRadiation_V1 Calc_NetRadiation_V1

With positive values, the soil looses heat from radiation.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'dailynetlongwaveradiation'
unit: str = 'MJ/m²/d'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.NetLongwaveRadiationInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Langwellige Nettostrahlung des interzepierten Schnees (net longwave radiation of the intercepted snow [MJ/m²].

Calculated by the methods:

Return_BackwardEulerErrorInz_V1 Return_WSurfInz_V1 Update_ESnowInz_V1

With positive values, the snow-layer gains heat from radiation.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'netlongwaveradiationinz'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.NetLongwaveRadiationSnow(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Net longwave radiation for snow-surfaces [MJ/m²].

Calculated by the methods:

Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_TempSSurface_V1 Update_ESnow_V1

With positive values, the snow-layer gains heat from radiation.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'netlongwaveradiationsnow'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.NetRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Total net radiation [MJ/m²].

Updated by the method:

Calc_NetRadiation_V1

Required by the methods:

Calc_EvB_V2 Calc_EvPo_V2 Return_PenmanMonteith_V1

With positive values, the soil gains heat from radiation.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'netradiation'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.NetRadiationInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Nettostrahlung des interzepierten Schnees (total net radiation of the intercepted snow [MJ/m²].

Calculated by the methods:

Return_BackwardEulerErrorInz_V1 Return_WSurfInz_V1 Update_ESnowInz_V1

With positive values, the soil gains heat from radiation.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'netradiationinz'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.NetRadiationSnow(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Total net radiation for snow-surfaces [MJ/m²].

Calculated by the methods:

Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_TempSSurface_V1 Update_ESnow_V1

With positive values, the snow-layer gains heat from radiation.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'netradiationsnow'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.DailyNetRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Daily not radiation [MJ/m²/d].

Calculated by the method:

Calc_DailyNetRadiation_V1

Required by the methods:

Calc_EvPo_V2 Calc_G_V1 Return_Penman_V1

With positive values, the soil gains heat from radiation.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'dailynetradiation'
unit: str = 'MJ/m²/d'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.AerodynamicResistance(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Aerodynamischer Widerstand (aerodynamic resistance) [s/m].

Calculated by the method:

Calc_AerodynamicResistance_V1

Required by the methods:

Calc_EvB_V2 Calc_EvPo_V2 Return_PenmanMonteith_V1

NDIM: int = 1
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
mask
name: str = 'aerodynamicresistance'
unit: str = 's/m'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.SoilSurfaceResistance(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Oberflächenwiderstand (surface resistance) [s/m].

Calculated by the method:

Calc_SoilSurfaceResistance_V1

Required by the method:

Calc_ActualSurfaceResistance_V1

NDIM: int = 1
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
mask
name: str = 'soilsurfaceresistance'
unit: str = 's/m'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.LanduseSurfaceResistance(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Oberflächenwiderstand (surface resistance) [s/m].

Calculated by the method:

Calc_LanduseSurfaceResistance_V1

Required by the method:

Calc_ActualSurfaceResistance_V1

NDIM: int = 1
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
mask
name: str = 'landusesurfaceresistance'
unit: str = 's/m'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.ActualSurfaceResistance(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Oberflächenwiderstand (surface resistance) [s/m].

Calculated by the method:

Calc_ActualSurfaceResistance_V1

Required by the method:

Calc_EvB_V2

NDIM: int = 1
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
mask
name: str = 'actualsurfaceresistance'
unit: str = 's/m'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.NBes(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Gesamter Bestandsniederschlag (total stand precipitation) [mm].

Calculated by the method:

Calc_NBes_Inzp_V1

Required by the methods:

Calc_NBesInz_V1 Calc_SBes_V1 Calc_WNied_ESnow_V1 Calc_WNied_V1 Calc_WaDa_WAeS_V1 Calc_WaDa_WAeS_V2

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'nbes'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.SBes(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Schneeanteil Bestandsniederschlag (frozen stand precipitation) [mm].

Calculated by the method:

Calc_SBes_V1

Required by the methods:

Calc_WATS_V1 Calc_WATS_V2 Calc_WNied_ESnow_V1 Calc_WNied_V1 Update_TauS_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'sbes'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.SnowIntMax(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Schneeinterzeptionsspeicherkapazität (capacity of the snow interception storage) [mm].

Calculated by the method:

Calc_SnowIntMax_V1

Required by the method:

Calc_NBesInz_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'snowintmax'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.SnowIntRate(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Anteil des im Schneeinterzeptionsspeicher zurückgehaltenen Niederschlags (ratio between the snow interception rate and precipitation) [-].

Calculated by the method:

Calc_SnowIntRate_V1

Required by the method:

Calc_NBesInz_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'snowintrate'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.NBesInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Gesamter Bestandsniederschlag, der den Schneeinterzeptionsspeicher erreicht (total stand precipitation reaching the snow interception storage) [mm].

Calculated by the method:

Calc_NBesInz_V1

Required by the methods:

Calc_SBesInz_V1 Calc_WNiedInz_ESnowInz_V1 Calc_WaDaInz_SInz_V1 Calc_WaDa_WAeS_V2

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'nbesinz'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.SBesInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Gefrorener Bestandsniederschlag, der den Schneeinterzeptionsspeicher erreicht (frozen amount of stand precipitation reaching the snow interception storage) [mm].

Calculated by the method:

Calc_SBesInz_V1

Required by the methods:

Calc_STInz_V1 Calc_WATS_V2 Calc_WNiedInz_ESnowInz_V1 Update_ASInz_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'sbesinz'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.WNiedInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Niederschlagsbedingter Wärmestrom in den Schneeinterzeptionsspeicher (heat flux into the snow interception storage due to precipitation) [MJ/m²].

Calculated by the method:

Calc_WNiedInz_ESnowInz_V1

With positive values, the snow layer gains heat from precipitation.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'wniedinz'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.ActualAlbedoInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Aktuelle Albedo der Oberfläche des interzeptierten Schnees (the current albedo of the surface of the intercepted snow) [-].

Calculated by the method:

Calc_ActualAlbedoInz_V1

Required by the method:

Calc_NetShortwaveRadiationInz_V1

If there is no intercepted snow, the value of ActualAlbedoInz is nan.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'actualalbedoinz'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.WaDaInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Wasserdargebot des Schneeinterzeptionsspeichers (water leaving the snow interception storage) [mm].

Calculated by the method:

Calc_WaDaInz_SInz_V1

Updated by the method:

Update_WaDaInz_SInz_V1

Required by the methods:

Calc_WNiedInz_ESnowInz_V1 Calc_WaDa_WAeS_V2

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'wadainz'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.SchmPotInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Potentielle Schmelze des interzepierten Schnees (potential amount of snow melting within the snow interception storage) [mm].

Calculated by the method:

Calc_SchmPotInz_V1

Required by the method:

Calc_SchmInz_STInz_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'schmpotinz'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.SchmInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Tatsächliche Schmelze des interzepierten Schnees (actual amount of snow melting within the snow cover) [mm].

Calculated by the method:

Calc_SchmInz_STInz_V1

Required by the method:

Update_ESnowInz_V2

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'schminz'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.GefrPotInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Potentielles Wiedergefrieren des interzipierten Schnees (potential amount of water refreezing within the snow interception storage) [mm].

Calculated by the method:

Calc_GefrPotInz_V1

Required by the method:

Calc_GefrInz_STInz_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'gefrpotinz'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.GefrInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Tatsächliche Wiedergefrieren des interzipierten Schnees (actual amount of water refreezing within the snow interception storage) [mm].

Calculated by the method:

Calc_GefrInz_STInz_V1

Required by the method:

Update_ESnowInz_V2

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'gefrinz'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.EvSInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Tatsächliche Verdunstung des interzepierten Schnees (actual evaporation of the intercepted snow) [mm].

Calculated by the method:

Calc_EvSInz_SInz_STInz_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'evsinz'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.ET0(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Grasreferenzverdunstung (reference evapotranspiration) [mm].

Calculated by the methods:

Calc_ET0_V1 Calc_ET0_WET0_V1

Required by the method:

Calc_EvPo_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'et0'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.EvPo(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Evapotranspiration (evapotranspiration) [mm].

Calculated by the methods:

Calc_EvPo_V1 Calc_EvPo_V2

Required by the methods:

Calc_EvB_V1 Calc_EvB_V2 Calc_EvI_Inzp_V1 Calc_EvI_Inzp_V2 Calc_EvI_Inzp_V3

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'evpo'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.EvI(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Tatsächliche Interzeptionsverdunstung (actual evaporation of intercepted water) [mm].

Calculated by the methods:

Calc_EvI_Inzp_V1 Calc_EvI_Inzp_V2 Calc_EvI_Inzp_V3

Updated by the method:

Calc_QAH_V1

Required by the methods:

Calc_EvB_V1 Calc_EvB_V2 Calc_QBGZ_V1 Calc_QDGZ_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'evi'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.EvB(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Tatsächliche Verdunstung von Bodenwasser (actual evaporation of soil water) [mm].

Calculated by the methods:

Calc_EvB_V1 Calc_EvB_V2

Updated by the method:

Calc_BoWa_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'evb'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.EvS(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Tatsächliche Schneeverdunstung (actual evaporation of snow-water) [mm].

Calculated by the method:

Calc_EvS_WAeS_WATS_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'evs'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.WGTF(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Mit dem Grad-Tag-Verfahren berechneter Wärmeestrom in die Schneedecke (heat flux into the snow layer calculated with the degree-day method) [MJ/m²].

Calculated by the method:

Calc_WGTF_V1

Required by the method:

Calc_SchmPot_V1

With positive values, the snow layer gains heat from the atmosphere and from radiation.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'wgtf'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.WNied(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Niederschlagsbedingter Wärmestrom in die Schneedecke (heat flux into the snow layer due to precipitation) [MJ/m²].

Calculated by the methods:

Calc_WNied_ESnow_V1 Calc_WNied_V1

Required by the method:

Calc_SchmPot_V1

With positive values, the snow layer gains heat from precipitation.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'wnied'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.TempSSurface(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Schneetemperatur an der Schneeoberfläche (the snow temperature at the snow surface) [°C].

Calculated by the methods:

Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_TempSSurface_V1 Update_ESnow_V1

Required by the methods:

Return_NetLongwaveRadiationSnow_V1 Return_WSensSnow_V1 Return_WSurf_V1

Note that the value of sequence TempSSurface is nan for snow-free surfaces.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'tempssurface'
unit: str = '°C'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.ActualAlbedo(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Aktuelle Albedo der relevanten Oberfläche (the current albedo of the relevant surface) [-].

Calculated by the method:

Calc_ActualAlbedo_V1

Required by the methods:

Calc_DailyNetShortwaveRadiation_V1 Calc_NetShortwaveRadiationSnow_V1 Calc_NetShortwaveRadiation_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'actualalbedo'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.SchmPot(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Potentielle Schneeschmelze (potential amount of water melting within the snow cover) [mm].

Calculated by the methods:

Calc_SchmPot_V1 Calc_SchmPot_V2

Required by the method:

Calc_Schm_WATS_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'schmpot'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.Schm(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Tatsächliche Schneeschmelze (actual amount of water melting within the snow cover) [mm].

Calculated by the method:

Calc_Schm_WATS_V1

Required by the method:

Update_ESnow_V2

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'schm'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.GefrPot(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Potentielles Schnee-Wiedergefrieren (potential amount of water refreezing within the snow cover) [mm].

Calculated by the method:

Calc_GefrPot_V1

Required by the method:

Calc_Gefr_WATS_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'gefrpot'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.Gefr(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Tatsächliche Schnee-Wiedergefrieren (actual amount of water refreezing within the snow cover) [mm].

Calculated by the method:

Calc_Gefr_WATS_V1

Required by the method:

Update_ESnow_V2

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'gefr'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.WLatInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Latente Wärmestrom interzepierter Schnee/Atmosphäre (latent heat flux between the intercepted snow and the atmosphere) [MJ/m²].

Calculated by the methods:

Return_BackwardEulerErrorInz_V1 Return_WSurfInz_V1 Update_ESnowInz_V1

Required by the method:

Calc_EvSInz_SInz_STInz_V1

With positive values, the snow-layer looses heat to the atmosphere.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'wlatinz'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.WLatSnow(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Latente Wärmestrom Schnee/Atmosphäre (latent heat flux between the snow-layer and the atmosphere) [MJ/m²].

Calculated by the methods:

Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_TempSSurface_V1 Update_ESnow_V1

Required by the method:

Calc_EvS_WAeS_WATS_V1

With positive values, the snow-layer looses heat to the atmosphere.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'wlatsnow'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.WSensInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Fühlbare Wärmestrom interzipierter Schnee/Atmosphäre (sensible heat flux between the intercepted snow and the atmosphere) [MJ/m²].

Calculated by the methods:

Return_BackwardEulerErrorInz_V1 Return_WSurfInz_V1 Update_ESnowInz_V1

With positive values, the snow-layer looses heat to the atmosphere.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'wsensinz'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.WSensSnow(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Fühlbare Wärmestrom Schnee/Atmosphäre (sensible heat flux between the snow-layer and the atmosphere) [MJ/m²].

Calculated by the methods:

Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_TempSSurface_V1 Update_ESnow_V1

With positive values, the snow-layer looses heat to the atmosphere.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'wsenssnow'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.WSurfInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Wärmestrom vom Körper des interzepierten Schnees bis zu dessen Schneeoberfläche (heat flux from the body of the intercepted snow to its surface) [MJ/m²].

Calculated by the methods:

Return_BackwardEulerErrorInz_V1 Return_WSurfInz_V1 Update_ESnowInz_V1

With positive values, the snow-layer looses heat to the atmosphere.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'wsurfinz'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.WSurf(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Wärmestrom von der Schneedecke zur Schneeoberfläche (heat flux from the snow layer to the snow surface) [MJ/m²].

Calculated by the methods:

Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_TempSSurface_V1 Update_ESnow_V1

With positive values, the snow-layer looses heat to the atmosphere.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'wsurf'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.SFF(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Relativer Anteil des gefrorenen Bodenwassers bis zu einer Tiefe von 2z (relative proportion of frozen soil water) [-].

Calculated by the method:

Calc_SFF_V1

Required by the method:

Calc_FVG_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'sff'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.FVG(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Frostversiegelungsgrad (degree of frost sealing) [-].

Calculated by the method:

Calc_FVG_V1

Required by the method:

Update_QDB_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'fvg'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.WaDa(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Wasserdargebot (water reaching the soil routine) [mm].

Calculated by the methods:

Calc_WaDa_WAeS_V1 Calc_WaDa_WAeS_V2

Updated by the method:

Update_WaDa_WAeS_V1

Required by the methods:

Calc_BoWa_V1 Calc_QDB_V1 Calc_WNied_ESnow_V1 Update_QDB_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'wada'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.QDB(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Direktabfluss-Abgabe aus dem Bodenspeicher (direct runoff release from the soil storage) [mm].

Calculated by the method:

Calc_QDB_V1

Updated by the methods:

Calc_BoWa_V1 Update_QDB_V1

Required by the method:

Calc_QDGZ_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'qdb'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.QIB1(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Erste Komponente der Interflow-Abgabe aus dem Bodenspeicher (first component of the interflow release from the soil storage) [mm].

Calculated by the method:

Calc_QIB1_V1

Updated by the method:

Calc_BoWa_V1

Required by the method:

Calc_QIGZ1_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'qib1'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.QIB2(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Zweite Komponente der Interflow-Abgabe aus dem Bodenspeicher (second component of the interflow release from the soil storage) [mm].

Calculated by the method:

Calc_QIB2_V1

Updated by the method:

Calc_BoWa_V1

Required by the method:

Calc_QIGZ2_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'qib2'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.QBB(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Basisabfluss-Abgabe aus dem Bodenspeicher (base flow release from the soil storage) [mm].

Calculated by the method:

Calc_QBB_V1

Updated by the method:

Calc_BoWa_V1

Required by the method:

Calc_QBGZ_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'qbb'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.QKap(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Kapillarer Aufstieg in den Bodenspeicher (capillary rise to soil storage) [mm].

Calculated by the method:

Calc_QKap_V1

Updated by the method:

Calc_BoWa_V1

Required by the method:

Calc_QBGZ_V1

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'qkap'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_fluxes.QDGZ(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Gesamtzufluss in beide Direktabfluss-Gebietsspeicher (total inflow into both storage compartments for direct runoff) [mm].

Calculated by the method:

Calc_QDGZ_V1

Updated by the methods:

Update_QDGZ_QBGZ_QBGA_V1 Update_QDGZ_QBGZ_QBGA_V2

Required by the method:

Calc_QDGZ1_QDGZ2_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'qdgz'
unit: str = 'mm'
class hydpy.models.lland.lland_fluxes.QAH(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Abflussspende des Teilgebiets (runoff at the catchment outlet) [mm].

Calculated by the method:

Calc_QAH_V1

Required by the method:

Calc_QA_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'qah'
unit: str = 'mm'
class hydpy.models.lland.lland_fluxes.QA(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Abfluss des Teilgebiets (runoff at the catchment outlet) [m³/s].

Calculated by the method:

Calc_QA_V1

Required by the method:

Pass_QA_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'qa'
unit: str = 'm³/s'

State sequences

class hydpy.models.lland.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 lland.

The following classes are selected:

  • Inzp() Interzeptionsspeicherung (interception storage) [mm].

  • STInz() Wasseräquivalent Trockenschnee im Interzeptionsspeicher (total water equivalent of the intercepted snow) [mm].

  • SInz() Wasseräquivalent Gesamtschnee im Interzeptionsspeicher (frozen water equivalent of the intercepted snow) [mm].

  • ESnowInz() Kälteinhalt der Schneedecke des Interzeptionsspeichers [MJ/m²].

  • ASInz() Dimensionsloses Alter des interzipierten Schnees (dimensionless age of the intercepted snow layer) [-].

  • WATS() Wasseräquivalent Trockenschnee auf der Bodenoberfläche (frozen water equivalent of the snow cover) [mm].

  • WAeS() Wasseräquivalent Gesamtschnee auf der Bodenoberfläche (total water equivalent of the snow cover) [mm].

  • ESnow() Thermischer Energieinhalt der Schneedecke bezogen auf 0°C (thermal energy content of the snow layer with respect to 0°C) [MJ/m²].

  • TauS() Dimensionsloses Alter der Schneedecke (dimensionless age of the snow layer) [-].

  • EBdn() Energiegehalt des Bodenwassers (energy content of the soil water) [MJ/m²].

  • BoWa() Bodenwasserspeicherung (soil water storage) [mm].

  • QDGZ1() Zufluss in den trägeren Direktabfluss-Gebietsspeicher (inflow into the less responsive storage compartment for direct runoff) [mm].

  • QDGZ2() Zufluss in den dynamischeren Direktabfluss-Gebietsspeicher (inflow into the more responsive storage compartment for direct runoff) [mm].

  • QIGZ1() “Zufluss in den ersten Zwischenabfluss-Gebietsspeicher (inflow into the first storage compartment for interflow) [mm].

  • QIGZ2() Zufluss in den zweiten Zwischenabfluss-Gebietsspeicher (inflow into the second storage compartment for interflow) [mm].

  • QBGZ() Zufluss in den Basisabfluss-Gebietsspeicher (inflow into the storage compartment for base flow) [mm].

  • QDGA1() Abfluss aus dem trägeren Direktabfluss-Gebietsspeicher (outflow from the less responsive storage compartment for direct runoff) [mm].

  • QDGA2() Abfluss aus dem dynamischeren Direktabfluss-Gebietsspeicher (outflow from the more responsive storage compartment for direct runoff) [mm].

  • QIGA1() Abfluss aus dem “unteren” Zwischenabfluss-Gebietsspeicher (outflow from the storage compartment for the first interflow component) [mm].

  • QIGA2() Abfluss aus dem “oberen” Zwischenabfluss-Gebietsspeicher (outflow from the storage compartment for the second interflow component) [mm].

  • QBGA() Abfluss aus dem Basisabfluss-Gebietsspeicher (outflow from the storage compartment for base flow) [mm].

class hydpy.models.lland.lland_states.Inzp(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Interzeptionsspeicherung (interception storage) [mm].

Updated by the methods:

Calc_EvI_Inzp_V1 Calc_EvI_Inzp_V2 Calc_EvI_Inzp_V3 Calc_NBes_Inzp_V1

Note that Inzp of HydPy-L implements no specialized trim method (as opposed to Ic of hland). This is due the discontinuous evolution of KInz in time. In accordance with the original LARSIM implementation, Inzp can be temporarily overfilled during rain periods whenever KInz drops rapidly between two months. A specialized trim method would just make the excess water vanish. But in HydPy-L, the excess water becomes NBes in the first simulation step of the new month.

NDIM: int = 1
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
mask
name: str = 'inzp'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_states.STInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Wasseräquivalent Trockenschnee im Interzeptionsspeicher (total water equivalent of the intercepted snow) [mm].

Updated by the methods:

Calc_EvSInz_SInz_STInz_V1 Calc_GefrInz_STInz_V1 Calc_STInz_V1 Calc_SchmInz_STInz_V1

Required by the methods:

Calc_TempSInz_V1 Calc_WaDaInz_SInz_V1 Return_BackwardEulerErrorInz_V1 Return_ESnowInz_V1 Return_TempSInz_V1 Update_ESnowInz_V1 Update_WaDaInz_SInz_V1

NDIM: int = 1
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
mask
trim(lower=None, upper=None)[source]

Trim values in accordance with \(SInz \leq PWMax \cdot STInz\), or at least in accordance with if \(STInz \geq 0\).

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(7)
>>> pwmax(2.0)
>>> states.sinz = -1.0, 0.0, 1.0, -1.0, 5.0, 10.0, 20.0
>>> states.stinz(-1.0, 0.0, 0.0, 5.0, 5.0, 5.0, 5.0)
>>> states.stinz
stinz(0.0, 0.0, 0.5, 5.0, 5.0, 5.0, 10.0)
name: str = 'stinz'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_states.SInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Wasseräquivalent Gesamtschnee im Interzeptionsspeicher (frozen water equivalent of the intercepted snow) [mm].

Updated by the methods:

Calc_EvSInz_SInz_STInz_V1 Calc_WaDaInz_SInz_V1 Update_WaDaInz_SInz_V1

Required by the methods:

Calc_ActualAlbedoInz_V1 Calc_EvI_Inzp_V3 Calc_GefrInz_STInz_V1 Calc_GefrPotInz_V1 Calc_NBesInz_V1 Calc_SchmPotInz_V1 Calc_SnowIntRate_V1 Calc_TempSInz_V1 Return_BackwardEulerErrorInz_V1 Return_ESnowInz_V1 Return_TempSInz_V1 Update_ASInz_V1 Update_ESnowInz_V1 Update_ESnowInz_V2

NDIM: int = 1
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
mask
trim(lower=None, upper=None)[source]

Trim values in accordance with \(0 \leq SInz \leq PWMax \cdot STInz\).

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(7)
>>> pwmax(2.0)
>>> states.stinz = 0.0, 0.0, 0.0, 5.0, 5.0, 5.0, 5.0
>>> states.sinz(-1.0, 0.0, 1.0, -1.0, 5.0, 10.0, 20.0)
>>> states.sinz
sinz(0.0, 0.0, 0.0, 0.0, 5.0, 10.0, 10.0)
name: str = 'sinz'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_states.ESnowInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Kälteinhalt der Schneedecke des Interzeptionsspeichers [MJ/m²].

Updated by the methods:

Calc_WNiedInz_ESnowInz_V1 Update_ESnowInz_V1 Update_ESnowInz_V2

Required by the methods:

Calc_GefrPotInz_V1 Calc_SchmPotInz_V1 Calc_TempSInz_V1 Return_BackwardEulerErrorInz_V1 Return_TempSInz_V1

NDIM: int = 1
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
mask
name: str = 'esnowinz'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_states.ASInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Dimensionsloses Alter des interzipierten Schnees (dimensionless age of the intercepted snow layer) [-].

Calculated by the method:

Update_ASInz_V1

Required by the method:

Calc_ActualAlbedoInz_V1

If there is no intercepted snow, the value of ASInz is nan.

NDIM: int = 1
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
mask
name: str = 'asinz'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_states.WATS(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Wasseräquivalent Trockenschnee auf der Bodenoberfläche (frozen water equivalent of the snow cover) [mm].

Updated by the methods:

Calc_EvS_WAeS_WATS_V1 Calc_Gefr_WATS_V1 Calc_Schm_WATS_V1 Calc_WATS_V1 Calc_WATS_V2

Required by the methods:

Calc_TempS_V1 Calc_WaDa_WAeS_V1 Calc_WaDa_WAeS_V2 Return_BackwardEulerError_V1 Return_ESnow_V1 Return_TempS_V1 Update_ESnow_V1 Update_WaDa_WAeS_V1

NDIM: int = 1
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
mask
trim(lower=None, upper=None)[source]

Trim values in accordance with \(WAeS \leq PWMax \cdot WATS\), or at least in accordance with if \(WATS \geq 0\).

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(7)
>>> pwmax(2.0)
>>> states.waes = -1., 0., 1., -1., 5., 10., 20.
>>> states.wats(-1., 0., 0., 5., 5., 5., 5.)
>>> states.wats
wats(0.0, 0.0, 0.5, 5.0, 5.0, 5.0, 10.0)
name: str = 'wats'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_states.WAeS(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Wasseräquivalent Gesamtschnee auf der Bodenoberfläche (total water equivalent of the snow cover) [mm].

Updated by the methods:

Calc_EvS_WAeS_WATS_V1 Calc_WaDa_WAeS_V1 Calc_WaDa_WAeS_V2 Update_WaDa_WAeS_V1

Required by the methods:

Calc_ActualAlbedo_V1 Calc_EvB_V2 Calc_EvI_Inzp_V2 Calc_EvI_Inzp_V3 Calc_GefrPot_V1 Calc_Gefr_WATS_V1 Calc_SchmPot_V2 Calc_TempS_V1 Calc_WG_V1 Return_BackwardEulerError_V1 Return_ESnow_V1 Return_TempSSurface_V1 Return_TempS_V1 Return_WG_V1 Update_ESnow_V1 Update_ESnow_V2 Update_TauS_V1

NDIM: int = 1
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
mask
trim(lower=None, upper=None)[source]

Trim values in accordance with \(WAeS \leq PWMax \cdot WATS\).

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(7)
>>> pwmax(2.)
>>> states.wats = 0., 0., 0., 5., 5., 5., 5.
>>> states.waes(-1., 0., 1., -1., 5., 10., 20.)
>>> states.waes
waes(0.0, 0.0, 0.0, 0.0, 5.0, 10.0, 10.0)
name: str = 'waes'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_states.ESnow(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Thermischer Energieinhalt der Schneedecke bezogen auf 0°C (thermal energy content of the snow layer with respect to 0°C) [MJ/m²].

Updated by the methods:

Calc_WNied_ESnow_V1 Update_ESnow_V1 Update_ESnow_V2

Required by the methods:

Calc_GefrPot_V1 Calc_SchmPot_V2 Calc_TempS_V1 Return_BackwardEulerError_V1 Return_TempS_V1

NDIM: int = 1
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
mask
name: str = 'esnow'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_states.TauS(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Dimensionsloses Alter der Schneedecke (dimensionless age of the snow layer) [-].

Calculated by the method:

Update_TauS_V1

Required by the method:

Calc_ActualAlbedo_V1

If there is no snow-layer, the value of TauS is nan.

NDIM: int = 1
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
mask
name: str = 'taus'
unit: str = '-'
subvars: SubVariablesType
class hydpy.models.lland.lland_states.EBdn(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Energiegehalt des Bodenwassers (energy content of the soil water) [MJ/m²].

Updated by the method:

Update_EBdn_V1

Required by the methods:

Calc_SFF_V1 Calc_TZ_V1

NDIM: int = 1
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
mask
name: str = 'ebdn'
unit: str = 'MJ/m²'
subvars: SubVariablesType
class hydpy.models.lland.lland_states.BoWa(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Bodenwasserspeicherung (soil water storage) [mm].

Updated by the method:

Calc_BoWa_V1

Required by the methods:

Calc_EvB_V1 Calc_LanduseSurfaceResistance_V1 Calc_QBB_V1 Calc_QDB_V1 Calc_QIB1_V1 Calc_QIB2_V1 Calc_QKap_V1 Calc_SoilSurfaceResistance_V1

NDIM: int = 1
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
mask
trim(lower=None, upper=None)[source]

Trim values in accordance with \(BoWa \leq WMax\).

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(5)
>>> wmax(200.)
>>> states.bowa(-100.,0., 100., 200., 300.)
>>> states.bowa
bowa(0.0, 0.0, 100.0, 200.0, 200.0)
name: str = 'bowa'
unit: str = 'mm'
subvars: SubVariablesType
class hydpy.models.lland.lland_states.QDGZ1(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Zufluss in den trägeren Direktabfluss-Gebietsspeicher (inflow into the less responsive storage compartment for direct runoff) [mm].

Calculated by the method:

Calc_QDGZ1_QDGZ2_V1

Required by the method:

Calc_QDGA1_V1

NDIM: int = 0
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'qdgz1'
unit: str = 'mm'
class hydpy.models.lland.lland_states.QDGZ2(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Zufluss in den dynamischeren Direktabfluss-Gebietsspeicher (inflow into the more responsive storage compartment for direct runoff) [mm].

Calculated by the method:

Calc_QDGZ1_QDGZ2_V1

Required by the method:

Calc_QDGA2_V1

NDIM: int = 0
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'qdgz2'
unit: str = 'mm'
class hydpy.models.lland.lland_states.QIGZ1(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

“Zufluss in den ersten Zwischenabfluss-Gebietsspeicher (inflow into the first storage compartment for interflow) [mm].

Calculated by the method:

Calc_QIGZ1_V1

Required by the method:

Calc_QIGA1_V1

NDIM: int = 0
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'qigz1'
unit: str = 'mm'
class hydpy.models.lland.lland_states.QIGZ2(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Zufluss in den zweiten Zwischenabfluss-Gebietsspeicher (inflow into the second storage compartment for interflow) [mm].

Calculated by the method:

Calc_QIGZ2_V1

Required by the method:

Calc_QIGA2_V1

NDIM: int = 0
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'qigz2'
unit: str = 'mm'
class hydpy.models.lland.lland_states.QBGZ(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Zufluss in den Basisabfluss-Gebietsspeicher (inflow into the storage compartment for base flow) [mm].

Calculated by the method:

Calc_QBGZ_V1

Updated by the methods:

Update_QDGZ_QBGZ_QBGA_V1 Update_QDGZ_QBGZ_QBGA_V2

Required by the method:

Calc_QBGA_V1

NDIM: int = 0
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'qbgz'
unit: str = 'mm'
class hydpy.models.lland.lland_states.QDGA1(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Abfluss aus dem trägeren Direktabfluss-Gebietsspeicher (outflow from the less responsive storage compartment for direct runoff) [mm].

Updated by the method:

Calc_QDGA1_V1

Required by the method:

Calc_QAH_V1

NDIM: int = 0
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'qdga1'
unit: str = 'mm'
class hydpy.models.lland.lland_states.QDGA2(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Abfluss aus dem dynamischeren Direktabfluss-Gebietsspeicher (outflow from the more responsive storage compartment for direct runoff) [mm].

Updated by the method:

Calc_QDGA2_V1

Required by the method:

Calc_QAH_V1

NDIM: int = 0
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'qdga2'
unit: str = 'mm'
class hydpy.models.lland.lland_states.QIGA1(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Abfluss aus dem “unteren” Zwischenabfluss-Gebietsspeicher (outflow from the storage compartment for the first interflow component) [mm].

Updated by the method:

Calc_QIGA1_V1

Required by the method:

Calc_QAH_V1

NDIM: int = 0
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'qiga1'
unit: str = 'mm'
class hydpy.models.lland.lland_states.QIGA2(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Abfluss aus dem “oberen” Zwischenabfluss-Gebietsspeicher (outflow from the storage compartment for the second interflow component) [mm].

Updated by the method:

Calc_QIGA2_V1

Required by the method:

Calc_QAH_V1

NDIM: int = 0
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'qiga2'
unit: str = 'mm'
class hydpy.models.lland.lland_states.QBGA(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Abfluss aus dem Basisabfluss-Gebietsspeicher (outflow from the storage compartment for base flow) [mm].

Updated by the methods:

Calc_QBGA_V1 Update_QDGZ_QBGZ_QBGA_V1 Update_QDGZ_QBGZ_QBGA_V2

Required by the method:

Calc_QAH_V1

NDIM: int = 0
NUMERIC: bool = False
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'qbga'
unit: str = 'mm'

Log sequences

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

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

Log sequences of model lland.

The following classes are selected:
class hydpy.models.lland.lland_logs.WET0(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.LogSequences, hydpy.core.variabletools.FastAccess]

Zeitlich gewichtete Grasreferenzverdunstung (temporally weighted reference evapotranspiration) [mm].

Updated by the method:

Calc_ET0_WET0_V1

NDIM: int = 2
NUMERIC: bool = False
property shape

Log sequence WET0 is generally initialized with a length of one on the first axis:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> logs.wet0.shape = 3
>>> logs.wet0.shape
(1, 3)
name: str = 'wet0'
unit: str = 'mm'
class hydpy.models.lland.lland_logs.LoggedTemL(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.LogSequences, hydpy.core.variabletools.FastAccess]

Logged air temperature [°C].

Updated by the method:

Update_LoggedTemL_V1

Required by the method:

Calc_TemLTag_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedteml'
unit: str = '°C'
class hydpy.models.lland.lland_logs.LoggedRelativeHumidity(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.LogSequences, hydpy.core.variabletools.FastAccess]

Logged relative humidity [%].

Updated by the method:

Update_LoggedRelativeHumidity_V1

Required by the method:

Calc_DailyRelativeHumidity_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedrelativehumidity'
unit: str = '%'
class hydpy.models.lland.lland_logs.LoggedSunshineDuration(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.LogSequences, hydpy.core.variabletools.FastAccess]

Logged sunshine duration [h].

Updated by the method:

Update_LoggedSunshineDuration_V1

Required by the method:

Calc_DailySunshineDuration_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedsunshineduration'
unit: str = 'h'
class hydpy.models.lland.lland_logs.LoggedGlobalRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.LogSequences, hydpy.core.variabletools.FastAccess]

Logged global radiation [h].

Updated by the method:

Update_LoggedGlobalRadiation_V1

Required by the method:

Calc_AdjustedGlobalRadiation_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedglobalradiation'
unit: str = 'h'
class hydpy.models.lland.lland_logs.LoggedWindSpeed2m(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.LogSequences, hydpy.core.variabletools.FastAccess]

Logged wind speed [m/s].

Updated by the method:

Update_LoggedWindSpeed2m_V1

Required by the method:

Calc_DailyWindSpeed2m_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedwindspeed2m'
unit: str = 'm/s'

Inlet sequences

class hydpy.models.lland.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 lland.

The following classes are selected:

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

class hydpy.models.lland.lland_inlets.Q(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.InletSequences]

Abfluss (runoff) [m³/s].

Required by the method:

Pick_QZ_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'q'
unit: str = 'm³/s'

Outlet sequences

class hydpy.models.lland.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 lland.

The following classes are selected:

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

class hydpy.models.lland.lland_outlets.Q(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.OutletSequences]

Abfluss (runoff) [m³/s].

Calculated by the method:

Pass_QA_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'q'
unit: str = 'm³/s'

Aide sequences

class hydpy.models.lland.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 lland.

The following classes are selected:

  • SNRatio() Ratio of frozen precipitation to total precipitation [-].

  • RLAtm() Atmosphärische Gegenstrahlung (longwave radiation emitted from the atmosphere) [MJ/m²/d].

  • TempS() Temperatur der Schneedecke (temperature of the snow layer) [°C].

  • TempSInz() Temperatur des interzepierten Schnees (temperature of the intercepted snow) [°C].

class hydpy.models.lland.lland_aides.SNRatio(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelSequence[hydpy.core.sequencetools.AideSequences, hydpy.core.variabletools.FastAccess]

Ratio of frozen precipitation to total precipitation [-].

Calculated by the method:

Calc_SNRatio_V1

Required by the methods:

Calc_SBesInz_V1 Calc_SBes_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'snratio'
unit: str = '-'
class hydpy.models.lland.lland_aides.RLAtm(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelSequence[hydpy.core.sequencetools.AideSequences, hydpy.core.variabletools.FastAccess]

Atmosphärische Gegenstrahlung (longwave radiation emitted from the atmosphere) [MJ/m²/d].

Calculated by the method:

Calc_RLAtm_V1

Required by the methods:

Return_BackwardEulerErrorInz_V1 Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_NetLongwaveRadiationInz_V1 Return_NetLongwaveRadiationSnow_V1 Return_TempSSurface_V1 Return_WSurfInz_V1 Update_ESnowInz_V1 Update_ESnow_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'rlatm'
unit: str = 'MJ/m²/d'
class hydpy.models.lland.lland_aides.TempS(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelSequence[hydpy.core.sequencetools.AideSequences, hydpy.core.variabletools.FastAccess]

Temperatur der Schneedecke (temperature of the snow layer) [°C].

Calculated by the method:

Calc_TempS_V1

Required by the methods:

Calc_WG_V1 Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_TempSSurface_V1 Return_WG_V1 Return_WSurf_V1 Update_ESnow_V1 Update_TauS_V1

Note that the value of sequence TempS is nan for snow-free surfaces.

NDIM: int = 1
NUMERIC: bool = False
name: str = 'temps'
unit: str = '°C'
class hydpy.models.lland.lland_aides.TempSInz(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelSequence[hydpy.core.sequencetools.AideSequences, hydpy.core.variabletools.FastAccess]

Temperatur des interzepierten Schnees (temperature of the intercepted snow) [°C].

Calculated by the methods:

Calc_TempSInz_V1 Return_BackwardEulerErrorInz_V1 Update_ESnowInz_V1

Required by the methods:

Return_NetLongwaveRadiationInz_V1 Return_WSensInz_V1 Return_WSurfInz_V1 Update_ASInz_V1

Note that the value of sequence TempSInz is nan for missing intercepted snow.

NDIM: int = 1
NUMERIC: bool = False
name: str = 'tempsinz'
unit: str = '°C'

Auxiliary Features

Masks

class hydpy.models.lland.Masks[source]

Bases: hydpy.core.masktools.Masks

Masks of base model lland.

The following classes are selected:
class hydpy.models.lland.lland_masks.Complete(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.core.masktools.IndexMask

Mask including all land uses.

RELEVANT_VALUES: Tuple[int, …] = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)
static get_refindices(variable)[source]

Reference to the associated instance of Lnk.

name: str = 'complete'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Land(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask excluding the land uses WASSER, SEE and FLUSS.

RELEVANT_VALUES: Tuple[int, …] = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
name: str = 'land'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Soil(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask excluding the land uses WASSER, SEE, FLUSS, and VERS.

RELEVANT_VALUES: Tuple[int, …] = (1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
name: str = 'soil'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Forest(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask including the land uses LAUBW, MISCHW, and NADELW.

RELEVANT_VALUES: Tuple[int, …] = (14, 15, 13)
name: str = 'forest'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Sied_D(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use SIED_D.

RELEVANT_VALUES: Tuple[int, …] = (1,)
name: str = 'sied_d'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Sied_L(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use SIED_L.

RELEVANT_VALUES: Tuple[int, …] = (2,)
name: str = 'sied_l'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Vers(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use VERS.

RELEVANT_VALUES: Tuple[int, …] = (3,)
name: str = 'vers'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Acker(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use ACKER.

RELEVANT_VALUES: Tuple[int, …] = (4,)
name: str = 'acker'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Weinb(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use WEINB.

RELEVANT_VALUES: Tuple[int, …] = (5,)
name: str = 'weinb'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Obstb(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use OBSTB.

RELEVANT_VALUES: Tuple[int, …] = (6,)
name: str = 'obstb'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Boden(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use BODEN.

RELEVANT_VALUES: Tuple[int, …] = (7,)
name: str = 'boden'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Glets(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use GLETS.

RELEVANT_VALUES: Tuple[int, …] = (8,)
name: str = 'glets'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Grue_I(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use GRUE_I.

RELEVANT_VALUES: Tuple[int, …] = (9,)
name: str = 'grue_i'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Feucht(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use FEUCHT.

RELEVANT_VALUES: Tuple[int, …] = (10,)
name: str = 'feucht'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Grue_E(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use GRUE_E.

RELEVANT_VALUES: Tuple[int, …] = (11,)
name: str = 'grue_e'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Baumb(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use BAUMB.

RELEVANT_VALUES: Tuple[int, …] = (12,)
name: str = 'baumb'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Nadelw(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use NADELW.

RELEVANT_VALUES: Tuple[int, …] = (13,)
name: str = 'nadelw'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Laubw(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use LAUBW.

RELEVANT_VALUES: Tuple[int, …] = (14,)
name: str = 'laubw'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Mischw(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use MISCHW.

RELEVANT_VALUES: Tuple[int, …] = (15,)
name: str = 'mischw'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Wasser(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use WASSER.

RELEVANT_VALUES: Tuple[int, …] = (16,)
name: str = 'wasser'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.Fluss(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use FLUSS.

RELEVANT_VALUES: Tuple[int, …] = (17,)
name: str = 'fluss'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.lland_masks.See(variable: Optional[hydpy.core.typingtools.VariableProtocol] = None, **kwargs)[source]

Bases: hydpy.models.lland.lland_masks.Complete

Mask for land use SEE.

RELEVANT_VALUES: Tuple[int, …] = (18,)
name: str = 'see'
variable: hydpy.core.typingtools.VariableProtocol
class hydpy.models.lland.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 lland.

The following classes are selected:

  • SNRatio() Ratio of frozen precipitation to total precipitation [-].

  • RLAtm() Atmosphärische Gegenstrahlung (longwave radiation emitted from the atmosphere) [MJ/m²/d].

  • TempS() Temperatur der Schneedecke (temperature of the snow layer) [°C].

  • TempSInz() Temperatur des interzepierten Schnees (temperature of the intercepted snow) [°C].

class hydpy.models.lland.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 lland.

The following classes are selected:

  • Latitude() The latitude [decimal degrees].

  • Longitude() The longitude [decimal degrees].

  • FT() Teileinzugsgebietsfläche (subbasin area) [km²].

  • NHRU() Anzahl der Hydrotope (number of hydrological response units) [-].

  • Lnk() Landnutzungsklasse (land use class) [-].

  • FHRU() Flächenanteile der Hydrotope (area percentages of the respective HRUs) [-].

  • HNN() Höhe über Normal-Null (height above sea level) [m].

  • KG() Niederschlagskorrekturfaktor (adjustment factor for precipitation) [-].

  • KT() Temperaturkorrektursummand (adjustment summand for air temperature) [°C].

  • KE() Grasreferenzverdunstungskorrekturfaktor (adjustment factor for reference evapotranspiration) [-].

  • AngstromConstant() The Ångström “a” coefficient for calculating global radiation [-].

  • AngstromFactor() The Ångström “b” coefficient for calculating global radiation [-].

  • AngstromAlternative() An alternative Ångström coefficient replacing coefficient “c” (AngstromConstant) on days without any direct sunshine [-].

  • P1Strahl() Konstante der Globalstrahlungsreduktion für Wald (constant for reducing the global radiation in forests) [-].

  • P2Strahl() Faktor der Globalstrahlungsreduktion für Wald (factor for reducing the global radiation in forests) [-].

  • Albedo() Albedo [-].

  • Albedo0Snow() Albedo von Neuschnee (albedo of fresh snow) [-].

  • SnowAgingFactor() Wichtungsfaktor für die Sensitivität der Albedo für die Alterung des Schnees (weighting factor of albedo sensitivity for snow aging) [-].

  • Turb0() Parameter des Übergangskoeffizienten des turbulenten Wärmestroms (parameter of transition coefficient for turbulent heat flux) [MJ/m²/K/T].

  • Turb1() Parameter des Übergangskoeffizienten des turbulenten Wärmestroms (parameter of transition coefficient for turbulent heat flux) [(MJ*s)/m³/K/T].

  • Emissivity() Emissivität der Oberfläche (emissivity) [-]

  • MeasuringHeightWindSpeed() The height above ground of the wind speed measurements [m].

  • P1Wind() Konstante der Windgeschwindigkeitsreduktion für Wald (constant for reducing the wind speed in forests) [-].

  • P2Wind() Faktor der Windgeschwindigkeitsreduktion für Wald (factor for reducing the wind speed in forests) [-].

  • LAI() Blattflächenindex (leaf area index) [-].

  • HInz() Interzeptionskapazität bezogen auf die Blattoberfläche (interception capacity normalized to the leaf surface area) [mm].

  • P1SIMax() Konstante zur Berechnung der maximalen Schneeinterzeptionskapazität basierend auf dem Blattflächenindex (constant for calculating the maximum snow interception capacity based on the leaf area index) [mm].

  • P2SIMax() Faktor zur Berechnung der maximalen Schneeinterzeptionskapazität basierend auf dem Blattflächenindex (factor for calculating the maximum snow interception capacity based on the leaf area index) [mm].

  • P1SIRate() Konstante zur Berechnung des Verhältnisses von Schneeinerzeptionsrate und Niederschlagsintensität basierend auf dem Blattflächenindex (constant for calculating the ratio of the snow interception rate and the precipitation intensity based on the leaf area index) [-].

  • P2SIRate() Faktor zur Berechnung des Verhältnisses von Schneeinerzeptionsrate und Niederschlagsintensität basierend auf dem Blattflächenindex (factor for calculating the ratio of the snow interception rate and precipitation intensity based on the leaf area index) [-].

  • P3SIRate() Faktor zur Berechnung des Verhältnisses von Schneeinerzeptionsrate und Niederschlagsintensität basierend auf der bereits interzipierten Schneemenge (factor for calculating the ratio of the snow interception rate and precipitation intensity based on the amount of already intercepted snow) [1/mm].

  • TRefT() Lufttemperaturgrenzwert des Grad-Tag-Verfahrens (air temperature threshold of the degree-day method) [°C].

  • TRefN() Niederschlagstemperaturgrenzwert des zur Berechnung des Wärmeeintrags durch Regen (precipitation temperature threshold to calculate heat flux caused by liquid precipitation on snow) [°C].

  • TGr() Temperaturgrenzwert flüssiger/fester Niederschlag (threshold temperature liquid/frozen precipitation) [°C].

  • TSp() Temperaturspanne flüssiger/fester Niederschlag (temperature range with mixed precipitation) [°C].

  • GTF() Grad-Tag-Faktor (factor of the degree-day method) [mm/°C/T].

  • PWMax() Maximalverhältnis Gesamt- zu Trockenschnee (maximum ratio of the total and the frozen water equivalent stored in the snow cover) [-].

  • RefreezeFlag() Flag um wiedergefrieren zu aktivieren (flag to activate refreezing) [-].

  • KTSchnee() Effektive Wärmeleitfähigkeit der obersten Schneeschicht (effective thermal conductivity of the top snow layer) [MJ/m²/K/T].

  • WG2Z() Bodenwärmestrom in der Tiefe 2z (soil heat flux at depth 2z) [MJ/m²/d].

  • KF() Küstenfaktor (“coast factor” of Turc-Wendling’s evaporation equation [-].

  • WfET0() Zeitlicher Wichtungsfaktor der Grasreferenzverdunsung (temporal weighting factor for reference evapotranspiration).

  • FLn() Landnutzungsabhängiger Verdunstungsfaktor (factor for adjusting reference evapotranspiration to different land use classes) [-].

  • GrasRef_R() Bodenfeuchte-Verdunstung-Parameter (soil moisture-dependent evaporation factor) [-].

  • CropHeight() Crop height [m].

  • SurfaceResistance() Surface Resistance [s/m].

  • WMax() Maximaler Bodenwasserspeicher (maximum soil water storage) [mm].

  • FK() Feldkapazität / Mindestbodenfeuchte für die Interflowentstehung (field capacity / threshold value of soil moisture for interflow generation) [mm].

  • PWP() Permanenter Welkepunkt / Mindestbodenfeuchte für die Basisabflussentstehung (permanent wilting point threshold value of soil moisture for base flow generation) [mm].

  • PY() Permanenter Welkepunkt / Schwellenwert für den Anteil des für Pflanzen gebundenen Bodenwassers (permanent wilting point) [mm].

  • BSf() Bodenfeuchte-Sättigungsfläche-Parameter (shape parameter for the relation between the avarage soil moisture and the relative saturated area of a subbasin) [-].

  • FVF() Frostversiegelungsfaktor zur Ermittelung des Frostversiegelungsgrades (frost sealing factor for determination of the degree of frost sealing FVG) [-].

  • BSFF() Exponent zur Ermittelung des Frostversieglungsgrades (frost sealing exponent for determination of degree of frost sealing FVG) [-].

  • DMin() Drainageindex des mittleren Bodenspeichers (flux rate for releasing interflow from the middle soil compartment) [mm/T].

  • DMax() Drainageindex des oberen Bodenspeichers (additional flux rate for releasing interflow from the upper soil compartment) [mm/T].

  • Beta() Drainageindex des tiefen Bodenspeichers (storage coefficient for releasing base flow from the lower soil compartment) [1/T].

  • FBeta() Faktor zur Erhöhung der Perkolation im Grobporenbereich (factor for increasing percolation under wet conditions) [-].

  • KapMax() Maximale kapillare Aufstiegsrate (maximum capillary rise) [mm/T].

  • KapGrenz() Grenzwerte für den kapillaren Aufstieg (threshold values related to the capillary rise) [mm].

  • RBeta() Boolscher Parameter der steuert, ob the Perkolation unterhalb der Feldkapazität auf Null reduziert wird (flag to indicate if seepage is reduced to zero below field capacity) [-].

  • VolBMax() Maximaler Inhalt des Gebietsspeichers für Basisabfluss (maximum value of the storage compartment for base flow) [mm].

  • GSBMax() Faktor zur Anpassung von VolBMax (factor for adjusting VolBMax) [-].

  • GSBGrad1() Höchste Volumenzunahme des Gebietsspeichers für Basisabfluss ohne Begrenzung des Zuflusses (highest possible storage increase of the compartment for base flow without inflow reductions) [mm/T].

  • GSBGrad2() Volumenzunahme des Gebietsspeichers für Basisabfluss, oberhalb der jeglicher Zufluss ausgeschlossen ist (highest possible storage increase of the compartment for base flow) [mm/T].

  • A1() Parameter für die kontinuierliche Aufteilung der Direktabflusskomponenten (threshold value for the continuous seperation of direct runoff in a slow and a fast component) [mm/T]

  • A2() Parameter für die diskontinuierliche Aufteilung der Direktabflusskomponenten (threshold value for the discontinuous seperation of direct runoff in a slow and a fast component) [mm/T]

  • TInd() Fließzeitindex (factor related to the time of concentration) [T].

  • EQB() Kalibrierfaktor für die Basisabflusskonzentration (factor for adjusting the concentration time of baseflow). [-].

  • EQI1() Kalibrierfaktor für die “untere” Zwischenabflusskonzentration (factor for adjusting the concentration time of the first interflow component) [-].

  • EQI2() Kalibrierfaktor für die “obere” Zwischenabflusskonzentration (factor for adjusting the concentration time of the second interflow component) [-].

  • EQD1() Kalibrierfaktor für die langsamere Direktabflusskonzentration (factor for adjusting the concentration time of the slower component of direct runoff). [-].

  • EQD2() Kalibrierfaktor für die schnellere Direktabflusskonzentration (factor for adjusting the concentration time of the faster component of direct runoff). [-].

  • NegQ() Option: sind negative Abflüsse erlaubt (flag that indicated wether negative discharge values are allowed or not) [-].

class hydpy.models.lland.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 lland.

The following classes are selected:

  • MOY() References the “global” month of the year index array [-].

  • DOY() References the “global” day of the year index array [-].

  • Seconds() The length of the actual simulation step size in seconds [s].

  • Hours() The length of the actual simulation step size in hours [h].

  • Days() The length of the actual simulation step size in days [d].

  • SCT() References the “global” standard clock time array [-].

  • UTCLongitude() Longitude of the centre of the local time zone [°].

  • NmbLogEntries() The number of log entries required for a memory duration of 24 hours [-].

  • LatitudeRad() The latitude [rad].

  • AbsFHRU() Flächen der Hydrotope (areas of the respective HRUs) [km²].

  • KInz() Interzeptionskapazität bezogen auf die Bodenoberfläche (interception capacity normalized to the soil surface area) [mm].

  • HeatOfFusion() Heat which is necessary to melt the frozen soil water content.

  • Fr() Reduktionsfaktor für Strahlung [4] (basierend auf [6]) (reduction factor for short- and long wave radiation) [4] (based on [6]) [-].

  • NFk() Nutzbare Feldkapazität (usable field capacity) [mm].

  • KB() Konzentrationszeit des Basisabflusses (concentration time of baseflow) [T].

  • KI1() Konzentrationszeit des “unteren” Zwischenabflusses (concentration time of the first interflow component) [T].

  • KI2() Konzentrationszeit des “oberen” Zwischenabflusses” (concentration time of the second interflow component) [T].

  • KD1() Konzentrationszeit des “langsamen” Direktabflusses (concentration time of the slower component of direct runoff) [T].

  • KD2() Konzentrationszeit des “schnellen” Direktabflusses (concentration time of the faster component of direct runoff) [T].

  • QBGAMax() Maximaler Abfluss aus dem Basisabfluss-Gebietsspeicher (maximum outflow from the storage compartment for base flow) [mm/T].

  • QFactor() Factor for converting mm/stepsize to m³/s.

class hydpy.models.lland.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 lland.

The following classes are selected:

  • CPWasser() Spezifische Wärmekapazität von Wasser (specific heat capacity of water) [MJ/mm/K].

  • CPEis() Spezifische Wärmekapazität von Eis bei 0 °C (specific heat capacity of ice at a temperature of 0 °C) [MJ/mm/K].

  • RSchmelz() Spezifische Schmelzwärme von Wasser (specific melt heat of water) [MJ/mm].

  • Pi() π [-].

  • Z() Halbe Mächtigkeit der in der Temperaturmodellierung betrachteten Bodensäule (the half thickness of the surface soil layer relevant for modelling soil temperature) [m].

  • BoWa2Z() Bodenwassergehalt der Bodenschicht bis zu einer Tiefe 2z (soil water content of the soil layer down two a depth of 2z) [mm].

  • LambdaG() Wärmeleitfähigkeit des Bodens (thermal conductivity of the top soil layer) [MJ/m/K/T].

  • Sigma() Stefan-Boltzmann-Konstante (Stefan-Boltzmann constant) [MJ/m²/K/d].

  • RDryAir() Gaskonstante für trockene Luft (gas constant for dry air) [MJ/kg/K].

  • RWaterVapour() Gaskonstante für Wasserdampf (gas constant for water vapour) [MJ/kg/K].

  • LW() Latente Verdunstungswärme bei 15°C (heat of condensation at at temperature of 15°C) [MJ/m²/mm].

  • LWE() Mittlere latente Verdunstungswärme für Wasser und Eis (average heat of condensation for water and ice) [MJ/m²/mm].

  • CPLuft() Spezifische Wärmekapazität Luft (heat of condensation for a water temperature of 15°C) [MJ/kg/K].

  • Psy() Psychrometerkonstante bei Normaldruck (psychrometric constant at normal pressure) [kPa/°C].

  • PsyInv() Kehrwert der Psychrometerkonstante über Schnee und Eis bei 0°C (inverse psychrometric constant for ice and snow at 0°C) [°C/kPa].

  • Z0() Rauhigkeitslänge für Wiese (roughness length for short grass) [m].

  • Sol() Solarkonstante (solar constant) [m].

  • FrAtm() Empirischer Faktor zur Berechnung der atmosphärischen Gegenstrahlung (empirical factor for the calculation of atmospheric radiation) [-]

  • CG() Volumetrische Wärmekapazität des Bodens (volumetric heat capacity of soil) [MJ/m³/°C].

class hydpy.models.lland.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 lland.

The following classes are selected:

  • QZ() Zufluss in das Teilgebiet (inflow into the subcatchment) [m³/s].

  • QZH() Abflussspende in das Teilgebiet (inflow into the subcatchment) [mm].

  • TemLTag() Tageswert der Lufttemperatur (daily air temperature) [°C].

  • DailyRelativeHumidity() Daily relative humidity [%].

  • DailySunshineDuration() Daily sunshine duration [h/d].

  • NKor() Korrigierter Niederschlag (corrected precipitation) [mm].

  • TKor() Korrigierte Lufttemperatur (corrected air temperature) [°C].

  • TKorTag() Tageswert der korrigierten Lufttemperatur (corrected daily air temperature) [°C].

  • WindSpeed2m() Wind speed at a height of 2 m above the ground for grass [m/s].

  • DailyWindSpeed2m() Daily wind speed 2 meters above ground [m/s].

  • ReducedWindSpeed2m() Land-use-specific wind speed at a height of 2 m above the ground [m/s].

  • WindSpeed10m() Wind speed at a height of 10 m above the ground for grass [m/s].

  • SaturationVapourPressure() Saturation vapour pressure [kPa].

  • DailySaturationVapourPressure() Daily satuarion vapour pressure [kPa].

  • SaturationVapourPressureInz() Sättigungsdampdruck unmittelbar oberhalb der Oberfläche des interzepierten Schnees (saturation vapour pressure directly above the surface of the intercepted snow) [kPa].

  • SaturationVapourPressureSnow() Saturation vapour pressure snow [kPa].

  • SaturationVapourPressureSlope() The slope of the saturation vapour pressure curve [kPa/°C].

  • DailySaturationVapourPressureSlope() Daily satuarion vapour pressure [kPa].

  • ActualVapourPressure() Actual vapour pressure [kPa].

  • DailyActualVapourPressure() Daily actual vapour pressure [kPa].

  • DryAirPressure() Dry air pressure [kPa].

  • DensityAir() Air density [kg/m³]

  • SolarDeclination() Solar declination [-].

  • TSA() Zeitpunkt Sonnenaufgang (time of sunrise) [h].

  • TSU() Zeitpunkt Sonnenuntergang (time of sunset) [h].

  • EarthSunDistance() The relative inverse distance between the earth and the sun [-].

  • ExtraterrestrialRadiation() Extraterrestial radiation [MJ/m²/d].

  • PossibleSunshineDuration() Possible astronomical sunshine duration [h].

  • DailyPossibleSunshineDuration() Possible daily astronomical sunshine duration [h/d].

  • DailyGlobalRadiation() Daily sum of global radiation [MJ/m²/d].

  • SP() Anteil an der Tagesstrahlungsmenge (relative amount of the daily radiation sum) [%].

  • GlobalRadiation() Global Radiation [MJ/m²].

  • AdjustedGlobalRadiation() Adjusted global Radiation [MJ/m²].

  • G() “MORECS” Bodenwärmestrom (“MORECS” soil heat flux) [MJ/m²].

  • TZ() Bodentemperatur in der Tiefe z (soil temperature at depth z) [°C].

  • WG() “Dynamischer” Bodenwärmestrom (“dynamic” soil heat flux) [MJ/m²].

  • NetShortwaveRadiation() Netto kurzwellige Strahlungsbilanz (net shortwave radiation) [MJ/m²].

  • NetShortwaveRadiationInz() Kurzwellige Netto-Strahlungsbilanz für den interzipierten Schnee (net shortwave radiation for intercepted snow) [MJ/m²].

  • NetShortwaveRadiationSnow() Kurzwellige Netto-Strahlungsbilanz für Schneeoberflächen (net shortwave radiation for snow surfaces) [MJ/m²].

  • DailyNetShortwaveRadiation() Daily not shortwave radiation [MJ/m²/d].

  • DailyNetLongwaveRadiation() Daily net longwave radiation [MJ/m²/d].

  • NetLongwaveRadiationInz() Langwellige Nettostrahlung des interzepierten Schnees (net longwave radiation of the intercepted snow [MJ/m²].

  • NetLongwaveRadiationSnow() Net longwave radiation for snow-surfaces [MJ/m²].

  • NetRadiation() Total net radiation [MJ/m²].

  • NetRadiationInz() Nettostrahlung des interzepierten Schnees (total net radiation of the intercepted snow [MJ/m²].

  • NetRadiationSnow() Total net radiation for snow-surfaces [MJ/m²].

  • DailyNetRadiation() Daily not radiation [MJ/m²/d].

  • AerodynamicResistance() Aerodynamischer Widerstand (aerodynamic resistance) [s/m].

  • SoilSurfaceResistance() Oberflächenwiderstand (surface resistance) [s/m].

  • LanduseSurfaceResistance() Oberflächenwiderstand (surface resistance) [s/m].

  • ActualSurfaceResistance() Oberflächenwiderstand (surface resistance) [s/m].

  • NBes() Gesamter Bestandsniederschlag (total stand precipitation) [mm].

  • SBes() Schneeanteil Bestandsniederschlag (frozen stand precipitation) [mm].

  • SnowIntMax() Schneeinterzeptionsspeicherkapazität (capacity of the snow interception storage) [mm].

  • SnowIntRate() Anteil des im Schneeinterzeptionsspeicher zurückgehaltenen Niederschlags (ratio between the snow interception rate and precipitation) [-].

  • NBesInz() Gesamter Bestandsniederschlag, der den Schneeinterzeptionsspeicher erreicht (total stand precipitation reaching the snow interception storage) [mm].

  • SBesInz() Gefrorener Bestandsniederschlag, der den Schneeinterzeptionsspeicher erreicht (frozen amount of stand precipitation reaching the snow interception storage) [mm].

  • WNiedInz() Niederschlagsbedingter Wärmestrom in den Schneeinterzeptionsspeicher (heat flux into the snow interception storage due to precipitation) [MJ/m²].

  • ActualAlbedoInz() Aktuelle Albedo der Oberfläche des interzeptierten Schnees (the current albedo of the surface of the intercepted snow) [-].

  • WaDaInz() Wasserdargebot des Schneeinterzeptionsspeichers (water leaving the snow interception storage) [mm].

  • SchmPotInz() Potentielle Schmelze des interzepierten Schnees (potential amount of snow melting within the snow interception storage) [mm].

  • SchmInz() Tatsächliche Schmelze des interzepierten Schnees (actual amount of snow melting within the snow cover) [mm].

  • GefrPotInz() Potentielles Wiedergefrieren des interzipierten Schnees (potential amount of water refreezing within the snow interception storage) [mm].

  • GefrInz() Tatsächliche Wiedergefrieren des interzipierten Schnees (actual amount of water refreezing within the snow interception storage) [mm].

  • EvSInz() Tatsächliche Verdunstung des interzepierten Schnees (actual evaporation of the intercepted snow) [mm].

  • ET0() Grasreferenzverdunstung (reference evapotranspiration) [mm].

  • EvPo() Evapotranspiration (evapotranspiration) [mm].

  • EvI() Tatsächliche Interzeptionsverdunstung (actual evaporation of intercepted water) [mm].

  • EvB() Tatsächliche Verdunstung von Bodenwasser (actual evaporation of soil water) [mm].

  • EvS() Tatsächliche Schneeverdunstung (actual evaporation of snow-water) [mm].

  • WGTF() Mit dem Grad-Tag-Verfahren berechneter Wärmeestrom in die Schneedecke (heat flux into the snow layer calculated with the degree-day method) [MJ/m²].

  • WNied() Niederschlagsbedingter Wärmestrom in die Schneedecke (heat flux into the snow layer due to precipitation) [MJ/m²].

  • TempSSurface() Schneetemperatur an der Schneeoberfläche (the snow temperature at the snow surface) [°C].

  • ActualAlbedo() Aktuelle Albedo der relevanten Oberfläche (the current albedo of the relevant surface) [-].

  • SchmPot() Potentielle Schneeschmelze (potential amount of water melting within the snow cover) [mm].

  • Schm() Tatsächliche Schneeschmelze (actual amount of water melting within the snow cover) [mm].

  • GefrPot() Potentielles Schnee-Wiedergefrieren (potential amount of water refreezing within the snow cover) [mm].

  • Gefr() Tatsächliche Schnee-Wiedergefrieren (actual amount of water refreezing within the snow cover) [mm].

  • WLatInz() Latente Wärmestrom interzepierter Schnee/Atmosphäre (latent heat flux between the intercepted snow and the atmosphere) [MJ/m²].

  • WLatSnow() Latente Wärmestrom Schnee/Atmosphäre (latent heat flux between the snow-layer and the atmosphere) [MJ/m²].

  • WSensInz() Fühlbare Wärmestrom interzipierter Schnee/Atmosphäre (sensible heat flux between the intercepted snow and the atmosphere) [MJ/m²].

  • WSensSnow() Fühlbare Wärmestrom Schnee/Atmosphäre (sensible heat flux between the snow-layer and the atmosphere) [MJ/m²].

  • WSurfInz() Wärmestrom vom Körper des interzepierten Schnees bis zu dessen Schneeoberfläche (heat flux from the body of the intercepted snow to its surface) [MJ/m²].

  • WSurf() Wärmestrom von der Schneedecke zur Schneeoberfläche (heat flux from the snow layer to the snow surface) [MJ/m²].

  • SFF() Relativer Anteil des gefrorenen Bodenwassers bis zu einer Tiefe von 2z (relative proportion of frozen soil water) [-].

  • FVG() Frostversiegelungsgrad (degree of frost sealing) [-].

  • WaDa() Wasserdargebot (water reaching the soil routine) [mm].

  • QDB() Direktabfluss-Abgabe aus dem Bodenspeicher (direct runoff release from the soil storage) [mm].

  • QIB1() Erste Komponente der Interflow-Abgabe aus dem Bodenspeicher (first component of the interflow release from the soil storage) [mm].

  • QIB2() Zweite Komponente der Interflow-Abgabe aus dem Bodenspeicher (second component of the interflow release from the soil storage) [mm].

  • QBB() Basisabfluss-Abgabe aus dem Bodenspeicher (base flow release from the soil storage) [mm].

  • QKap() Kapillarer Aufstieg in den Bodenspeicher (capillary rise to soil storage) [mm].

  • QDGZ() Gesamtzufluss in beide Direktabfluss-Gebietsspeicher (total inflow into both storage compartments for direct runoff) [mm].

  • QAH() Abflussspende des Teilgebiets (runoff at the catchment outlet) [mm].

  • QA() Abfluss des Teilgebiets (runoff at the catchment outlet) [m³/s].

class hydpy.models.lland.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 lland.

The following classes are selected:

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

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

Bases: hydpy.core.sequencetools.ModelIOSequences[InputSequence, hydpy.core.sequencetools.FastAccessInputSequence]

Input sequences of model lland.

The following classes are selected:
class hydpy.models.lland.LogSequences(master: hydpy.core.sequencetools.Sequences, cls_fastaccess: Optional[Type[FastAccessType]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

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

Log sequences of model lland.

The following classes are selected:
class hydpy.models.lland.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 lland.

The following classes are selected:

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

class hydpy.models.lland.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 lland.

The following classes are selected:

  • Inzp() Interzeptionsspeicherung (interception storage) [mm].

  • STInz() Wasseräquivalent Trockenschnee im Interzeptionsspeicher (total water equivalent of the intercepted snow) [mm].

  • SInz() Wasseräquivalent Gesamtschnee im Interzeptionsspeicher (frozen water equivalent of the intercepted snow) [mm].

  • ESnowInz() Kälteinhalt der Schneedecke des Interzeptionsspeichers [MJ/m²].

  • ASInz() Dimensionsloses Alter des interzipierten Schnees (dimensionless age of the intercepted snow layer) [-].

  • WATS() Wasseräquivalent Trockenschnee auf der Bodenoberfläche (frozen water equivalent of the snow cover) [mm].

  • WAeS() Wasseräquivalent Gesamtschnee auf der Bodenoberfläche (total water equivalent of the snow cover) [mm].

  • ESnow() Thermischer Energieinhalt der Schneedecke bezogen auf 0°C (thermal energy content of the snow layer with respect to 0°C) [MJ/m²].

  • TauS() Dimensionsloses Alter der Schneedecke (dimensionless age of the snow layer) [-].

  • EBdn() Energiegehalt des Bodenwassers (energy content of the soil water) [MJ/m²].

  • BoWa() Bodenwasserspeicherung (soil water storage) [mm].

  • QDGZ1() Zufluss in den trägeren Direktabfluss-Gebietsspeicher (inflow into the less responsive storage compartment for direct runoff) [mm].

  • QDGZ2() Zufluss in den dynamischeren Direktabfluss-Gebietsspeicher (inflow into the more responsive storage compartment for direct runoff) [mm].

  • QIGZ1() “Zufluss in den ersten Zwischenabfluss-Gebietsspeicher (inflow into the first storage compartment for interflow) [mm].

  • QIGZ2() Zufluss in den zweiten Zwischenabfluss-Gebietsspeicher (inflow into the second storage compartment for interflow) [mm].

  • QBGZ() Zufluss in den Basisabfluss-Gebietsspeicher (inflow into the storage compartment for base flow) [mm].

  • QDGA1() Abfluss aus dem trägeren Direktabfluss-Gebietsspeicher (outflow from the less responsive storage compartment for direct runoff) [mm].

  • QDGA2() Abfluss aus dem dynamischeren Direktabfluss-Gebietsspeicher (outflow from the more responsive storage compartment for direct runoff) [mm].

  • QIGA1() Abfluss aus dem “unteren” Zwischenabfluss-Gebietsspeicher (outflow from the storage compartment for the first interflow component) [mm].

  • QIGA2() Abfluss aus dem “oberen” Zwischenabfluss-Gebietsspeicher (outflow from the storage compartment for the second interflow component) [mm].

  • QBGA() Abfluss aus dem Basisabfluss-Gebietsspeicher (outflow from the storage compartment for base flow) [mm].