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

Bases: 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:

• Calc_QZH_V1 Calculate the inflow in mm.

• Update_LoggedTemL_V1 Log the air temperature values of the last 24 hours.

• Calc_TemLTag_V1 Calculate the average air temperature of the last 24 hours.

• Update_LoggedRelativeHumidity_V1 Log the sunshine duration values of the last 24 hours.

• Calc_DailyRelativeHumidity_V1 Calculate the average relative humidity of the last 24 hours.

• Update_LoggedSunshineDuration_V1 Log the sunshine duration values of the last 24 hours.

• Calc_DailySunshineDuration_V1 Calculate the sunshine duration sum of the last 24 hours.

• Update_LoggedPossibleSunshineDuration_V1 Log the sunshine duration values of the last 24 hours.

• Calc_DailyPossibleSunshineDuration_V1 Calculate the sunshine duration sum of the last 24 hours.

• Update_LoggedGlobalRadiation_V1 Log the global radiation values of the last 24 hours.

• Calc_DailyGlobalRadiation_V1 Calculate the global radiation sum of the last 24 hours.

• Calc_NKor_V1 Adjust the given precipitation value according to LEG (2020).

• Calc_TKor_V1 Adjust the given air temperature value.

• Calc_TKorTag_V1 Adjust the given daily air temperature value.

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

• Calc_ReducedWindSpeed2m_V1 Calculate the landuse-use-specific wind speed at height of 2 meters according to LEG (2020) (based on LUBW (2006), LUWG (2015)).

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

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

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

• Calc_SaturationVapourPressure_V1 Calculate the saturation vapour pressure over arbitrary surfaces.

• Calc_DailySaturationVapourPressure_V1 Calculate the daily saturation vapour pressure over arbitrary surfaces.

• Calc_SaturationVapourPressureSlope_V1 Calculate the daily slope of the saturation vapour pressure curve.

• Calc_DailySaturationVapourPressureSlope_V1 Calculate the daily slope of the saturation vapour pressure curve.

• Calc_ActualVapourPressure_V1 Calculate the actual vapour pressure.

• Calc_DailyActualVapourPressure_V1 Calculate the daily actual vapour pressure.

• Calc_ET0_V1 Calculate reference evapotranspiration after Turc-Wendling.

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

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

• Calc_NBes_Inzp_V1 Calculate stand precipitation and update the interception storage accordingly.

• Calc_SNRatio_V1 Calculate the ratio of frozen to total precipitation according to LEG (2020).

• Calc_SBes_V1 Calculate the frozen part of stand precipitation.

• Calc_SnowIntMax_V1 Calculate the current capacity of the snow interception storage according to LEG (2020).

• Calc_SnowIntRate_V1 Calculate the ratio between the snow interception rate and precipitation intensity according to LEG (2020).

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

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

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

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

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

• Calc_TempSInz_V1 Calculate the average temperature of the intercepted snow.

• Update_ASInz_V1 Calculate the dimensionless age of the intercepted snow.

• Calc_NetShortwaveRadiationInz_V1 Calculate the net shortwave radiation for the intercepted snow.

• Calc_ActualAlbedoInz_V1 Calculate the current albedo of the intercepted snow.

• Update_ESnowInz_V1 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).

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

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

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

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

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

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

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

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

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

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

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

• Calc_WGTF_V1 Calculate the heat flux according to the degree-day method according to LEG (2020).

• Calc_WNied_V1 Calculate the heat flux into the snow layer due to the total amount of ingoing precipitation (LEG (2020), modified).

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

• Calc_TZ_V1 Calculate the mean temperature in the top-layer of the soil according to LEG (2020) (based on LUBW (2006)).

• Calc_WG_V1 Calculate the soil heat flux.

• Calc_TempS_V1 Calculate the average temperature of the snow layer.

• Update_TauS_V1 Calculate the dimensionless age of the snow layer according to LEG (2020) (based on LUBW (2006)).

• Calc_ActualAlbedo_V1 Calculate the current albedo value according to LEG (2020) (based on LUBW (2006)).

• Calc_NetShortwaveRadiation_V1 Calculate the net shortwave radiation.

• Calc_NetShortwaveRadiationSnow_V1 Calculate the net shortwave radiation for snow-surfaces.

• Calc_DailyNetShortwaveRadiation_V1 Calculate the daily net shortwave radiation.

• Calc_RLAtm_V1 Calculate the longwave radiation emitted from the atmosphere according to LEG (2020) (based on Thompson et al. (1981)).

• Calc_G_V1 Calculate and return the “MORECS” soil heat flux (modified LEG (2020), based on Thompson et al. (1981)).

• Calc_G_V2 Take the actual daily soil heat flux from parameter WG2Z.

• Calc_EvB_V2 Calculate the actual evapotranspiration from the soil.

• Update_EBdn_V1 Update the thermal energy content of the upper soil layer according to LEG (2020).

• Update_ESnow_V1 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). LEG (2020) based on LUBW (2006), modified.

• Calc_NetRadiation_V1 Calculate the total net radiation.

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

• Calc_DryAirPressure_V1 Calculate the pressure of the dry air (based on DWD (1987)).

• Calc_DensityAir_V1 Calculate the density of the air (based on DWD (1987)).

• Calc_AerodynamicResistance_V1 Calculate the aerodynamic resistance according to LEG (2020) (based on Thompson et al. (1981)).

• Calc_SoilSurfaceResistance_V1 Calculate the surface resistance of the bare soil surface according to LEG (2020) (based on Thompson et al. (1981)).

• Calc_LanduseSurfaceResistance_V1 Calculate the surface resistance of vegetation, water and sealed areas according to LEG (2020) (based on Thompson et al. (1981)).

• Calc_ActualSurfaceResistance_V1 Calculate the total surface resistance according to LEG (2020) (based on Grant (1975)).

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

• Calc_EvI_Inzp_V1 Calculate interception evaporation and update the interception storage accordingly.

• Calc_EvI_Inzp_V2 Calculate interception evaporation and update the interception storage accordingly.

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

• Calc_EvB_V1 Calculate the actual soil evapotranspiration.

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

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

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

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

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

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

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

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

• Calc_SFF_V1 Calculate the ratio between frozen water and total water within the top soil layer according to LEG (2020).

• Calc_FVG_V1 Calculate the degree of frost sealing of the soil according to LEG (2020).

• Calc_QKap_V1 Calculate the capillary rise.

• Calc_QBB_V1 Calculate the amount of base flow released from the soil.

• Calc_QIB1_V1 Calculate the first inflow component released from the soil.

• Calc_QIB2_V1 Calculate the second inflow component released from the soil.

• Calc_QDB_V1 Calculate direct runoff released from the soil.

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

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

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

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

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

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

• Calc_QBGA_V1 Perform the runoff concentration calculation for base flow.

• Update_QDGZ_QBGZ_QBGA_V1 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 according to LEG (2020).

• Update_QDGZ_QBGZ_QBGA_V2 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 according to LEG (2020).

• Calc_QIGA1_V1 Perform the runoff concentration calculation for the first interflow component.

• Calc_QIGA2_V1 Perform the runoff concentration calculation for the second interflow component.

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

• Calc_QDGA1_V1 Perform the runoff concentration calculation for “slow” direct runoff.

• Calc_QDGA2_V1 Perform the runoff concentration calculation for “fast” direct runoff.

• Calc_QAH_V1 Calculate the final runoff in mm.

• Calc_QA_V1 Calculate the final runoff in m³/s.

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

• Pass_QA_V1 Update the outlet link sequence.

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

• Return_AdjustedWindSpeed_V1 Adjust and return the measured wind speed to the given defined height above the ground according to LEG (2020).

• Return_ActualVapourPressure_V1 Calculate and return the actual vapour pressure for the given saturation vapour pressure and relative humidity according to LEG (2020) (based on Weischet and Endlicher (1983)).

• Calc_DailyNetLongwaveRadiation_V1 Calculate the daily net longwave radiation.

• Return_NetLongwaveRadiationInz_V1 Calculate and return the net longwave radiation for intercepted snow.

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

• Return_Penman_V1 Calculate and return the evaporation from water surfaces according to Penman according to LEG (2020) (based on DVWK (1996)).

• Return_PenmanMonteith_V1 Calculate and return the evapotranspiration according to Penman-Monteith according to LEG (2020) (based on Thompson et al. (1981)).

• Return_EnergyGainSnowSurface_V1 Calculate and return the net energy gain of the snow surface (:cite:t`ref-LARSIM` based on LUBW (2006), modified).

• Return_SaturationVapourPressure_V1 Calculate and return the saturation vapour pressure over an arbitrary surface for the given temperature according to LEG (2020) (based on Weischet and Endlicher (1983)).

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

• Return_NetRadiation_V1 Calculate and return the total net radiation.

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

• Return_WSensSnow_V1 Calculate and return the sensible heat flux of the snow surface according to LEG (2020).

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

• Return_WLatSnow_V1 Calculate and return the latent heat flux of the snow surface according to LEG (2020).

• Return_WSurfInz_V1 Calculate and return the intercepted snow heat flux WSurfInz.

• Return_WSurf_V1 Calculate and return the snow surface heat flux according to LEG (2020) (based on LUBW (2006)).

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

• Return_BackwardEulerError_V1 Calculate and return the “Backward Euler error” regarding the update of ESnow due to the energy fluxes WG and WSurf (LEG (2020) based on LUBW (2006), modified).

• Return_TempSInz_V1 Calculate and return the average temperature of the intercepted snow.

• Return_TempS_V1 Calculate and return the average temperature of the snow layer according to LEG (2020).

• Return_WG_V1 Calculate and return the “dynamic” soil heat flux according to LEG (2020).

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

• Return_ESnow_V1 Calculate and return the thermal energy content of the snow layer for the given bulk temperature according to LEG (2020).

• Return_TempSSurface_V1 Determine and return the snow surface temperature (LEG (2020) based on LUBW (2006), modified).

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.

class hydpy.models.lland.lland_model.Pick_QZ_V1

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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.Update_LoggedPossibleSunshineDuration_V1

Bases: Method

Log the sunshine duration values of the last 24 hours.

Requires the derived parameter:

NmbLogEntries

Requires the input sequence:

PossibleSunshineDuration

Updates the log sequence:

LoggedPossibleSunshineDuration

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.loggedpossiblesunshineduration.shape = 3
>>> logs.loggedpossiblesunshineduration = 0.0
>>> from hydpy import UnitTest
>>> test = UnitTest(model,
...                 model.update_loggedpossiblesunshineduration_v1,
...                 last_example=4,
...                 parseqs=(inputs.possiblesunshineduration,
...                          logs.loggedpossiblesunshineduration))
>>> test.nexts.possiblesunshineduration = 1.0, 3.0, 2.0, 4.0
>>> del test.inits.loggedpossiblesunshineduration
>>> test()
| ex. | possiblesunshineduration |           loggedpossiblesunshineduration |
-----------------------------------------------------------------------------
|   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_DailyPossibleSunshineDuration_V1

Bases: Method

Calculate the sunshine duration sum of the last 24 hours.

Requires the derived parameter:

NmbLogEntries

Requires the log sequence:

LoggedPossibleSunshineDuration

Updates the flux sequence:

DailyPossibleSunshineDuration

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedpossiblesunshineduration.shape = 3
>>> logs.loggedpossiblesunshineduration = 1.0, 5.0, 3.0
>>> model.calc_dailypossiblesunshineduration_v1()
>>> fluxes.dailypossiblesunshineduration
dailypossiblesunshineduration(9.0)

class hydpy.models.lland.lland_model.Calc_NKor_V1

Bases: Method

Adjust the given precipitation value according to LEG (2020).

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

Bases: 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

Bases: 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

Bases: Method

Adjust and return the measured wind speed to the given defined height above the ground according to LEG (2020).

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

Bases: 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

Bases: Method

Calculate the landuse-use-specific wind speed at height of 2 meters according to LEG (2020) (based on LUBW (2006), LUWG (2015)).

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

Bases: 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.Update_LoggedGlobalRadiation_V1

Bases: Method

Log the global radiation values of the last 24 hours.

Requires the derived parameter:

NmbLogEntries

Requires the input 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=(inputs.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

Bases: Method

Calculate the global radiation sum of the last 24 hours.

Requires the derived parameter:

NmbLogEntries

Requires the log sequence:

LoggedGlobalRadiation

Updates the flux sequence:

DailyGlobalRadiation

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedglobalradiation.shape = 3
>>> logs.loggedglobalradiation = 100.0, 800.0, 600.0
>>> model.calc_dailyglobalradiation_v1()
>>> fluxes.dailyglobalradiation
dailyglobalradiation(500.0)

class hydpy.models.lland.lland_model.Calc_ET0_V1

Bases: Method

Calculate reference evapotranspiration after Turc-Wendling.

Requires the control parameters:

NHRU KE KF HNN

Requires the input sequence:

GlobalRadiation

Requires the flux sequence:

TKor

Calculates the flux sequence:

ET0

Basic equation:

\(ET0 = KE \cdot \frac{(8.64 \cdot GlobalRadiation + 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.globalradiation = 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

Bases: 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

Bases: 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

Bases: 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

Bases: Method

Calculate the ratio of frozen to total precipitation according to LEG (2020).

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

Bases: 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

Bases: Method

Calculate the current capacity of the snow interception storage according to LEG (2020).

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:

\[\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

Bases: Method

Calculate the ratio between the snow interception rate and precipitation intensity according to LEG (2020).

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:

\(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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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 *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nhru(6)
>>> lnk(LAUBW, MISCHW, NADELW, NADELW, NADELW, ACKER)
>>> trefn(1.0)
>>> states.esnowinz = 0.5
>>> 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(2.9075, -0.969167, -0.726481, -0.483796, -0.241898, 0.0)
>>> states.esnowinz
esnowinz(3.4075, -0.469167, -0.226481, 0.016204, 0.258102, 0.0)

class hydpy.models.lland.lland_model.Return_TempSInz_V1

Bases: 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 *
>>> simulationstep("12h")
>>> 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, -1.0, -10.0, -100.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))
-1.376498
>>> round_(model.return_tempsinz_v1(3))
-137.649758
>>> round_(model.return_tempsinz_v1(4))
-273.0

class hydpy.models.lland.lland_model.Calc_TempSInz_V1

Bases: 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 *
>>> simulationstep("12h")
>>> 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, -2.0, -2.0, -2.0, -2.0
>>> model.calc_tempsinz_v1()
>>> aides.tempsinz
tempsinz(nan, 0.0, -2.752995, -2.752995, -2.752995, -2.752995)

class hydpy.models.lland.lland_model.Update_ASInz_V1

Bases: 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

Bases: 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

Bases: Method

Calculate the net shortwave radiation for the intercepted snow.

Requires the control parameters:

NHRU Lnk

Requires the derived parameters:

Fr MOY

Requires the input sequence:

GlobalRadiation

Requires the flux sequence:

ActualAlbedoInz

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()
>>> inputs.globalradiation = 40.0
>>> fluxes.actualalbedoinz = 0.5

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

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

class hydpy.models.lland.lland_model.Calc_SchmPotInz_V1

Bases: 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 *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nhru(4)
>>> states.sinz = 0.0, 1.0, 1.0, 1.0
>>> states.esnowinz = nan, 10.0, 5.0, -5.0
>>> model.calc_schmpotinz_v1()
>>> fluxes.schmpotinz
schmpotinz(0.0, 1.293413, 0.646707, 0.0)

class hydpy.models.lland.lland_model.Calc_SchmInz_STInz_V1

Bases: 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

Bases: 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 *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nhru(4)
>>> states.sinz = 0.0, 1.0, 1.0, 1.0
>>> states.esnowinz = nan, -10.0, -5.0, 5.0
>>> model.calc_gefrpotinz_v1()
>>> fluxes.gefrpotinz
gefrpotinz(0.0, 1.293413, 0.646707, 0.0)

class hydpy.models.lland.lland_model.Calc_GefrInz_STInz_V1

Bases: 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

Bases: 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 - EvSInz}{SInz}\)

\(EvSInz = max \left( \frac{WLatInz}{LWE}, SInz \right)\)

Example:

>>> from hydpy.models.lland import *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nhru(8)
>>> lnk(LAUBW, MISCHW, NADELW, NADELW, NADELW, NADELW, NADELW, ACKER)
>>> fluxes.wlatinz = -20.0, 0.0, 50.0, 100.0, 150.0, 150.0, 150.0, 150.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.323905, 0.0, 0.809762, 1.619524, 2.0, 1.5, 0.0, 0.0)
>>> states.sinz
sinz(2.323905, 2.0, 1.190238, 0.380476, 0.0, 0.0, 0.0, 0.0)
>>> states.stinz
stinz(1.161952, 1.0, 0.595119, 0.190238, 0.0, 0.0, 0.0, 0.0)

class hydpy.models.lland.lland_model.Update_WaDaInz_SInz_V1

Bases: 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

Bases: 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 *
>>> simulationstep("12h")
>>> 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 = 20.0, 20.0, -40.0, 30.925926, 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, -9.074074, 0.0, 0.0)

class hydpy.models.lland.lland_model.Calc_WATS_V1

Bases: 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

Bases: 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

Bases: 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

Bases: 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.5, 1.5, 1.5, 0.5, 1.0, 1.5, 1.0, 0.0, 0.5, 1.0)

class hydpy.models.lland.lland_model.Calc_WGTF_V1

Bases: Method

Calculate the heat flux according to the degree-day method according to LEG (2020).

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 *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> 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, 19.328704, 19.328704, 0.0, -19.328704)

class hydpy.models.lland.lland_model.Calc_WNied_V1

Bases: Method

Calculate the heat flux into the snow layer due to the total amount of ingoing precipitation (LEG (2020), 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 *
>>> simulationstep("12h")
>>> 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(2.9075, -0.969167, -0.726481, -0.483796, 0.0)

class hydpy.models.lland.lland_model.Calc_WNied_ESnow_V1

Bases: 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 *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nhru(6)
>>> lnk(ACKER, ACKER, ACKER, ACKER, ACKER, WASSER)
>>> trefn(1.0)
>>> states.esnow = 0.5
>>> 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(2.9075, -0.969167, -0.726481, -0.483796, -0.241898, 0.0)
>>> states.esnow
esnow(3.4075, -0.469167, -0.226481, 0.016204, 0.258102, 0.0)

class hydpy.models.lland.lland_model.Return_SaturationVapourPressure_V1

Bases: Method

Calculate and return the saturation vapour pressure over an arbitrary surface for the given temperature according to LEG (2020) (based on Weischet and Endlicher (1983)).

Required by the methods:

Calc_DailySaturationVapourPressure_V1 Calc_SaturationVapourPressure_V1 Return_BackwardEulerErrorInz_V1 Return_EnergyGainSnowSurface_V1 Return_WSurfInz_V1

Basic equation:

\(6.1078 \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))
12.293852

class hydpy.models.lland.lland_model.Return_SaturationVapourPressureSlope_V1

Bases: 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{24430.6 \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.824774
>>> dx = 1e-6
>>> round_((model.return_saturationvapourpressure_v1(10.0+dx) -
...         model.return_saturationvapourpressure_v1(10.0-dx))/2/dx)
0.824775

class hydpy.models.lland.lland_model.Calc_SaturationVapourPressure_V1

Bases: 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(2.850871, 6.1078, 12.293852)

class hydpy.models.lland.lland_model.Calc_DailySaturationVapourPressure_V1

Bases: 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(2.850871, 6.1078, 12.293852)

class hydpy.models.lland.lland_model.Calc_SaturationVapourPressureSlope_V1

Bases: 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
>>> model.calc_saturationvapourpressureslope_v1()
>>> fluxes.saturationvapourpressureslope
saturationvapourpressureslope(0.226909, 0.445506, 0.824774)

class hydpy.models.lland.lland_model.Calc_DailySaturationVapourPressureSlope_V1

Bases: 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.824774, 0.445506, 0.226909)

class hydpy.models.lland.lland_model.Return_ActualVapourPressure_V1

Bases: Method

Calculate and return the actual vapour pressure for the given saturation vapour pressure and relative humidity according to LEG (2020) (based on Weischet and Endlicher (1983)).

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(20.0, 60.0))
12.0

class hydpy.models.lland.lland_model.Calc_ActualVapourPressure_V1

Bases: 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 = 20.0
>>> model.calc_actualvapourpressure_v1()
>>> fluxes.actualvapourpressure
actualvapourpressure(12.0)

class hydpy.models.lland.lland_model.Calc_DailyActualVapourPressure_V1

Bases: 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 = 40.0
>>> model.calc_dailyactualvapourpressure_v1()
>>> fluxes.dailyactualvapourpressure
dailyactualvapourpressure(16.0)

class hydpy.models.lland.lland_model.Calc_DailyNetLongwaveRadiation_V1

Bases: 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} {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 = 16.0, 6.0
>>> fluxes.dailysunshineduration = 12.0
>>> fluxes.dailypossiblesunshineduration = 14.0
>>> model.calc_dailynetlongwaveradiation_v1()
>>> fluxes.dailynetlongwaveradiation
dailynetlongwaveradiation(40.451915, 58.190798)

class hydpy.models.lland.lland_model.Calc_RLAtm_V1

Bases: Method

Calculate the longwave radiation emitted from the atmosphere according to LEG (2020) (based on Thompson et al. (1981)).

Requires the control parameter:

NHRU

Requires the fixed parameters:

Sigma FrAtm

Requires the flux sequences:

TKor ActualVapourPressure DailySunshineDuration DailyPossibleSunshineDuration

Calculates the aide sequence:

RLAtm

Basic equation:

\(RLAtm = FrAtm \cdot Sigma \cdot (Tkor + 273.15)^4 \cdot \left( \frac{ActualVapourPressure}{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)
>>> emissivity(0.95)
>>> fluxes.tkor = 0.0, 10.0
>>> fluxes.actualvapourpressure = 6.0
>>> fluxes.dailysunshineduration = 12.0
>>> fluxes.dailypossiblesunshineduration = 14.0
>>> model.calc_rlatm_v1()
>>> aides.rlatm
rlatm(235.207154, 270.197425)

class hydpy.models.lland.lland_model.Return_NetLongwaveRadiationInz_V1

Bases: 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 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.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 = 100.0

>>> 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, 126.624073
1, 84.416049

>>> 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, 105.520061
1, 63.312037

class hydpy.models.lland.lland_model.Return_NetLongwaveRadiationSnow_V1

Bases: 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:

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 LEG (2020) and Thompson et al. (1981) 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.shape = 1
>>> derived.moy(5)
>>> derived.fr(0.3)
>>> fluxes.tempssurface = -5.0
>>> fluxes.tkor = 0.0
>>> aides.rlatm = 235.207154
>>> from hydpy import print_values
>>> for hru in range(2):
...     print_values([hru, model.return_netlongwaveradiationsnow_v1(hru)])
0, 57.945793
1, 8.273292

class hydpy.models.lland.lland_model.Update_TauS_V1

Bases: Method

Calculate the dimensionless age of the snow layer according to LEG (2020) (based on LUBW (2006)).

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

Bases: Method

Calculate the current albedo value according to LEG (2020) (based on LUBW (2006)).

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

Bases: Method

Calculate the net shortwave radiation.

Requires the control parameter:

NHRU

Requires the input sequence:

GlobalRadiation

Requires the flux sequence:

ActualAlbedo

Calculates the flux sequence:

NetShortwaveRadiation

Basic equation:

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

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(1)
>>> inputs.globalradiation = 100.0
>>> fluxes.actualalbedo = 0.25
>>> model.calc_netshortwaveradiation_v1()
>>> fluxes.netshortwaveradiation
netshortwaveradiation(75.0)

class hydpy.models.lland.lland_model.Calc_NetShortwaveRadiationSnow_V1

Bases: Method

Calculate the net shortwave radiation for snow-surfaces.

Requires the control parameters:

NHRU Lnk

Requires the derived parameters:

MOY Fr

Requires the input sequence:

GlobalRadiation

Requires the flux sequence:

ActualAlbedo

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()
>>> inputs.globalradiation = 40.0
>>> fluxes.actualalbedo = 0.5

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

>>> model.idx_sim = pub.timegrids.init["2000-02-01"]
>>> model.calc_netshortwaveradiationsnow_v1()
>>> fluxes.netshortwaveradiationsnow
netshortwaveradiationsnow(20.0, 2.0)

class hydpy.models.lland.lland_model.Calc_DailyNetShortwaveRadiation_V1

Bases: 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 = 100.0
>>> model.calc_dailynetshortwaveradiation_v1()
>>> fluxes.dailynetshortwaveradiation
dailynetshortwaveradiation(75.0)

class hydpy.models.lland.lland_model.Return_TempS_V1

Bases: Method

Calculate and return the average temperature of the snow layer according to LEG (2020).

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 *
>>> simulationstep("12h")
>>> 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, -1.0, -10.0, -100.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))
-1.376498
>>> round_(model.return_temps_v1(3))
-137.649758
>>> round_(model.return_temps_v1(4))
-273.0

class hydpy.models.lland.lland_model.Return_ESnowInz_V1

Bases: 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 *
>>> simulationstep("12h")
>>> 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, -2.0
>>> 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, -2.752995))
-2.0

class hydpy.models.lland.lland_model.Return_ESnow_V1

Bases: Method

Calculate and return the thermal energy content of the snow layer for the given bulk temperature according to LEG (2020).

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 *
>>> simulationstep("12h")
>>> 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, -2.0
>>> 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, -2.752995))
-2.0

class hydpy.models.lland.lland_model.Calc_TempS_V1

Bases: 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 *
>>> simulationstep("12h")
>>> 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, -2.0
>>> model.calc_temps_v1()
>>> aides.temps
temps(nan, 0.0, -2.752995)

class hydpy.models.lland.lland_model.Calc_TZ_V1

Bases: Method

Calculate the mean temperature in the top-layer of the soil according to LEG (2020) (based on LUBW (2006)).

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 *
>>> simulationstep("12h")
>>> 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(310.0)
>>> states.ebdn(-20.0, -10.0, 0.0, 310.0, 620.0, 630, 640.0)
>>> model.calc_tz_v1()
>>> fluxes.tz
tz(-2.88, -1.44, 0.0, 0.0, 0.0, 1.44, 2.88)

class hydpy.models.lland.lland_model.Calc_G_V1

Bases: Method

Calculate and return the “MORECS” soil heat flux (modified LEG (2020), based on Thompson et al. (1981)).

Requires the control parameters:

NHRU Lnk LAI WG2Z

Requires the derived parameters:

MOY Hours

Requires the input sequence:

PossibleSunshineDuration

Requires the flux sequences:

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.

Warning

This method was implemented when lland handled energy fluxes in MJ/m²/T. Before using it in an application model, one probably needs to adjust it to the new energy flux unit W/m².

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 = 10.0
>>> wg2z.jun = -20.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:

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

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

>>> fluxes.dailynetradiation = 100.0, 100.0, -100.0, 100.0, 100.0, 100.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(10.0, 10.0, 10.0, 10.0, 10.0, 0.0)
>>> model.idx_sim = pub.timegrids.init["2000-06-01"]
>>> model.calc_g_v1()
>>> fluxes.g
g(-20.0, -20.0, -20.0, -20.0, -20.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:

>>> inputs.possiblesunshineduration = 1.0
>>> model.calc_g_v1()
>>> fluxes.g
g(-2.142857, -1.071429, 1.071429, 0.0, 1.071429, 0.0)
>>> day = fluxes.g.values.copy()

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

>>> inputs.possiblesunshineduration = 0.0
>>> model.calc_g_v1()
>>> fluxes.g
g(4.0, 2.5, -0.5, 1.0, -0.5, 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))
10.0, 10.0, 10.0, 10.0, 10.0, 0.0

class hydpy.models.lland.lland_model.Calc_G_V2

Bases: Method

Take the actual daily soil heat flux from parameter WG2Z.

Requires the control parameters:

NHRU Lnk WG2Z

Requires the derived parameter:

MOY

Calculates the flux sequence:

G

Basic equations:

\(G = WG2Z\)

Note

Method Calc_G_V1 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 = 12.0
>>> wg2z.jun = -24.0
>>> derived.moy.update()
>>> derived.days.update()
>>> model.idx_sim = pub.timegrids.init["2000-05-31 23:00"]
>>> model.calc_g_v2()
>>> fluxes.g
g(12.0, 0.0, 0.0, 0.0)
>>> model.idx_sim = pub.timegrids.init["2000-06-01 00:00"]
>>> model.calc_g_v2()
>>> fluxes.g
g(-24.0, 0.0, 0.0, 0.0)

class hydpy.models.lland.lland_model.Return_WG_V1

Bases: Method

Calculate and return the “dynamic” soil heat flux according to LEG (2020).

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))
-48.0
>>> round_(model.return_wg_v1(1))
18.0

class hydpy.models.lland.lland_model.Calc_WG_V1

Bases: 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(-48.0, 18.0, 0.0, 0.0, 0.0)

class hydpy.models.lland.lland_model.Update_EBdn_V1

Bases: Method

Update the thermal energy content of the upper soil layer according to LEG (2020).

Requires the control parameters:

NHRU Lnk WG2Z

Requires the derived parameter:

MOY

Requires the flux sequence:

WG

Updates the state sequence:

EBdn

Basic equation:

\(\frac{dEBdn}{dt} = WG2Z - 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()
>>> wg2z.apr = -0.347222
>>> wg2z.may = -0.462963
>>> states.ebdn = 0.0
>>> fluxes.wg = 0.0, 0.0, 0.0, 5.787037, 11.574074, 23.148148
>>> model.idx_sim = 1
>>> model.update_ebdn_v1()
>>> states.ebdn
ebdn(0.0, 0.0, 0.0, -6.134259, -11.921296, -23.49537)
>>> model.idx_sim = 2
>>> model.update_ebdn_v1()
>>> states.ebdn
ebdn(0.0, 0.0, 0.0, -12.384259, -23.958333, -47.106481)

class hydpy.models.lland.lland_model.Return_WSensInz_V1

Bases: 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 *
>>> parameterstep()
>>> nhru(2)
>>> turb0(2.0)
>>> turb1(2.0)
>>> 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))
-24.0
>>> round_(model.return_wsensinz_v1(1))
8.0

class hydpy.models.lland.lland_model.Return_WSensSnow_V1

Bases: Method

Calculate and return the sensible heat flux of the snow surface according to LEG (2020).

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 *
>>> parameterstep()
>>> nhru(2)
>>> turb0(2.0)
>>> turb1(2.0)
>>> 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))
-24.0
>>> round_(model.return_wsenssnow_v1(1))
8.0

class hydpy.models.lland.lland_model.Return_WLatInz_V1

Bases: 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 *
>>> parameterstep()
>>> nhru(2)
>>> turb0(2.0)
>>> turb1(2.0)
>>> fluxes.reducedwindspeed2m = 3.0
>>> fluxes.saturationvapourpressureinz = 4.0, 8.0
>>> fluxes.actualvapourpressure = 6.108
>>> from hydpy import round_
>>> round_(model.return_wlatinz_v1(0))
-29.68064
>>> round_(model.return_wlatinz_v1(1))
26.63936

class hydpy.models.lland.lland_model.Return_WLatSnow_V1

Bases: Method

Calculate and return the latent heat flux of the snow surface according to LEG (2020).

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 *
>>> parameterstep()
>>> nhru(2)
>>> turb0(2.0)
>>> turb1(2.0)
>>> fluxes.reducedwindspeed2m = 3.0
>>> fluxes.saturationvapourpressuresnow = 4.0, 8.0
>>> fluxes.actualvapourpressure = 6.108
>>> from hydpy import round_
>>> round_(model.return_wlatsnow_v1(0))
-29.68064
>>> round_(model.return_wlatsnow_v1(1))
26.63936

class hydpy.models.lland.lland_model.Return_WSurf_V1

Bases: Method

Calculate and return the snow surface heat flux according to LEG (2020) (based on LUBW (2006)).

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(5.0)
>>> fluxes.tempssurface = -4.0
>>> aides.temps = -2.0
>>> from hydpy import round_
>>> round_(model.return_wsurf_v1(0))
10.0

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

Bases: 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(300.0, 200.0))
100.0

class hydpy.models.lland.lland_model.Calc_NetRadiation_V1

Bases: Method

Calculate the total net radiation.

Required submethod:

Return_NetRadiation_V1

Requires the control parameter:

NHRU

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)
>>> fluxes.netshortwaveradiation = 300.0
>>> fluxes.dailynetlongwaveradiation = 200.0
>>> model.calc_netradiation_v1()
>>> fluxes.netradiation
netradiation(100.0)

class hydpy.models.lland.lland_model.Calc_DailyNetRadiation_V1

Bases: 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 = 300.0
>>> fluxes.dailynetlongwaveradiation = 200.0
>>> model.calc_dailynetradiation_v1()
>>> fluxes.dailynetradiation
dailynetradiation(100.0)

class hydpy.models.lland.lland_model.Return_EnergyGainSnowSurface_V1

Bases: Method

Calculate and return the net energy gain of the snow surface (:cite:t`ref-LARSIM` based on LUBW (2006), 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 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(2.0)
>>> turb1(2.0)
>>> ktschnee(5.0)
>>> derived.days.update()
>>> inputs.relativehumidity = 60.0
>>> states.waes = 1.0
>>> fluxes.tkor = -3.0
>>> fluxes.reducedwindspeed2m = 3.0
>>> fluxes.actualvapourpressure = 2.9
>>> fluxes.netshortwaveradiationsnow = 20.0
>>> derived.nmblogentries.update()
>>> aides.temps = -2.0
>>> aides.rlatm = 200.0

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))
-82.62933

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

>>> fluxes.saturationvapourpressuresnow
saturationvapourpressuresnow(4.539126)
>>> fluxes.netlongwaveradiationsnow
netlongwaveradiationsnow(97.550439)
>>> fluxes.netradiationsnow
netradiationsnow(-77.550439)
>>> fluxes.wsenssnow
wsenssnow(-8.0)
>>> fluxes.wlatsnow
wlatsnow(23.078891)
>>> fluxes.wsurf
wsurf(10.0)

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

Bases: Method

Determine and return the snow surface temperature (LEG (2020) based on LUBW (2006), 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 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(2.0)
>>> turb1(2.0)
>>> ktschnee(5.0)
>>> 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 = 2.9
>>> fluxes.netshortwaveradiationsnow = 10.0, 10.0, 20.0, 20.0, 20.0, 200.0
>>> aides.temps = nan, -2.0, -2.0, -50.0, -200.0, -2.0
>>> aides.rlatm = 200.0
>>> 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.307868, -7.828995

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.828995, -20.191197, -66.644357

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, 137.892846, 127.892846, -495.403823, -1835.208545, -52.107154)
>>> 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

Bases: 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 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 LEG (2020).

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(2.0)
>>> turb1(2.0)
>>> 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 = 2.9
>>> fluxes.netshortwaveradiationinz = 20.0
>>> fluxes.dailysunshineduration = 10.0
>>> fluxes.dailypossiblesunshineduration = 12.0
>>> aides.tempsinz = -6.675053
>>> aides.rlatm = 200.0

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

>>> fluxes.saturationvapourpressureinz
saturationvapourpressureinz(4.893489)
>>> fluxes.netlongwaveradiationinz
netlongwaveradiationinz(42.94817)
>>> fluxes.netradiationinz
netradiationinz(-22.94817)
>>> fluxes.wsensinz
wsensinz(-29.400424)
>>> fluxes.wlatinz
wlatinz(28.068322)
>>> fluxes.wsurfinz
wsurfinz(21.616068)

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

Bases: 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 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(2.0)
>>> turb1(2.0)
>>> 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 = 2.9
>>> fluxes.netshortwaveradiationinz = 20.0
>>> states.esnowinz = -1.0
>>> fluxes.dailysunshineduration = 10.0
>>> fluxes.dailypossiblesunshineduration = 12.0
>>> aides.rlatm = 200.0

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

>>> aides.tempsinz
tempsinz(-6.675053)
>>> fluxes.saturationvapourpressureinz
saturationvapourpressureinz(4.893489)
>>> fluxes.netlongwaveradiationinz
netlongwaveradiationinz(42.94817)
>>> fluxes.netradiationinz
netradiationinz(-22.94817)
>>> fluxes.wsensinz
wsensinz(-29.400424)
>>> fluxes.wlatinz
wlatinz(28.068322)
>>> fluxes.wsurfinz
wsurfinz(21.616068)

>>> states.esnowinz
esnowinz(-1.0)

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

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

Bases: Method

Calculate and return the “Backward Euler error” regarding the update of ESnow due to the energy fluxes WG and WSurf (LEG (2020) based on LUBW (2006), 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 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(2.0)
>>> turb1(2.0)
>>> 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 = 2.9
>>> fluxes.netshortwaveradiationsnow = 20.0
>>> states.esnow = -1.0
>>> fluxes.tz = 0.0
>>> aides.rlatm = 200.0

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

>>> ktschnee(inf)
>>> from hydpy import round_
>>> model.idx_hru = 0
>>> round_(model.return_backwardeulererror_v1(-2.3582799))
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.96038)
>>> fluxes.tempssurface
tempssurface(-6.96038)
>>> fluxes.saturationvapourpressuresnow
saturationvapourpressuresnow(3.619445)
>>> fluxes.netlongwaveradiationsnow
netlongwaveradiationsnow(84.673816)
>>> fluxes.netradiationsnow
netradiationsnow(-64.673816)
>>> fluxes.wsenssnow
wsenssnow(-31.683041)
>>> fluxes.wlatsnow
wlatsnow(10.129785)
>>> fluxes.wsurf
wsurf(43.120561)
>>> fluxes.wg
wg(41.762281)

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(-1.0)

In the above example, KTSchnee is set to inf, which is why TempSSurface is identical with TempS. After setting the common value of 5 W/m²/K, 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 -2.36 Wd/m² is not correct anymore:

>>> ktschnee(5.0)
>>> round_(model.return_backwardeulererror_v1(-2.3582799))
32.808687
>>> aides.temps
temps(-6.96038)
>>> fluxes.tempssurface
tempssurface(-9.022755)
>>> fluxes.saturationvapourpressuresnow
saturationvapourpressuresnow(3.080429)
>>> fluxes.netlongwaveradiationsnow
netlongwaveradiationsnow(75.953474)
>>> fluxes.netradiationsnow
netradiationsnow(-55.953474)
>>> fluxes.wsenssnow
wsenssnow(-48.182039)
>>> fluxes.wlatsnow
wlatsnow(2.540439)
>>> fluxes.wsurf
wsurf(10.311874)
>>> fluxes.wg
wg(41.762281)
>>> states.esnow
esnow(-1.0)

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(-2.3582799))
nan
>>> fluxes.wsurf
wsurf(10.311874)

class hydpy.models.lland.lland_model.Update_ESnowInz_V1

Bases: 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 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(2.0)
>>> turb1(2.0)
>>> 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 = 2.9
>>> fluxes.netshortwaveradiationinz = 20.0
>>> states.esnowinz = -1.0
>>> aides.rlatm = 200.0

>>> model.update_esnowinz_v1()
>>> states.esnowinz
esnowinz(0.0, -22.616068, -2.514108, -0.300877, -0.030179, -0.003019,
         0.0, 0.0)
>>> aides.tempsinz
tempsinz(nan, -6.675053, -8.661041, -8.880269, -8.907091, -8.909782,
         -8.910081, -8.910081)

>>> esnowinz = states.esnowinz.values.copy()
>>> states.esnowinz = -1.0
>>> 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

Bases: 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). LEG (2020) based on LUBW (2006), 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 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(2.0)
>>> turb1(2.0)
>>> 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 = 2.9
>>> fluxes.netshortwaveradiationsnow = 20.0
>>> states.esnow = -1.0
>>> fluxes.tz = 0.0
>>> aides.rlatm = 200.0

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, -20.789871, -2.024799, -0.239061, -0.023939, -0.002394, 0.0,
      0.0)
>>> aides.temps
temps(nan, -6.136057, -6.975386, -7.055793, -7.065486, -7.066457,
      -7.066565, -7.066565)
>>> fluxes.tempssurface
tempssurface(nan, -6.136057, -6.975386, -7.055793, -7.065486, -7.066457,
             -7.066565, -7.066565)

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 = -1.0
>>> 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(5.0)
>>> model.update_esnow_v1()
>>> states.esnow
esnow(0.0, -9.695862, -1.085682, -0.130026, -0.013043, -0.001305, 0.0,
      0.0)
>>> aides.temps
temps(nan, -2.861699, -3.740149, -3.837669, -3.849607, -3.850805,
      -3.850938, -3.850938)
>>> fluxes.tempssurface
tempssurface(nan, -8.034911, -8.245463, -8.268877, -8.271743, -8.272031,
             -8.272063, -8.272063)

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

>>> esnow = states.esnow.values.copy()
>>> states.esnow = -1.0
>>> 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

Bases: 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 *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nhru(2)
>>> fluxes.wgtf = 20.0
>>> fluxes.wnied = 10.0, 20.0
>>> model.calc_schmpot_v1()
>>> fluxes.schmpot
schmpot(3.88024, 5.173653)

class hydpy.models.lland.lland_model.Calc_SchmPot_V2

Bases: 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 *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nhru(4)
>>> states.waes = 0.0, 1.0, 1.0, 1.0
>>> states.esnow = nan, 100.0, 50.0, -50.0
>>> model.calc_schmpot_v2()
>>> fluxes.schmpot
schmpot(0.0, 12.934132, 6.467066, 0.0)

class hydpy.models.lland.lland_model.Calc_GefrPot_V1

Bases: 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 *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nhru(4)
>>> states.waes = 0.0, 1.0, 1.0, 1.0
>>> states.esnow = nan, -100.0, -50.0, 50.0
>>> model.calc_gefrpot_v1()
>>> fluxes.gefrpot
gefrpot(0.0, 12.934132, 6.467066, 0.0)

class hydpy.models.lland.lland_model.Calc_Schm_WATS_V1

Bases: 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

Bases: 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

Bases: 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

Bases: 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 *
>>> simulationstep("12h")
>>> 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 = 20.0, 20.0, 20.0, 20.0, -40.0, 30.925926, 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, -9.074074, 0.0, 0.0)

class hydpy.models.lland.lland_model.Calc_SFF_V1

Bases: Method

Calculate the ratio between frozen water and total water within the top soil layer according to LEG (2020).

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 *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nhru(9)
>>> lnk(VERS, WASSER, FLUSS, SEE, ACKER, ACKER, ACKER, ACKER, ACKER)
>>> states.ebdn(0.0, 0.0, 0.0, 0.0, 620.0, 618.519, 309.259, 0.0, -1.0)
>>> model.calc_sff_v1()
>>> fluxes.sff
sff(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 1.0, 1.0)

class hydpy.models.lland.lland_model.Calc_FVG_V1

Bases: Method

Calculate the degree of frost sealing of the soil according to LEG (2020).

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

Bases: 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 (DVWK, 2002). 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

Bases: Method

Calculate the pressure of the dry air (based on DWD (1987)).

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 = 9.0, 11.0, 25.0
>>> inputs.atmosphericpressure = 1200.0
>>> model.calc_dryairpressure_v1()
>>> fluxes.dryairpressure
dryairpressure(1191.0, 1189.0, 1175.0)

class hydpy.models.lland.lland_model.Calc_DensityAir_V1

Bases: Method

Calculate the density of the air (based on DWD (1987)).

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{100 \cdot DryAirPressure}{RDryAir \cdot (TKor + 273.15)} + \frac{100 \cdot ActualVapourPressure}{RWaterVapour \cdot (TKor + 273.15)}\)

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(3)
>>> fluxes.dryairpressure = 1191.0, 1000.0, 1150.0
>>> fluxes.actualvapourpressure = 8.0, 7.0, 10.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

Bases: Method

Calculate the aerodynamic resistance according to LEG (2020) (based on Thompson et al. (1981)).

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

Bases: Method

Calculate the surface resistance of the bare soil surface according to LEG (2020) (based on Thompson et al. (1981)).

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

Bases: Method

Calculate the surface resistance of vegetation, water and sealed areas according to LEG (2020) (based on Thompson et al. (1981)).

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 20) \\ min\left(\frac{25 \cdot SurfaceResistance}{(TKor + 5) \cdot (1 - \Delta / 20)}, 10\,000\right) &|\ Lnk = NADELW \;\; \land \;\; (-5 < TKor < 20 \;\; \land \;\; \Delta < 20) \\ min\left(\frac{SurfaceResistance}{1 - \Delta / 20}, 10\,000\right) &|\ Lnk = NADELW \;\; \land \;\; (20 \leq TKor \;\; \land \;\; \Delta < 20) \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 20 hPa:

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

>>> fluxes.actualvapourpressure = 10.0, 10.1, 11.0, 12.0
>>> model.calc_landusesurfaceresistance_v1()
>>> fluxes.landusesurfaceresistance
landusesurfaceresistance(12214.027582, 12214.027582, 1954.244413,
                         977.122207)

>>> fluxes.actualvapourpressure = 20.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

Bases: Method

Calculate the total surface resistance according to LEG (2020) (based on Grant (1975)).

Requires the control parameters:

NHRU Lnk LAI

Requires the derived parameters:

MOY Hours

Requires the input sequence:

PossibleSunshineDuration

Requires the flux sequences:

SoilSurfaceResistance LanduseSurfaceResistance

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:

>>> inputs.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:

>>> inputs.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:

>>> inputs.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
>>> inputs.possiblesunshineduration = 1.0
>>> model.calc_actualsurfaceresistance_v1()
>>> fluxes.actualsurfaceresistance
actualsurfaceresistance(109.174477)

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

>>> inputs.possiblesunshineduration = 0.5
>>> model.calc_actualsurfaceresistance_v1()
>>> fluxes.actualsurfaceresistance
actualsurfaceresistance(123.765057)

class hydpy.models.lland.lland_model.Return_Penman_V1

Bases: Method

Calculate and return the evaporation from water surfaces according to Penman according to LEG (2020) (based on DVWK (1996)).

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:

\(\frac{DailySaturationVapourPressureSlope \cdot DailyNetRadiation/ LW + Days \cdot Psy \cdot (0.13 + 0.094 \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, 50.0, 100.0, 0.0, 0.0, 0.0, 100.0
>>> fluxes.dailywindspeed2m = 2.0
>>> fluxes.dailysaturationvapourpressure = 12.0
>>> fluxes.dailysaturationvapourpressureslope = 0.8
>>> fluxes.dailyactualvapourpressure = 12.0, 12.0, 12.0, 12.0, 6.0, 0.0, 0.0
>>> from hydpy import print_values
>>> for hru in range(7):
...     deficit = (fluxes.dailysaturationvapourpressure[hru] -
...                fluxes.dailyactualvapourpressure[hru])
...     evap = model.return_penman_v1(hru)
...     print_values([fluxes.dailynetradiation[hru], deficit, evap])
0.0, 0.0, 0.0
50.0, 0.0, 0.964611
100.0, 0.0, 1.929222
0.0, 0.0, 0.0
0.0, 6.0, 0.858928
0.0, 12.0, 1.717856
100.0, 12.0, 3.647077

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()
>>> fixed.lw.restore()
>>> for hru in range(7):
...     deficit = (fluxes.dailysaturationvapourpressure[hru] -
...                fluxes.dailyactualvapourpressure[hru])
...     evap = model.return_penman_v1(hru)
...     print_values([fluxes.dailynetradiation[hru], deficit, 24 * evap])
0.0, 0.0, 0.0
50.0, 0.0, 0.964611
100.0, 0.0, 1.929222
0.0, 0.0, 0.0
0.0, 6.0, 0.858928
0.0, 12.0, 1.717856
100.0, 12.0, 3.647077

class hydpy.models.lland.lland_model.Return_PenmanMonteith_V1

Bases: Method

Calculate and return the evapotranspiration according to Penman-Monteith according to LEG (2020) (based on Thompson et al. (1981)).

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 Sigma / Seconds \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 = 10.0, 50.0, 100.0, 10.0, 10.0, 10.0, 100.0
>>> fluxes.g = -10.0
>>> fluxes.saturationvapourpressure = 12.0
>>> fluxes.saturationvapourpressureslope = 0.8
>>> fluxes.actualvapourpressure = 12.0, 12.0, 12.0, 12.0, 6.0, 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])
...     evap = model.return_penmanmonteith_v1(
...         hru, fluxes.actualsurfaceresistance[hru])
...     print_values([fluxes.netradiation[hru]+fluxes.g[hru], deficit, evap])
0.0, 0.0, 0.0
40.0, 0.0, 0.648881
90.0, 0.0, 1.459982
0.0, 0.0, 0.0
0.0, 6.0, 2.031724
0.0, 12.0, 4.063447
90.0, 12.0, 5.523429

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])
...     evap = model.return_penmanmonteith_v1(
...         hru, fluxes.actualsurfaceresistance[hru])
...     print_values([fluxes.netradiation[hru]+fluxes.g[hru], deficit, evap])
0.0, 0.0, 0.0
40.0, 0.0, 0.364933
90.0, 0.0, 0.8211
0.0, 0.0, 0.0
0.0, 6.0, 2.469986
0.0, 12.0, 4.939972
90.0, 12.0, 5.761072

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 = 100.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.370311
20.0, 9.144449
50.0, 7.068767
100.0, 5.128562
200.0, 3.31099
500.0, 1.604779
1000.0, 0.863312

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 = 6.0
>>> 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.006739
1.0, 4.918573
1000.0, 0.887816
1000000.0, 0.001372
inf, 0.001372

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()
>>> fixed.lw.restore()
>>> fixed.cpluft.restore()
>>> fluxes.netradiation = 10.0, 50.0, 100.0, 10.0, 10.0, 10.0, 100.0
>>> fluxes.actualvapourpressure = 12.0, 12.0, 12.0, 12.0, 6.0, 0.0, 0.0
>>> fluxes.actualsurfaceresistance = 0.0
>>> fluxes.aerodynamicresistance = 106.0
>>> for hru in range(7):
...     deficit = (fluxes.saturationvapourpressure[hru] -
...                fluxes.actualvapourpressure[hru])
...     evap = 24 * model.return_penmanmonteith_v1(
...         hru, fluxes.actualsurfaceresistance[hru])
...     print_values([fluxes.netradiation[hru]+fluxes.g[hru], deficit, evap])
0.0, 0.0, 0.0
40.0, 0.0, 0.648881
90.0, 0.0, 1.459982
0.0, 0.0, 0.0
0.0, 6.0, 2.031724
0.0, 12.0, 4.063447
90.0, 12.0, 5.523429

class hydpy.models.lland.lland_model.Calc_EvPo_V2

Bases: 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 = 90.0
>>> fluxes.dailynetradiation = 80.0
>>> fluxes.g = -10.0
>>> fluxes.saturationvapourpressure = 12.0
>>> fluxes.dailysaturationvapourpressure = 12.0
>>> fluxes.saturationvapourpressureslope = 0.8
>>> fluxes.dailysaturationvapourpressureslope = 0.8
>>> fluxes.actualvapourpressure = 0.0
>>> fluxes.dailyactualvapourpressure = 0.0
>>> fluxes.windspeed2m = 2.0
>>> fluxes.dailywindspeed2m = 2.0
>>> fluxes.tkor = 10.0
>>> fluxes.densityair = 1.24
>>> fluxes.aerodynamicresistance = 106.0
>>> model.calc_evpo_v2()
>>> fluxes.evpo
evpo(3.261233, 5.361209)

class hydpy.models.lland.lland_model.Calc_EvS_WAeS_WATS_V1

Bases: 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 *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nhru(8)
>>> lnk(ACKER, ACKER, ACKER, ACKER, ACKER, ACKER, ACKER, WASSER)
>>> fluxes.wlatsnow = -25.0, 0.0, 50.0, 90.0, 150.0, 150.0, 150.0, 150.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.404881, 0.0, 0.809762, 1.457572, 2.0, 1.5, 0.0, 0.0)
>>> states.waes
waes(2.404881, 2.0, 1.190238, 0.542428, 0.0, 0.0, 0.0, 0.0)
>>> states.wats
wats(1.202441, 1.0, 0.595119, 0.271214, 0.0, 0.0, 0.0, 0.0)

class hydpy.models.lland.lland_model.Calc_EvI_Inzp_V1

Bases: 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

Bases: 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

Bases: 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

Bases: 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 = 100.0, 100.0, 100.0, 100.0, 100.0, -300.0
>>> fluxes.g = -11.574074074074
>>> fluxes.saturationvapourpressure = 12.0
>>> fluxes.saturationvapourpressureslope = 0.8
>>> 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.497895, 3.665263, 1.832632, 0.0, -0.495458)

class hydpy.models.lland.lland_model.Calc_QKap_V1

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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 according to LEG (2020).

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

Bases: 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 according to LEG (2020).

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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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

Bases: 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: Model)

Bases: 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: Model)

Bases: 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: Model)

Bases: 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: SubParameters)

Bases: ZipParameter

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'

Name of the variable in lower case letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.lland.lland_parameters.ParameterLand(subvars: SubParameters)

Bases: ParameterComplete

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'

Name of the variable in lower case letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.lland.lland_parameters.ParameterSoil(subvars: SubParameters)

Bases: ParameterComplete

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'

Name of the variable in lower case letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.lland.lland_parameters.ParameterSoilThreshold(subvars: SubParameters)

Bases: ParameterSoil

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'

Name of the variable in lower case letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.lland.lland_parameters.LanduseMonthParameter(subvars: SubParameters)

Bases: KeywordParameter2D

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'

Name of the variable in lower case letters.

unit: str = '?'

Unit of the variable.

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: Parameters, cls_fastaccess: Type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)

Bases: SubParameters

Control parameters of model lland.

The following classes are selected:

• 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) [-].

• 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) [W/m²/K].

• Turb1() Parameter des Übergangskoeffizienten des turbulenten Wärmestroms (parameter of transition coefficient for turbulent heat flux) [J/m³/K].

• 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) [W/m²/K].

• WG2Z() Bodenwärmestrom in der Tiefe 2z (soil heat flux at depth 2z) [W/m²].

• 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.FT(subvars: SubParameters)

Bases: Parameter

Teileinzugsgebietsfläche (subbasin area) [km²].

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (1e-10, None)

name: str = 'ft'

Name of the variable in lower case letters.

unit: str = 'km²'

Unit of the variable.

class hydpy.models.lland.lland_control.NHRU(subvars: SubParameters)

Bases: Parameter

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,)
>>> control.kapgrenz.shape
(5, 2)
>>> fluxes.tkor.shape
(5,)
>>> logs.wet0.shape
(1, 5)
>>> control.wg2z.shape
(12,)

NDIM: int = 0

TYPE

alias of int

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (1, None)

name: str = 'nhru'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.Lnk(subvars: SubParameters)

Bases: NameParameter

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

alias of int

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (1, 18)

CONSTANTS: 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'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.FHRU(subvars: SubParameters)

Bases: ParameterComplete

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)

name: str = 'fhru'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.HNN(subvars: SubParameters)

Bases: ParameterComplete

Höhe über Normal-Null (height above sea level) [m].

Required by the method:

Calc_ET0_V1

NDIM: int = 1

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (None, None)

name: str = 'hnn'

Name of the variable in lower case letters.

unit: str = 'm'

Unit of the variable.

class hydpy.models.lland.lland_control.KG(subvars: SubParameters)

Bases: ParameterComplete

Niederschlagskorrekturfaktor (adjustment factor for precipitation) [-].

Required by the method:

Calc_NKor_V1

NDIM: int = 1

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 1.0

name: str = 'kg'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.KT(subvars: SubParameters)

Bases: ParameterComplete

Temperaturkorrektursummand (adjustment summand for air temperature) [°C].

Required by the methods:

Calc_TKorTag_V1 Calc_TKor_V1

NDIM: int = 1

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (None, None)

INIT: int | float | bool | None = 0.0

name: str = 'kt'

Name of the variable in lower case letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.lland.lland_control.KE(subvars: SubParameters)

Bases: ParameterComplete

Grasreferenzverdunstungskorrekturfaktor (adjustment factor for reference evapotranspiration) [-].

Required by the methods:

Calc_ET0_V1 Calc_ET0_WET0_V1

NDIM: int = 1

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 1.0

name: str = 'ke'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.P1Strahl(subvars: SubParameters)

Bases: Parameter

Konstante der Globalstrahlungsreduktion für Wald (constant for reducing the global radiation in forests) [-].

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)

INIT: int | float | bool | None = 0.5

name: str = 'p1strahl'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.P2Strahl(subvars: SubParameters)

Bases: Parameter

Faktor der Globalstrahlungsreduktion für Wald (factor for reducing the global radiation in forests) [-].

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)

INIT: int | float | bool | None = 0.02857142857142857

name: str = 'p2strahl'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.Albedo(subvars: SubParameters)

Bases: LanduseMonthParameter

Albedo [-].

Required by the method:

Calc_ActualAlbedo_V1

NDIM: int = 2

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)

INIT: int | float | bool | None = 0.0

name: str = 'albedo'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.Albedo0Snow(subvars: SubParameters)

Bases: Parameter

Albedo von Neuschnee (albedo of fresh snow) [-].

Required by the methods:

Calc_ActualAlbedoInz_V1 Calc_ActualAlbedo_V1

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)

INIT: int | float | bool | None = 0.8

name: str = 'albedo0snow'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.SnowAgingFactor(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)

INIT: int | float | bool | None = 0.35

name: str = 'snowagingfactor'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.Turb0(subvars: SubParameters)

Bases: Parameter

Parameter des Übergangskoeffizienten des turbulenten Wärmestroms (parameter of transition coefficient for turbulent heat flux) [W/m²/K].

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 2.0

name: str = 'turb0'

Name of the variable in lower case letters.

unit: str = 'W/m²/K'

Unit of the variable.

class hydpy.models.lland.lland_control.Turb1(subvars: SubParameters)

Bases: Parameter

Parameter des Übergangskoeffizienten des turbulenten Wärmestroms (parameter of transition coefficient for turbulent heat flux) [J/m³/K].

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 2.0

name: str = 'turb1'

Name of the variable in lower case letters.

unit: str = 'J/m³/K'

Unit of the variable.

class hydpy.models.lland.lland_control.Emissivity(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)

INIT: int | float | bool | None = 0.95

name: str = 'emissivity'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.MeasuringHeightWindSpeed(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0, None)

INIT: int | float | bool | None = 10.0

name: str = 'measuringheightwindspeed'

Name of the variable in lower case letters.

unit: str = 'm'

Unit of the variable.

class hydpy.models.lland.lland_control.P1Wind(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)

INIT: int | float | bool | None = 0.6

name: str = 'p1wind'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.P2Wind(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)

INIT: int | float | bool | None = 0.014285714285714285

name: str = 'p2wind'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.LAI(subvars: SubParameters)

Bases: LanduseMonthParameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 5.0

name: str = 'lai'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.HInz(subvars: SubParameters)

Bases: Parameter

Interzeptionskapazität bezogen auf die Blattoberfläche (interception capacity normalized to the leaf surface area) [mm].

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.2

name: str = 'hinz'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_control.P1SIMax(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 8.0

name: str = 'p1simax'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_control.P2SIMax(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 1.5

name: str = 'p2simax'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_control.P1SIRate(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)

INIT: int | float | bool | None = 0.2

name: str = 'p1sirate'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.P2SIRate(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)

INIT: int | float | bool | None = 0.02

name: str = 'p2sirate'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.P3SIRate(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, 0.05)

INIT: int | float | bool | None = 0.003

name: str = 'p3sirate'

Name of the variable in lower case letters.

unit: str = '1/mm'

Unit of the variable.

class hydpy.models.lland.lland_control.TRefT(subvars: SubParameters)

Bases: ParameterLand

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (None, None)

INIT: int | float | bool | None = 0.0

name: str = 'treft'

Name of the variable in lower case letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.lland.lland_control.TRefN(subvars: SubParameters)

Bases: ParameterLand

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (None, None)

INIT: int | float | bool | None = 0.0

name: str = 'trefn'

Name of the variable in lower case letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.lland.lland_control.TGr(subvars: SubParameters)

Bases: ParameterLand

Temperaturgrenzwert flüssiger/fester Niederschlag (threshold temperature liquid/frozen precipitation) [°C].

Required by the method:

Calc_SNRatio_V1

NDIM: int = 1

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (None, None)

INIT: int | float | bool | None = 0.0

name: str = 'tgr'

Name of the variable in lower case letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.lland.lland_control.TSp(subvars: SubParameters)

Bases: ParameterLand

Temperaturspanne flüssiger/fester Niederschlag (temperature range with mixed precipitation) [°C].

Required by the method:

Calc_SNRatio_V1

NDIM: int = 1

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.0

name: str = 'tsp'

Name of the variable in lower case letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.lland.lland_control.GTF(subvars: SubParameters)

Bases: ParameterLand

Grad-Tag-Faktor (factor of the degree-day method) [mm/°C/T].

Required by the method:

Calc_WGTF_V1

NDIM: int = 1

TYPE

alias of float

TIME: bool | None = True

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 3.0

name: str = 'gtf'

Name of the variable in lower case letters.

unit: str = 'mm/°C/T'

Unit of the variable.

class hydpy.models.lland.lland_control.PWMax(subvars: SubParameters)

Bases: ParameterLand

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (1.0, None)

INIT: int | float | bool | None = 1.4278333871488538

name: str = 'pwmax'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.RefreezeFlag(subvars: SubParameters)

Bases: Parameter

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

alias of int

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (False, True)

INIT: int | float | bool | None = 0

name: str = 'refreezeflag'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.KTSchnee(subvars: SubParameters)

Bases: Parameter

Effektive Wärmeleitfähigkeit der obersten Schneeschicht (effective thermal conductivity of the top snow layer) [W/m²/K].

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, inf)

INIT: int | float | bool | None = 5.0

name: str = 'ktschnee'

Name of the variable in lower case letters.

unit: str = 'W/m²/K'

Unit of the variable.

class hydpy.models.lland.lland_control.WG2Z(subvars: SubParameters)

Bases: MonthParameter

Bodenwärmestrom in der Tiefe 2z (soil heat flux at depth 2z) [W/m²].

Required by the methods:

Calc_G_V1 Calc_G_V2 Update_EBdn_V1

NDIM: int = 1

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (None, None)

INIT: int | float | bool | None = 0.0

name: str = 'wg2z'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_control.KF(subvars: SubParameters)

Bases: ParameterComplete

Küstenfaktor (“coast factor” of Turc-Wendling’s evaporation equation [-].

Required by the method:

Calc_ET0_V1

NDIM: int = 1

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.6, 1.0)

INIT: int | float | bool | None = 1.0

name: str = 'kf'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.WfET0(subvars: SubParameters)

Bases: ParameterComplete

Zeitlicher Wichtungsfaktor der Grasreferenzverdunsung (temporal weighting factor for reference evapotranspiration).

Required by the method:

Calc_ET0_WET0_V1

NDIM: int = 1

TYPE

alias of float

TIME: bool | None = True

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)

name: str = 'wfet0'

Name of the variable in lower case letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.lland.lland_control.FLn(subvars: SubParameters)

Bases: LanduseMonthParameter

Landnutzungsabhängiger Verdunstungsfaktor (factor for adjusting reference evapotranspiration to different land use classes) [-].

Required by the method:

Calc_EvPo_V1

NDIM: int = 2

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 1.0

name: str = 'fln'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.GrasRef_R(subvars: SubParameters)

Bases: Parameter

Bodenfeuchte-Verdunstung-Parameter (soil moisture-dependent evaporation factor) [-].

Required by the method:

Calc_EvB_V1

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 5.0

name: str = 'grasref_r'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.CropHeight(subvars: SubParameters)

Bases: LanduseMonthParameter

Crop height [m].

Required by the method:

Calc_AerodynamicResistance_V1

NDIM: int = 2

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.0

name: str = 'cropheight'

Name of the variable in lower case letters.

unit: str = 'm'

Unit of the variable.

class hydpy.models.lland.lland_control.SurfaceResistance(subvars: SubParameters)

Bases: LanduseMonthParameter

Surface Resistance [s/m].

Required by the method:

Calc_LanduseSurfaceResistance_V1

NDIM: int = 2

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.0

name: str = 'surfaceresistance'

Name of the variable in lower case letters.

unit: str = 's/m'

Unit of the variable.

class hydpy.models.lland.lland_control.WMax(subvars: SubParameters)

Bases: ParameterSoil

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 100.0

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_control.FK(subvars: SubParameters)

Bases: ParameterSoilThreshold

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.0

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_control.PWP(subvars: SubParameters)

Bases: ParameterSoilThreshold

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.0

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_control.PY(subvars: SubParameters)

Bases: ParameterSoilThreshold

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.0

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_control.BSf(subvars: SubParameters)

Bases: ParameterSoil

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.4

name: str = 'bsf'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.FVF(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.5

name: str = 'fvf'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.BSFF(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 2.0

name: str = 'bsff'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.DMin(subvars: SubParameters)

Bases: ParameterSoil

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

alias of float

TIME: bool | None = True

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.0

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_control.DMax(subvars: SubParameters)

Bases: ParameterSoil

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

alias of float

TIME: bool | None = True

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (None, None)

INIT: int | float | bool | None = 1.0

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_control.Beta(subvars: SubParameters)

Bases: ParameterSoil

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

alias of float

TIME: bool | None = True

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.01

name: str = 'beta'

Name of the variable in lower case letters.

unit: str = '1/T'

Unit of the variable.

class hydpy.models.lland.lland_control.FBeta(subvars: SubParameters)

Bases: ParameterSoil

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (1.0, None)

INIT: int | float | bool | None = 1.0

name: str = 'fbeta'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.KapMax(subvars: SubParameters)

Bases: ParameterSoil

Maximale kapillare Aufstiegsrate (maximum capillary rise) [mm/T].

Required by the method:

Calc_QKap_V1

NDIM: int = 1

TYPE

alias of float

TIME: bool | None = True

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.0

name: str = 'kapmax'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_control.KapGrenz(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (None, None)

INIT: int | float | bool | None = 0.0

name: str = 'kapgrenz'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_control.RBeta(subvars: SubParameters)

Bases: Parameter

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

alias of bool

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (False, True)

INIT: int | float | bool | None = False

name: str = 'rbeta'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.VolBMax(subvars: SubParameters)

Bases: Parameter

Maximaler Inhalt des Gebietsspeichers für Basisabfluss (maximum value of the storage compartment for base flow) [mm].

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = inf

name: str = 'volbmax'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_control.GSBMax(subvars: SubParameters)

Bases: Parameter

Faktor zur Anpassung von VolBMax (factor for adjusting VolBMax) [-].

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 1.0

name: str = 'gsbmax'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.GSBGrad1(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = True

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (None, None)

INIT: int | float | bool | None = inf

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_control.GSBGrad2(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = True

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (None, None)

INIT: int | float | bool | None = inf

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_control.A1(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = True

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = inf

name: str = 'a1'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_control.A2(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = True

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.0

name: str = 'a2'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_control.TInd(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 1.0

name: str = 'tind'

Name of the variable in lower case letters.

unit: str = 'T'

Unit of the variable.

class hydpy.models.lland.lland_control.EQB(subvars: SubParameters)

Bases: Parameter

Kalibrierfaktor für die Basisabflusskonzentration (factor for adjusting the concentration time of baseflow). [-].

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 5000.0

name: str = 'eqb'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.EQI1(subvars: SubParameters)

Bases: Parameter

Kalibrierfaktor für die “untere” Zwischenabflusskonzentration (factor for adjusting the concentration time of the first interflow component) [-].

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 2000.0

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.EQI2(subvars: SubParameters)

Bases: Parameter

Kalibrierfaktor für die “obere” Zwischenabflusskonzentration (factor for adjusting the concentration time of the second interflow component) [-].

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 1000.0

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.EQD1(subvars: SubParameters)

Bases: Parameter

Kalibrierfaktor für die langsamere Direktabflusskonzentration (factor for adjusting the concentration time of the slower component of direct runoff). [-].

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 100.0

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.EQD2(subvars: SubParameters)

Bases: Parameter

Kalibrierfaktor für die schnellere Direktabflusskonzentration (factor for adjusting the concentration time of the faster component of direct runoff). [-].

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 50.0

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_control.NegQ(subvars: SubParameters)

Bases: Parameter

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

alias of bool

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = False

name: str = 'negq'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

Derived parameters

class hydpy.models.lland.DerivedParameters(master: Parameters, cls_fastaccess: Type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)

Bases: SubParameters

Derived parameters of model lland.

The following classes are selected:

• MOY() References the “global” month 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].

• NmbLogEntries() The number of log entries required for a memory duration of 24 hours [-].

• 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 [WT].

• Fr() Reduktionsfaktor für Strahlung according to LEG (2020) (basierend auf LUWG (2015)) (reduction factor for short- and long wave radiation) LEG (2020) (based on LUWG (2015)) [-].

• 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/T to m³/s.

class hydpy.models.lland.lland_derived.MOY(subvars: SubParameters)

Bases: MOYParameter

References the “global” month of the year index array [-].

Required by the methods:

Calc_ActualAlbedo_V1 Calc_ActualSurfaceResistance_V1 Calc_AerodynamicResistance_V1 Calc_EvPo_V1 Calc_G_V1 Calc_G_V2 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_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'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_derived.Seconds(subvars: SubParameters)

Bases: SecondsParameter

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'

Name of the variable in lower case letters.

unit: str = 's'

Unit of the variable.

class hydpy.models.lland.lland_derived.Hours(subvars: SubParameters)

Bases: HoursParameter

The length of the actual simulation step size in hours [h].

Required by the methods:

Calc_ActualSurfaceResistance_V1 Calc_G_V1

name: str = 'hours'

Name of the variable in lower case letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.lland.lland_derived.Days(subvars: SubParameters)

Bases: DaysParameter

The length of the actual simulation step size in days [d].

Required by the methods:

Calc_EvPo_V2 Return_Penman_V1

name: str = 'days'

Name of the variable in lower case letters.

unit: str = 'd'

Unit of the variable.

class hydpy.models.lland.lland_derived.NmbLogEntries(subvars: SubParameters)

Bases: Parameter

The number of log entries required for a memory duration of 24 hours [-].

Required by the methods:

Calc_DailyGlobalRadiation_V1 Calc_DailyPossibleSunshineDuration_V1 Calc_DailyRelativeHumidity_V1 Calc_DailySunshineDuration_V1 Calc_DailyWindSpeed2m_V1 Calc_TemLTag_V1 Update_LoggedGlobalRadiation_V1 Update_LoggedPossibleSunshineDuration_V1 Update_LoggedRelativeHumidity_V1 Update_LoggedSunshineDuration_V1 Update_LoggedTemL_V1 Update_LoggedWindSpeed2m_V1

NDIM: int = 0

TYPE

alias of int

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (1, None)

update()

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
>>> 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)
loggedpossiblesunshineduration(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'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_derived.AbsFHRU(subvars: SubParameters)

Bases: ParameterComplete

Flächen der Hydrotope (areas of the respective HRUs) [km²].

NDIM: int = 1

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

update()

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'

Name of the variable in lower case letters.

unit: str = 'km²'

Unit of the variable.

class hydpy.models.lland.lland_derived.KInz(subvars: SubParameters)

Bases: LanduseMonthParameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

update()

Update KInz based on HInz and LAI according to LEG (2020) (based on Dickinson (1984)).

>>> 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'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_derived.HeatOfFusion(subvars: SubParameters)

Bases: ParameterLand

Heat which is necessary to melt the frozen soil water content [WT].

Required by the method:

Calc_TZ_V1

NDIM: int = 1

TYPE

alias of float

TIME: bool | None = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

update()

Update HeatOfFusion based on RSchmelz and BoWa2Z.

Basic equation:

\(HeatOfFusion = RSchmelz \cdot BoWa2Z\)

>>> from hydpy.models.lland import *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nhru(2)
>>> lnk(ACKER, LAUBW)
>>> derived.heatoffusion.update()
>>> derived.heatoffusion
heatoffusion(309.259259)
>>> from hydpy import round_
>>> round_(derived.heatoffusion.values)
618.518519, 618.518519

name: str = 'heatoffusion'

Name of the variable in lower case letters.

unit: str = 'WT'

Unit of the variable.

class hydpy.models.lland.lland_derived.Fr(subvars: SubParameters)

Bases: LanduseMonthParameter

Reduktionsfaktor für Strahlung according to LEG (2020) (basierend auf LUWG (2015)) (reduction factor for short- and long wave radiation) LEG (2020) (based on LUWG (2015)) [-].

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

update()

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'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_derived.NFk(subvars: SubParameters)

Bases: ParameterSoil

Nutzbare Feldkapazität (usable field capacity) [mm].

Required by the method:

Calc_SoilSurfaceResistance_V1

NDIM: int = 1

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

update()

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'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_derived.KB(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

update()

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'

Name of the variable in lower case letters.

unit: str = 'T'

Unit of the variable.

class hydpy.models.lland.lland_derived.KI1(subvars: SubParameters)

Bases: Parameter

Konzentrationszeit des “unteren” Zwischenabflusses (concentration time of the first interflow component) [T].

Required by the method:

Calc_QIGA1_V1

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

update()

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'

Name of the variable in lower case letters.

unit: str = 'T'

Unit of the variable.

class hydpy.models.lland.lland_derived.KI2(subvars: SubParameters)

Bases: Parameter

Konzentrationszeit des “oberen” Zwischenabflusses” (concentration time of the second interflow component) [T].

Required by the method:

Calc_QIGA2_V1

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

update()

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'

Name of the variable in lower case letters.

unit: str = 'T'

Unit of the variable.

class hydpy.models.lland.lland_derived.KD1(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

update()

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'

Name of the variable in lower case letters.

unit: str = 'T'

Unit of the variable.

class hydpy.models.lland.lland_derived.KD2(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

update()

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'

Name of the variable in lower case letters.

unit: str = 'T'

Unit of the variable.

class hydpy.models.lland.lland_derived.QBGAMax(subvars: SubParameters)

Bases: Parameter

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

alias of float

TIME: bool | None = True

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

update()

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_derived.QFactor(subvars: SubParameters)

Bases: Parameter

Factor for converting mm/T to m³/s.

Required by the methods:

Calc_QA_V1 Calc_QZH_V1

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

update()

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'

Name of the variable in lower case letters.

unit: str = '?'

Unit of the variable.

Fixed parameters

class hydpy.models.lland.FixedParameters(master: Parameters, cls_fastaccess: Type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)

Bases: SubParameters

Fixed parameters of model lland.

The following classes are selected:

• CPWasser() Spezifische Wärmekapazität von Wasser (specific heat capacity of water) [WT/kg/K].

• CPEis() Spezifische Wärmekapazität von Eis bei 0 °C (specific heat capacity of ice at a temperature of 0 °C) [WT/kg/K].

• RSchmelz() Spezifische Schmelzwärme von Wasser (specific melt heat of water) [WT/kg].

• 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) [W/m/K].

• Sigma() Stefan-Boltzmann-Konstante (Stefan-Boltzmann constant) [W/m²/K].

• RDryAir() Gaskonstante für trockene Luft (gas constant for dry air) [J/kg/K].

• RWaterVapour() Gaskonstante für Wasserdampf (gas constant for water vapour) [J/kg/K].

• LW() Latente Verdunstungswärme bei 15°C (heat of condensation at at temperature of 15°C) [WT/kg)].

• LWE() Mittlere latente Verdunstungswärme für Wasser und Eis (average heat of condensation for water and ice) [WT/kg].

• CPLuft() Spezifische Wärmekapazität Luft (heat of condensation for a water temperature of 15°C) [WT/kg/K].

• Psy() Psychrometerkonstante bei Normaldruck (psychrometric constant at normal pressure) [hPa/K].

• PsyInv() Kehrwert der Psychrometerkonstante über Schnee und Eis bei 0°C (inverse psychrometric constant for ice and snow at 0°C) [K/hPa].

• Z0() Rauhigkeitslänge für Wiese (roughness length for short grass) [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) [WT/m³/K].

class hydpy.models.lland.lland_fixed.CPWasser(subvars: SubParameters)

Bases: FixedParameter

Spezifische Wärmekapazität von Wasser (specific heat capacity of water) [WT/kg/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

alias of float

TIME: bool | None = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.04845833333333333

name: str = 'cpwasser'

Name of the variable in lower case letters.

unit: str = 'WT/kg/K'

Unit of the variable.

class hydpy.models.lland.lland_fixed.CPEis(subvars: SubParameters)

Bases: FixedParameter

Spezifische Wärmekapazität von Eis bei 0 °C (specific heat capacity of ice at a temperature of 0 °C) [WT/kg/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

alias of float

TIME: bool | None = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.024189814814814813

name: str = 'cpeis'

Name of the variable in lower case letters.

unit: str = 'WT/kg/K'

Unit of the variable.

class hydpy.models.lland.lland_fixed.RSchmelz(subvars: SubParameters)

Bases: FixedParameter

Spezifische Schmelzwärme von Wasser (specific melt heat of water) [WT/kg].

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

alias of float

TIME: bool | None = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 3.865740740740741

name: str = 'rschmelz'

Name of the variable in lower case letters.

unit: str = 'WT/kg'

Unit of the variable.

class hydpy.models.lland.lland_fixed.Pi(subvars: SubParameters)

Bases: FixedParameter

π [-].

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 3.141592653589793

name: str = 'pi'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_fixed.Z(subvars: SubParameters)

Bases: FixedParameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.1

name: str = 'z'

Name of the variable in lower case letters.

unit: str = 'm'

Unit of the variable.

class hydpy.models.lland.lland_fixed.BoWa2Z(subvars: SubParameters)

Bases: FixedParameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0, None)

INIT: int | float | bool | None = 80.0

name: str = 'bowa2z'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_fixed.LambdaG(subvars: SubParameters)

Bases: FixedParameter

Wärmeleitfähigkeit des Bodens (thermal conductivity of the top soil layer) [W/m/K].

Required by the methods:

Calc_WG_V1 Return_BackwardEulerError_V1 Return_WG_V1 Update_ESnow_V1

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.6

name: str = 'lambdag'

Name of the variable in lower case letters.

unit: str = 'W/m/K'

Unit of the variable.

class hydpy.models.lland.lland_fixed.Sigma(subvars: SubParameters)

Bases: FixedParameter

Stefan-Boltzmann-Konstante (Stefan-Boltzmann constant) [W/m²/K].

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 5.67e-08

name: str = 'sigma'

Name of the variable in lower case letters.

unit: str = 'W/m²/K'

Unit of the variable.

class hydpy.models.lland.lland_fixed.RDryAir(subvars: SubParameters)

Bases: FixedParameter

Gaskonstante für trockene Luft (gas constant for dry air) [J/kg/K].

Required by the method:

Calc_DensityAir_V1

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 287.058

name: str = 'rdryair'

Name of the variable in lower case letters.

unit: str = 'J/kg/K'

Unit of the variable.

class hydpy.models.lland.lland_fixed.RWaterVapour(subvars: SubParameters)

Bases: FixedParameter

Gaskonstante für Wasserdampf (gas constant for water vapour) [J/kg/K].

Required by the method:

Calc_DensityAir_V1

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 461.495

name: str = 'rwatervapour'

Name of the variable in lower case letters.

unit: str = 'J/kg/K'

Unit of the variable.

class hydpy.models.lland.lland_fixed.LW(subvars: SubParameters)

Bases: FixedParameter

Latente Verdunstungswärme bei 15°C (heat of condensation at at temperature of 15°C) [WT/kg)].

Required by the methods:

Calc_EvB_V2 Calc_EvPo_V2 Return_PenmanMonteith_V1 Return_Penman_V1

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 28.5

name: str = 'lw'

Name of the variable in lower case letters.

unit: str = 'WT/kg)'

Unit of the variable.

class hydpy.models.lland.lland_fixed.LWE(subvars: SubParameters)

Bases: FixedParameter

Mittlere latente Verdunstungswärme für Wasser und Eis (average heat of condensation for water and ice) [WT/kg].

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/60/60/24)
28.944444
>>> round_((2834.1-0.29*t-0.004*t**2)*1000/60/60/24)
32.802083

… and use their average as the default value for parameter LWE:

>>> round_((28.944444+32.802083)/2)
30.873264
>>> from hydpy.models.lland.lland_fixed import LWE
>>> round_(LWE.INIT)
30.873264

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 30.87326388888889

name: str = 'lwe'

Name of the variable in lower case letters.

unit: str = 'WT/kg'

Unit of the variable.

class hydpy.models.lland.lland_fixed.CPLuft(subvars: SubParameters)

Bases: FixedParameter

Spezifische Wärmekapazität Luft (heat of condensation for a water temperature of 15°C) [WT/kg/K].

Required by the methods:

Calc_EvB_V2 Calc_EvPo_V2 Return_PenmanMonteith_V1

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.011631944444444445

name: str = 'cpluft'

Name of the variable in lower case letters.

unit: str = 'WT/kg/K'

Unit of the variable.

class hydpy.models.lland.lland_fixed.Psy(subvars: SubParameters)

Bases: FixedParameter

Psychrometerkonstante bei Normaldruck (psychrometric constant at normal pressure) [hPa/K].

Required by the methods:

Calc_EvB_V2 Calc_EvPo_V2 Return_PenmanMonteith_V1 Return_Penman_V1

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.655

name: str = 'psy'

Name of the variable in lower case letters.

unit: str = 'hPa/K'

Unit of the variable.

class hydpy.models.lland.lland_fixed.PsyInv(subvars: SubParameters)

Bases: FixedParameter

Kehrwert der Psychrometerkonstante über Schnee und Eis bei 0°C (inverse psychrometric constant for ice and snow at 0°C) [K/hPa].

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 1.76

name: str = 'psyinv'

Name of the variable in lower case letters.

unit: str = 'K/hPa'

Unit of the variable.

class hydpy.models.lland.lland_fixed.Z0(subvars: SubParameters)

Bases: FixedParameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 0.003

name: str = 'z0'

Name of the variable in lower case letters.

unit: str = 'm'

Unit of the variable.

class hydpy.models.lland.lland_fixed.FrAtm(subvars: SubParameters)

Bases: FixedParameter

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

alias of float

TIME: bool | None = None

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

INIT: int | float | bool | None = 1.28

name: str = 'fratm'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_fixed.CG(subvars: SubParameters)

Bases: FixedParameter

Volumetrische Wärmekapazität des Bodens (volumetric heat capacity of soil) [WT/m³/K].

Required by the method:

Calc_TZ_V1

NDIM: int = 0

TYPE

alias of float

TIME: bool | None = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (None, None)

INIT: int | float | bool | None = 17.36111111111111

name: str = 'cg'

Name of the variable in lower case letters.

unit: str = 'WT/m³/K'

Unit of the variable.

Sequence Features

Sequence tools

class hydpy.models.lland.lland_sequences.Flux1DSequence(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: FluxSequence

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

property refweights

Alias for the associated instance of AbsFHRU for calculating areal values.

name: str = 'flux1dsequence'

Name of the variable in lower case letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.lland.lland_sequences.State1DSequence(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

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

property refweights

Alias for the associated instance of AbsFHRU for calculating areal values.

name: str = 'state1dsequence'

Name of the variable in lower case letters.

unit: str = '?'

Unit of the variable.

Input sequences

class hydpy.models.lland.InputSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: InputSequences

Input sequences of model lland.

The following classes are selected:

• Nied() Niederschlag (precipitation) [mm/T].

• TemL() Lufttemperatur (air temperature) [°C].

• SunshineDuration() Sonnenscheindauer (sunshine duration) [h].

• PossibleSunshineDuration() Astronomisch mögliche Sonnenscheindauer (astronomically possible sunshine duration) [h].

• GlobalRadiation() Globalstrahlung (global radiation) [W/m²].

• RelativeHumidity() Relative humidity [%].

• WindSpeed() Windgeschwindigkeit (wind speed) [m/s].

• PET() Potenzielle Verdunstung (potential evapotranspiration) [mm/T].

• AtmosphericPressure() Luftdruck (atmospheric pressure) [hPa].

class hydpy.models.lland.lland_inputs.Nied(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: InputSequence

Niederschlag (precipitation) [mm/T].

Required by the method:

Calc_NKor_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'nied'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_inputs.TemL(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: InputSequence

Lufttemperatur (air temperature) [°C].

Required by the methods:

Calc_TKor_V1 Update_LoggedTemL_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'teml'

Name of the variable in lower case letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.lland.lland_inputs.SunshineDuration(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: InputSequence

Sonnenscheindauer (sunshine duration) [h].

Required by the method:

Update_LoggedSunshineDuration_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'sunshineduration'

Name of the variable in lower case letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.lland.lland_inputs.PossibleSunshineDuration(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: InputSequence

Astronomisch mögliche Sonnenscheindauer (astronomically possible sunshine duration) [h].

Required by the methods:

Calc_ActualSurfaceResistance_V1 Calc_G_V1 Update_LoggedPossibleSunshineDuration_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'possiblesunshineduration'

Name of the variable in lower case letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.lland.lland_inputs.GlobalRadiation(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: InputSequence

Globalstrahlung (global radiation) [W/m²].

Required by the methods:

Calc_ET0_V1 Calc_NetShortwaveRadiationInz_V1 Calc_NetShortwaveRadiationSnow_V1 Calc_NetShortwaveRadiation_V1 Update_LoggedGlobalRadiation_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'globalradiation'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_inputs.RelativeHumidity(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: InputSequence

Relative humidity [%].

Required by the methods:

Calc_ActualVapourPressure_V1 Update_LoggedRelativeHumidity_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'relativehumidity'

Name of the variable in lower case letters.

unit: str = '%'

Unit of the variable.

class hydpy.models.lland.lland_inputs.WindSpeed(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: InputSequence

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'

Name of the variable in lower case letters.

unit: str = 'm/s'

Unit of the variable.

class hydpy.models.lland.lland_inputs.PET(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: InputSequence

Potenzielle Verdunstung (potential evapotranspiration) [mm/T].

Required by the method:

Calc_ET0_WET0_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'pet'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_inputs.AtmosphericPressure(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: InputSequence

Luftdruck (atmospheric pressure) [hPa].

Required by the method:

Calc_DryAirPressure_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'atmosphericpressure'

Name of the variable in lower case letters.

unit: str = 'hPa'

Unit of the variable.

Flux sequences

class hydpy.models.lland.FluxSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: FluxSequences

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/T].

• TemLTag() Tageswert der Lufttemperatur (daily air temperature) [°C].

• DailyRelativeHumidity() Daily relative humidity [%].

• DailySunshineDuration() Daily sunshine duration [h].

• DailyPossibleSunshineDuration() Astronomically possible daily sunshine duration [h].

• DailyGlobalRadiation() Daily global radiation [h].

• NKor() Korrigierter Niederschlag (corrected precipitation) [mm/T].

• 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 [hPa].

• DailySaturationVapourPressure() Daily satuarion vapour pressure [hPa].

• SaturationVapourPressureInz() Sättigungsdampdruck unmittelbar oberhalb der Oberfläche des interzepierten Schnees (saturation vapour pressure directly above the surface of the intercepted snow) [hPa].

• SaturationVapourPressureSnow() Saturation vapour pressure snow [hPa].

• SaturationVapourPressureSlope() The slope of the saturation vapour pressure curve [hPa/K].

• DailySaturationVapourPressureSlope() Daily satuarion vapour pressure [hPa/K].

• ActualVapourPressure() Actual vapour pressure [hPa].

• DailyActualVapourPressure() Daily actual vapour pressure [hPa].

• DryAirPressure() Dry air pressure [hPa].

• DensityAir() Air density [kg/m³]

• G() “MORECS” Bodenwärmestrom (“MORECS” soil heat flux) [W/m²].

• TZ() Bodentemperatur in der Tiefe z (soil temperature at depth z) [°C].

• WG() “Dynamischer” Bodenwärmestrom (“dynamic” soil heat flux) [W/m²].

• NetShortwaveRadiation() Netto kurzwellige Strahlungsbilanz (net shortwave radiation) [W/m²].

• NetShortwaveRadiationInz() Kurzwellige Netto-Strahlungsbilanz für den interzipierten Schnee (net shortwave radiation for intercepted snow) [W/m²].

• NetShortwaveRadiationSnow() Kurzwellige Netto-Strahlungsbilanz für Schneeoberflächen (net shortwave radiation for snow surfaces) [W/m²].

• DailyNetShortwaveRadiation() Daily not shortwave radiation [W/m²].

• DailyNetLongwaveRadiation() Daily net longwave radiation [W/m²].

• NetLongwaveRadiationInz() Langwellige Nettostrahlung des interzepierten Schnees (net longwave radiation of the intercepted snow [W/m²].

• NetLongwaveRadiationSnow() Net longwave radiation for snow-surfaces [W/m²].

• NetRadiation() Total net radiation [W/m²].

• NetRadiationInz() Nettostrahlung des interzepierten Schnees (total net radiation of the intercepted snow [W/m²].

• NetRadiationSnow() Total net radiation for snow-surfaces [W/m²].

• DailyNetRadiation() Daily net radiation [W/m²].

• 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/T].

• SBes() Schneeanteil Bestandsniederschlag (frozen stand precipitation) [mm/T].

• 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/T].

• SBesInz() Gefrorener Bestandsniederschlag, der den Schneeinterzeptionsspeicher erreicht (frozen amount of stand precipitation reaching the snow interception storage) [mm/T].

• WNiedInz() Niederschlagsbedingter Wärmestrom in den Schneeinterzeptionsspeicher (heat flux into the snow interception storage due to precipitation) [W/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/T].

• SchmPotInz() Potentielle Schmelze des interzepierten Schnees (potential amount of snow melting within the snow interception storage) [mm/T].

• SchmInz() Tatsächliche Schmelze des interzepierten Schnees (actual amount of snow melting within the snow cover) [mm/T].

• GefrPotInz() Potentielles Wiedergefrieren des interzipierten Schnees (potential amount of water refreezing within the snow interception storage) [mm/T].

• GefrInz() Tatsächliche Wiedergefrieren des interzipierten Schnees (actual amount of water refreezing within the snow interception storage) [mm/T].

• EvSInz() Tatsächliche Verdunstung des interzepierten Schnees (actual evaporation of the intercepted snow) [mm/T].

• ET0() Grasreferenzverdunstung (reference evapotranspiration) [mm/T].

• EvPo() Evapotranspiration (evapotranspiration) [mm/T].

• EvI() Tatsächliche Interzeptionsverdunstung (actual evaporation of intercepted water) [mm/T].

• EvB() Tatsächliche Verdunstung von Bodenwasser (actual evaporation of soil water) [mm/T].

• EvS() Tatsächliche Schneeverdunstung (actual evaporation of snow-water) [mm/T].

• WGTF() Mit dem Grad-Tag-Verfahren berechneter Wärmeestrom in die Schneedecke (heat flux into the snow layer calculated with the degree-day method) [W/m²].

• WNied() Niederschlagsbedingter Wärmestrom in die Schneedecke (heat flux into the snow layer due to precipitation) [W/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/T].

• Schm() Tatsächliche Schneeschmelze (actual amount of water melting within the snow cover) [mm/T].

• GefrPot() Potentielles Schnee-Wiedergefrieren (potential amount of water refreezing within the snow cover) [mm/T].

• Gefr() Tatsächliche Schnee-Wiedergefrieren (actual amount of water refreezing within the snow cover) [mm/T].

• WLatInz() Latente Wärmestrom interzepierter Schnee/Atmosphäre (latent heat flux between the intercepted snow and the atmosphere) [W/m²].

• WLatSnow() Latente Wärmestrom Schnee/Atmosphäre (latent heat flux between the snow-layer and the atmosphere) [W/m²].

• WSensInz() Fühlbare Wärmestrom interzipierter Schnee/Atmosphäre (sensible heat flux between the intercepted snow and the atmosphere) [W/m²].

• WSensSnow() Fühlbare Wärmestrom Schnee/Atmosphäre (sensible heat flux between the snow-layer and the atmosphere) [W/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) [W/m²].

• WSurf() Wärmestrom von der Schneedecke zur Schneeoberfläche (heat flux from the snow layer to the snow surface) [W/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/T].

• QDB() Direktabfluss-Abgabe aus dem Bodenspeicher (direct runoff release from the soil storage) [mm/T].

• QIB1() Erste Komponente der Interflow-Abgabe aus dem Bodenspeicher (first component of the interflow release from the soil storage) [mm/T].

• QIB2() Zweite Komponente der Interflow-Abgabe aus dem Bodenspeicher (second component of the interflow release from the soil storage) [mm/T].

• QBB() Basisabfluss-Abgabe aus dem Bodenspeicher (base flow release from the soil storage) [mm/T].

• QKap() Kapillarer Aufstieg in den Bodenspeicher (capillary rise to soil storage) [mm/T].

• QDGZ() Gesamtzufluss in beide Direktabfluss-Gebietsspeicher (total inflow into both storage compartments for direct runoff) [mm/T].

• QAH() Abflussspende des Teilgebiets (runoff at the catchment outlet) [mm/T].

• QA() Abfluss des Teilgebiets (runoff at the catchment outlet) [m³/s].

class hydpy.models.lland.lland_fluxes.QZ(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: FluxSequence

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'

Name of the variable in lower case letters.

unit: str = 'm³/s'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.QZH(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: FluxSequence

Abflussspende in das Teilgebiet (inflow into the subcatchment) [mm/T].

Calculated by the method:

Calc_QZH_V1

Required by the method:

Calc_QAH_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'qzh'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.TemLTag(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: FluxSequence

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'

Name of the variable in lower case letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.DailyRelativeHumidity(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: FluxSequence

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'

Name of the variable in lower case letters.

unit: str = '%'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.DailySunshineDuration(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: FluxSequence

Daily sunshine duration [h].

Updated by the method:

Calc_DailySunshineDuration_V1

Required by the methods:

Calc_DailyNetLongwaveRadiation_V1 Calc_RLAtm_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'dailysunshineduration'

Name of the variable in lower case letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.DailyPossibleSunshineDuration(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: FluxSequence

Astronomically possible daily sunshine duration [h].

Updated by the method:

Calc_DailyPossibleSunshineDuration_V1

Required by the methods:

Calc_DailyNetLongwaveRadiation_V1 Calc_G_V1 Calc_RLAtm_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'dailypossiblesunshineduration'

Name of the variable in lower case letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.DailyGlobalRadiation(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: FluxSequence

Daily global radiation [h].

Updated by the method:

Calc_DailyGlobalRadiation_V1

Required by the method:

Calc_DailyNetShortwaveRadiation_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'dailyglobalradiation'

Name of the variable in lower case letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.NKor(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Korrigierter Niederschlag (corrected precipitation) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.TKor(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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'

Name of the variable in lower case letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.TKorTag(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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'

Name of the variable in lower case letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.WindSpeed2m(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: FluxSequence

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'

Name of the variable in lower case letters.

unit: str = 'm/s'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.DailyWindSpeed2m(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: FluxSequence

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'

Name of the variable in lower case letters.

unit: str = 'm/s'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.ReducedWindSpeed2m(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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'

Name of the variable in lower case letters.

unit: str = 'm/s'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.WindSpeed10m(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: FluxSequence

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'

Name of the variable in lower case letters.

unit: str = 'm/s'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.SaturationVapourPressure(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Saturation vapour pressure [hPa].

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'

Name of the variable in lower case letters.

unit: str = 'hPa'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.DailySaturationVapourPressure(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Daily satuarion vapour pressure [hPa].

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'

Name of the variable in lower case letters.

unit: str = 'hPa'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.SaturationVapourPressureInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Sättigungsdampdruck unmittelbar oberhalb der Oberfläche des interzepierten Schnees (saturation vapour pressure directly above the surface of the intercepted snow) [hPa].

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'

Name of the variable in lower case letters.

unit: str = 'hPa'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.SaturationVapourPressureSnow(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Saturation vapour pressure snow [hPa].

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'

Name of the variable in lower case letters.

unit: str = 'hPa'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.SaturationVapourPressureSlope(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

The slope of the saturation vapour pressure curve [hPa/K].

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'

Name of the variable in lower case letters.

unit: str = 'hPa/K'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.DailySaturationVapourPressureSlope(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Daily satuarion vapour pressure [hPa/K].

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'

Name of the variable in lower case letters.

unit: str = 'hPa/K'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.ActualVapourPressure(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Actual vapour pressure [hPa].

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'

Name of the variable in lower case letters.

unit: str = 'hPa'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.DailyActualVapourPressure(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Daily actual vapour pressure [hPa].

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'

Name of the variable in lower case letters.

unit: str = 'hPa'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.DryAirPressure(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Dry air pressure [hPa].

Calculated by the method:

Calc_DryAirPressure_V1

Required by the method:

Calc_DensityAir_V1

NDIM: int = 1

NUMERIC: bool = False

mask

name: str = 'dryairpressure'

Name of the variable in lower case letters.

unit: str = 'hPa'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.DensityAir(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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'

Name of the variable in lower case letters.

unit: str = 'kg/m³'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.G(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

“MORECS” Bodenwärmestrom (“MORECS” soil heat flux) [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.TZ(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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'

Name of the variable in lower case letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.WG(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

“Dynamischer” Bodenwärmestrom (“dynamic” soil heat flux) [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.NetShortwaveRadiation(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Netto kurzwellige Strahlungsbilanz (net shortwave radiation) [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.NetShortwaveRadiationInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Kurzwellige Netto-Strahlungsbilanz für den interzipierten Schnee (net shortwave radiation for intercepted snow) [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.NetShortwaveRadiationSnow(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Kurzwellige Netto-Strahlungsbilanz für Schneeoberflächen (net shortwave radiation for snow surfaces) [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.DailyNetShortwaveRadiation(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Daily not shortwave radiation [W/m²].

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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.DailyNetLongwaveRadiation(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Daily net longwave radiation [W/m²].

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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.NetLongwaveRadiationInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Langwellige Nettostrahlung des interzepierten Schnees (net longwave radiation of the intercepted snow [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.NetLongwaveRadiationSnow(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Net longwave radiation for snow-surfaces [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.NetRadiation(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Total net radiation [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.NetRadiationInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Nettostrahlung des interzepierten Schnees (total net radiation of the intercepted snow [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.NetRadiationSnow(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Total net radiation for snow-surfaces [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.DailyNetRadiation(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Daily net radiation [W/m²].

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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.AerodynamicResistance(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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[int | float | bool | None, int | float | bool | None] = (0.0, None)

mask

name: str = 'aerodynamicresistance'

Name of the variable in lower case letters.

unit: str = 's/m'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.SoilSurfaceResistance(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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[int | float | bool | None, int | float | bool | None] = (0.0, None)

mask

name: str = 'soilsurfaceresistance'

Name of the variable in lower case letters.

unit: str = 's/m'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.LanduseSurfaceResistance(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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[int | float | bool | None, int | float | bool | None] = (0.0, None)

mask

name: str = 'landusesurfaceresistance'

Name of the variable in lower case letters.

unit: str = 's/m'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.ActualSurfaceResistance(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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[int | float | bool | None, int | float | bool | None] = (0.0, None)

mask

name: str = 'actualsurfaceresistance'

Name of the variable in lower case letters.

unit: str = 's/m'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.NBes(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Gesamter Bestandsniederschlag (total stand precipitation) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.SBes(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Schneeanteil Bestandsniederschlag (frozen stand precipitation) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.SnowIntMax(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.SnowIntRate(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.NBesInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Gesamter Bestandsniederschlag, der den Schneeinterzeptionsspeicher erreicht (total stand precipitation reaching the snow interception storage) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.SBesInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Gefrorener Bestandsniederschlag, der den Schneeinterzeptionsspeicher erreicht (frozen amount of stand precipitation reaching the snow interception storage) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.WNiedInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Niederschlagsbedingter Wärmestrom in den Schneeinterzeptionsspeicher (heat flux into the snow interception storage due to precipitation) [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.ActualAlbedoInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.WaDaInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Wasserdargebot des Schneeinterzeptionsspeichers (water leaving the snow interception storage) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.SchmPotInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Potentielle Schmelze des interzepierten Schnees (potential amount of snow melting within the snow interception storage) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.SchmInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Tatsächliche Schmelze des interzepierten Schnees (actual amount of snow melting within the snow cover) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.GefrPotInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Potentielles Wiedergefrieren des interzipierten Schnees (potential amount of water refreezing within the snow interception storage) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.GefrInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Tatsächliche Wiedergefrieren des interzipierten Schnees (actual amount of water refreezing within the snow interception storage) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.EvSInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Tatsächliche Verdunstung des interzepierten Schnees (actual evaporation of the intercepted snow) [mm/T].

Calculated by the method:

Calc_EvSInz_SInz_STInz_V1

NDIM: int = 1

NUMERIC: bool = False

mask

name: str = 'evsinz'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.ET0(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Grasreferenzverdunstung (reference evapotranspiration) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.EvPo(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Evapotranspiration (evapotranspiration) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.EvI(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Tatsächliche Interzeptionsverdunstung (actual evaporation of intercepted water) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.EvB(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Tatsächliche Verdunstung von Bodenwasser (actual evaporation of soil water) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.EvS(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Tatsächliche Schneeverdunstung (actual evaporation of snow-water) [mm/T].

Calculated by the method:

Calc_EvS_WAeS_WATS_V1

NDIM: int = 1

NUMERIC: bool = False

mask

name: str = 'evs'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.WGTF(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Mit dem Grad-Tag-Verfahren berechneter Wärmeestrom in die Schneedecke (heat flux into the snow layer calculated with the degree-day method) [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.WNied(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Niederschlagsbedingter Wärmestrom in die Schneedecke (heat flux into the snow layer due to precipitation) [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.TempSSurface(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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'

Name of the variable in lower case letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.ActualAlbedo(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.SchmPot(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Potentielle Schneeschmelze (potential amount of water melting within the snow cover) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.Schm(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Tatsächliche Schneeschmelze (actual amount of water melting within the snow cover) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.GefrPot(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Potentielles Schnee-Wiedergefrieren (potential amount of water refreezing within the snow cover) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.Gefr(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Tatsächliche Schnee-Wiedergefrieren (actual amount of water refreezing within the snow cover) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.WLatInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Latente Wärmestrom interzepierter Schnee/Atmosphäre (latent heat flux between the intercepted snow and the atmosphere) [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.WLatSnow(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Latente Wärmestrom Schnee/Atmosphäre (latent heat flux between the snow-layer and the atmosphere) [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.WSensInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Fühlbare Wärmestrom interzipierter Schnee/Atmosphäre (sensible heat flux between the intercepted snow and the atmosphere) [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.WSensSnow(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Fühlbare Wärmestrom Schnee/Atmosphäre (sensible heat flux between the snow-layer and the atmosphere) [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.WSurfInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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) [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.WSurf(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Wärmestrom von der Schneedecke zur Schneeoberfläche (heat flux from the snow layer to the snow surface) [W/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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.SFF(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.FVG(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

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'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.WaDa(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Wasserdargebot (water reaching the soil routine) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.QDB(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Direktabfluss-Abgabe aus dem Bodenspeicher (direct runoff release from the soil storage) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.QIB1(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Erste Komponente der Interflow-Abgabe aus dem Bodenspeicher (first component of the interflow release from the soil storage) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.QIB2(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Zweite Komponente der Interflow-Abgabe aus dem Bodenspeicher (second component of the interflow release from the soil storage) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.QBB(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Basisabfluss-Abgabe aus dem Bodenspeicher (base flow release from the soil storage) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.QKap(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: Flux1DSequence

Kapillarer Aufstieg in den Bodenspeicher (capillary rise to soil storage) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.QDGZ(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: FluxSequence

Gesamtzufluss in beide Direktabfluss-Gebietsspeicher (total inflow into both storage compartments for direct runoff) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.QAH(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: FluxSequence

Abflussspende des Teilgebiets (runoff at the catchment outlet) [mm/T].

Calculated by the method:

Calc_QAH_V1

Required by the method:

Calc_QA_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'qah'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_fluxes.QA(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: FluxSequence

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'

Name of the variable in lower case letters.

unit: str = 'm³/s'

Unit of the variable.

State sequences

class hydpy.models.lland.StateSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: StateSequences

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 [WT/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) [WT/m²].

• TauS() Dimensionsloses Alter der Schneedecke (dimensionless age of the snow layer) [-].

• EBdn() Energiegehalt des Bodenwassers (energy content of the soil water) [WT/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/T].

• QDGZ2() Zufluss in den dynamischeren Direktabfluss-Gebietsspeicher (inflow into the more responsive storage compartment for direct runoff) [mm/T].

• QIGZ1() “Zufluss in den ersten Zwischenabfluss-Gebietsspeicher (inflow into the first storage compartment for interflow) [mm/T].

• QIGZ2() Zufluss in den zweiten Zwischenabfluss-Gebietsspeicher (inflow into the second storage compartment for interflow) [mm/T].

• QBGZ() Zufluss in den Basisabfluss-Gebietsspeicher (inflow into the storage compartment for base flow) [mm/T].

• QDGA1() Abfluss aus dem trägeren Direktabfluss-Gebietsspeicher (outflow from the less responsive storage compartment for direct runoff) [mm/T].

• QDGA2() Abfluss aus dem dynamischeren Direktabfluss-Gebietsspeicher (outflow from the more responsive storage compartment for direct runoff) [mm/T].

• QIGA1() Abfluss aus dem “unteren” Zwischenabfluss-Gebietsspeicher (outflow from the storage compartment for the first interflow component) [mm/T].

• QIGA2() Abfluss aus dem “oberen” Zwischenabfluss-Gebietsspeicher (outflow from the storage compartment for the second interflow component) [mm/T].

• QBGA() Abfluss aus dem Basisabfluss-Gebietsspeicher (outflow from the storage compartment for base flow) [mm/T].

class hydpy.models.lland.lland_states.Inzp(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: State1DSequence

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[int | float | bool | None, int | float | bool | None] = (0.0, None)

mask

name: str = 'inzp'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_states.STInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: State1DSequence

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[int | float | bool | None, int | float | bool | None] = (0.0, None)

mask

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_states.SInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: State1DSequence

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[int | float | bool | None, int | float | bool | None] = (0.0, None)

mask

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_states.ESnowInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: State1DSequence

Kälteinhalt der Schneedecke des Interzeptionsspeichers [WT/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[int | float | bool | None, int | float | bool | None] = (None, None)

mask

name: str = 'esnowinz'

Name of the variable in lower case letters.

unit: str = 'WT/m²'

Unit of the variable.

class hydpy.models.lland.lland_states.ASInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: State1DSequence

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[int | float | bool | None, int | float | bool | None] = (0.0, None)

mask

name: str = 'asinz'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_states.WATS(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: State1DSequence

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[int | float | bool | None, int | float | bool | None] = (0.0, None)

mask

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_states.WAeS(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: State1DSequence

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[int | float | bool | None, int | float | bool | None] = (0.0, None)

mask

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_states.ESnow(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: State1DSequence

Thermischer Energieinhalt der Schneedecke bezogen auf 0°C (thermal energy content of the snow layer with respect to 0°C) [WT/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[int | float | bool | None, int | float | bool | None] = (None, None)

mask

name: str = 'esnow'

Name of the variable in lower case letters.

unit: str = 'WT/m²'

Unit of the variable.

class hydpy.models.lland.lland_states.TauS(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: State1DSequence

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[int | float | bool | None, int | float | bool | None] = (0.0, None)

mask

name: str = 'taus'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_states.EBdn(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: State1DSequence

Energiegehalt des Bodenwassers (energy content of the soil water) [WT/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[int | float | bool | None, int | float | bool | None] = (None, None)

mask

name: str = 'ebdn'

Name of the variable in lower case letters.

unit: str = 'WT/m²'

Unit of the variable.

class hydpy.models.lland.lland_states.BoWa(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: State1DSequence

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[int | float | bool | None, int | float | bool | None] = (0.0, None)

mask

trim(lower=None, upper=None)

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'

Name of the variable in lower case letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_states.QDGZ1(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

Zufluss in den trägeren Direktabfluss-Gebietsspeicher (inflow into the less responsive storage compartment for direct runoff) [mm/T].

Calculated by the method:

Calc_QDGZ1_QDGZ2_V1

Required by the method:

Calc_QDGA1_V1

NDIM: int = 0

NUMERIC: bool = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (None, None)

name: str = 'qdgz1'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_states.QDGZ2(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

Zufluss in den dynamischeren Direktabfluss-Gebietsspeicher (inflow into the more responsive storage compartment for direct runoff) [mm/T].

Calculated by the method:

Calc_QDGZ1_QDGZ2_V1

Required by the method:

Calc_QDGA2_V1

NDIM: int = 0

NUMERIC: bool = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (None, None)

name: str = 'qdgz2'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_states.QIGZ1(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

“Zufluss in den ersten Zwischenabfluss-Gebietsspeicher (inflow into the first storage compartment for interflow) [mm/T].

Calculated by the method:

Calc_QIGZ1_V1

Required by the method:

Calc_QIGA1_V1

NDIM: int = 0

NUMERIC: bool = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

name: str = 'qigz1'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_states.QIGZ2(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

Zufluss in den zweiten Zwischenabfluss-Gebietsspeicher (inflow into the second storage compartment for interflow) [mm/T].

Calculated by the method:

Calc_QIGZ2_V1

Required by the method:

Calc_QIGA2_V1

NDIM: int = 0

NUMERIC: bool = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

name: str = 'qigz2'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_states.QBGZ(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

Zufluss in den Basisabfluss-Gebietsspeicher (inflow into the storage compartment for base flow) [mm/T].

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[int | float | bool | None, int | float | bool | None] = (None, None)

name: str = 'qbgz'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_states.QDGA1(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

Abfluss aus dem trägeren Direktabfluss-Gebietsspeicher (outflow from the less responsive storage compartment for direct runoff) [mm/T].

Updated by the method:

Calc_QDGA1_V1

Required by the method:

Calc_QAH_V1

NDIM: int = 0

NUMERIC: bool = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (None, None)

name: str = 'qdga1'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_states.QDGA2(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

Abfluss aus dem dynamischeren Direktabfluss-Gebietsspeicher (outflow from the more responsive storage compartment for direct runoff) [mm/T].

Updated by the method:

Calc_QDGA2_V1

Required by the method:

Calc_QAH_V1

NDIM: int = 0

NUMERIC: bool = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (None, None)

name: str = 'qdga2'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_states.QIGA1(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

Abfluss aus dem “unteren” Zwischenabfluss-Gebietsspeicher (outflow from the storage compartment for the first interflow component) [mm/T].

Updated by the method:

Calc_QIGA1_V1

Required by the method:

Calc_QAH_V1

NDIM: int = 0

NUMERIC: bool = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

name: str = 'qiga1'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_states.QIGA2(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

Abfluss aus dem “oberen” Zwischenabfluss-Gebietsspeicher (outflow from the storage compartment for the second interflow component) [mm/T].

Updated by the method:

Calc_QIGA2_V1

Required by the method:

Calc_QAH_V1

NDIM: int = 0

NUMERIC: bool = False

SPAN: Tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)

name: str = 'qiga2'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_states.QBGA(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

Abfluss aus dem Basisabfluss-Gebietsspeicher (outflow from the storage compartment for base flow) [mm/T].

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[int | float | bool | None, int | float | bool | None] = (None, None)

name: str = 'qbga'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

Log sequences

class hydpy.models.lland.LogSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: LogSequences

Log sequences of model lland.

The following classes are selected:

• WET0() Zeitlich gewichtete Grasreferenzverdunstung (temporally weighted reference evapotranspiration) [mm/T].

• LoggedTemL() Logged air temperature [°C].

• LoggedRelativeHumidity() Logged relative humidity [%].

• LoggedSunshineDuration() Logged sunshine duration [h].

• LoggedPossibleSunshineDuration() Logged astronomically possible sunshine duration [h].

• LoggedGlobalRadiation() Logged global radiation [W/m²].

• LoggedWindSpeed2m() Logged wind speed [m/s].

class hydpy.models.lland.lland_logs.WET0(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: LogSequence

Zeitlich gewichtete Grasreferenzverdunstung (temporally weighted reference evapotranspiration) [mm/T].

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'

Name of the variable in lower case letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.lland.lland_logs.LoggedTemL(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: LogSequence

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'

Name of the variable in lower case letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.lland.lland_logs.LoggedRelativeHumidity(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: LogSequence

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'

Name of the variable in lower case letters.

unit: str = '%'

Unit of the variable.

class hydpy.models.lland.lland_logs.LoggedSunshineDuration(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: LogSequence

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'

Name of the variable in lower case letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.lland.lland_logs.LoggedPossibleSunshineDuration(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: LogSequence

Logged astronomically possible sunshine duration [h].

Updated by the method:

Update_LoggedPossibleSunshineDuration_V1

Required by the method:

Calc_DailyPossibleSunshineDuration_V1

NDIM: int = 1

NUMERIC: bool = False

name: str = 'loggedpossiblesunshineduration'

Name of the variable in lower case letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.lland.lland_logs.LoggedGlobalRadiation(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: LogSequence

Logged global radiation [W/m²].

Updated by the method:

Update_LoggedGlobalRadiation_V1

Required by the method:

Calc_DailyGlobalRadiation_V1

NDIM: int = 1

NUMERIC: bool = False

name: str = 'loggedglobalradiation'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_logs.LoggedWindSpeed2m(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: LogSequence

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'

Name of the variable in lower case letters.

unit: str = 'm/s'

Unit of the variable.

Inlet sequences

class hydpy.models.lland.InletSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: InletSequences

Inlet sequences of model lland.

The following classes are selected:

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

class hydpy.models.lland.lland_inlets.Q(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: InletSequence

Abfluss (runoff) [m³/s].

Required by the method:

Pick_QZ_V1

NDIM: int = 1

NUMERIC: bool = False

name: str = 'q'

Name of the variable in lower case letters.

unit: str = 'm³/s'

Unit of the variable.

Outlet sequences

class hydpy.models.lland.OutletSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: OutletSequences

Outlet sequences of model lland.

The following classes are selected:

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

class hydpy.models.lland.lland_outlets.Q(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: OutletSequence

Abfluss (runoff) [m³/s].

Calculated by the method:

Pass_QA_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'q'

Name of the variable in lower case letters.

unit: str = 'm³/s'

Unit of the variable.

Aide sequences

class hydpy.models.lland.AideSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: AideSequences

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) [W/m²].

• 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: ModelSequences[ModelSequence, FastAccess])

Bases: AideSequence

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'

Name of the variable in lower case letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.lland.lland_aides.RLAtm(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: AideSequence

Atmosphärische Gegenstrahlung (longwave radiation emitted from the atmosphere) [W/m²].

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'

Name of the variable in lower case letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.lland.lland_aides.TempS(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: AideSequence

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'

Name of the variable in lower case letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.lland.lland_aides.TempSInz(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: AideSequence

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'

Name of the variable in lower case letters.

unit: str = '°C'

Unit of the variable.

Auxiliary Features

Masks

class hydpy.models.lland.Masks

Bases: Masks

Masks of base model lland.

The following classes are selected:

• Complete() Mask including all land uses.

• Land() Mask excluding the land uses WASSER, SEE and FLUSS.

• Soil() Mask excluding the land uses WASSER, SEE, FLUSS, and VERS.

• Forest() Mask including the land uses LAUBW, MISCHW, and NADELW.

• Water() Mask including the land uses WASSER, SEE, and FLUSS.

• Sied_D() Mask for land use SIED_D.

• Sied_L() Mask for land use SIED_L.

• Vers() Mask for land use VERS.

• Acker() Mask for land use ACKER.

• Weinb() Mask for land use WEINB.

• Obstb() Mask for land use OBSTB.

• Boden() Mask for land use BODEN.

• Glets() Mask for land use GLETS.

• Grue_I() Mask for land use GRUE_I.

• Feucht() Mask for land use FEUCHT.

• Grue_E() Mask for land use GRUE_E.

• Baumb() Mask for land use BAUMB.

• Nadelw() Mask for land use NADELW.

• Laubw() Mask for land use LAUBW.

• Mischw() Mask for land use MISCHW.

• Wasser() Mask for land use WASSER.

• Fluss() Mask for land use FLUSS.

• See() Mask for land use SEE.

class hydpy.models.lland.lland_masks.Complete(variable: VariableProtocol | None = None, **kwargs)

Bases: 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)

Reference to the associated instance of Lnk.

name: str = 'complete'

class hydpy.models.lland.lland_masks.Land(variable: VariableProtocol | None = None, **kwargs)

Bases: 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'

class hydpy.models.lland.lland_masks.Soil(variable: VariableProtocol | None = None, **kwargs)

Bases: 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'

class hydpy.models.lland.lland_masks.Forest(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask including the land uses LAUBW, MISCHW, and NADELW.

RELEVANT_VALUES: Tuple[int, ...] = (14, 15, 13)

name: str = 'forest'

class hydpy.models.lland.lland_masks.Water(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask including the land uses WASSER, SEE, and FLUSS.

relevant = (16, 18, 17)

name: str = 'water'

class hydpy.models.lland.lland_masks.Sied_D(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use SIED_D.

RELEVANT_VALUES: Tuple[int, ...] = (1,)

name: str = 'sied_d'

class hydpy.models.lland.lland_masks.Sied_L(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use SIED_L.

RELEVANT_VALUES: Tuple[int, ...] = (2,)

name: str = 'sied_l'

class hydpy.models.lland.lland_masks.Vers(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use VERS.

RELEVANT_VALUES: Tuple[int, ...] = (3,)

name: str = 'vers'

class hydpy.models.lland.lland_masks.Acker(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use ACKER.

RELEVANT_VALUES: Tuple[int, ...] = (4,)

name: str = 'acker'

class hydpy.models.lland.lland_masks.Weinb(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use WEINB.

RELEVANT_VALUES: Tuple[int, ...] = (5,)

name: str = 'weinb'

class hydpy.models.lland.lland_masks.Obstb(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use OBSTB.

RELEVANT_VALUES: Tuple[int, ...] = (6,)

name: str = 'obstb'

class hydpy.models.lland.lland_masks.Boden(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use BODEN.

RELEVANT_VALUES: Tuple[int, ...] = (7,)

name: str = 'boden'

class hydpy.models.lland.lland_masks.Glets(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use GLETS.

RELEVANT_VALUES: Tuple[int, ...] = (8,)

name: str = 'glets'

class hydpy.models.lland.lland_masks.Grue_I(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use GRUE_I.

RELEVANT_VALUES: Tuple[int, ...] = (9,)

name: str = 'grue_i'

class hydpy.models.lland.lland_masks.Feucht(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use FEUCHT.

RELEVANT_VALUES: Tuple[int, ...] = (10,)

name: str = 'feucht'

class hydpy.models.lland.lland_masks.Grue_E(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use GRUE_E.

RELEVANT_VALUES: Tuple[int, ...] = (11,)

name: str = 'grue_e'

class hydpy.models.lland.lland_masks.Baumb(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use BAUMB.

RELEVANT_VALUES: Tuple[int, ...] = (12,)

name: str = 'baumb'

class hydpy.models.lland.lland_masks.Nadelw(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use NADELW.

RELEVANT_VALUES: Tuple[int, ...] = (13,)

name: str = 'nadelw'

class hydpy.models.lland.lland_masks.Laubw(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use LAUBW.

RELEVANT_VALUES: Tuple[int, ...] = (14,)

name: str = 'laubw'

class hydpy.models.lland.lland_masks.Mischw(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use MISCHW.

RELEVANT_VALUES: Tuple[int, ...] = (15,)

name: str = 'mischw'

class hydpy.models.lland.lland_masks.Wasser(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use WASSER.

RELEVANT_VALUES: Tuple[int, ...] = (16,)

name: str = 'wasser'

class hydpy.models.lland.lland_masks.Fluss(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use FLUSS.

RELEVANT_VALUES: Tuple[int, ...] = (17,)

name: str = 'fluss'

class hydpy.models.lland.lland_masks.See(variable: VariableProtocol | None = None, **kwargs)

Bases: Complete

Mask for land use SEE.

RELEVANT_VALUES: Tuple[int, ...] = (18,)

name: str = 'see'

class hydpy.models.lland.AideSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: AideSequences

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) [W/m²].

• 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: Parameters, cls_fastaccess: Type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)

Bases: SubParameters

Control parameters of model lland.

The following classes are selected:

• 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) [-].

• 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) [W/m²/K].

• Turb1() Parameter des Übergangskoeffizienten des turbulenten Wärmestroms (parameter of transition coefficient for turbulent heat flux) [J/m³/K].

• 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) [W/m²/K].

• WG2Z() Bodenwärmestrom in der Tiefe 2z (soil heat flux at depth 2z) [W/m²].

• 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: Parameters, cls_fastaccess: Type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)

Bases: SubParameters

Derived parameters of model lland.

The following classes are selected:

• MOY() References the “global” month 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].

• NmbLogEntries() The number of log entries required for a memory duration of 24 hours [-].

• 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 [WT].

• Fr() Reduktionsfaktor für Strahlung according to LEG (2020) (basierend auf LUWG (2015)) (reduction factor for short- and long wave radiation) LEG (2020) (based on LUWG (2015)) [-].

• 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/T to m³/s.

class hydpy.models.lland.FixedParameters(master: Parameters, cls_fastaccess: Type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)

Bases: SubParameters

Fixed parameters of model lland.

The following classes are selected:

• CPWasser() Spezifische Wärmekapazität von Wasser (specific heat capacity of water) [WT/kg/K].

• CPEis() Spezifische Wärmekapazität von Eis bei 0 °C (specific heat capacity of ice at a temperature of 0 °C) [WT/kg/K].

• RSchmelz() Spezifische Schmelzwärme von Wasser (specific melt heat of water) [WT/kg].

• 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) [W/m/K].

• Sigma() Stefan-Boltzmann-Konstante (Stefan-Boltzmann constant) [W/m²/K].

• RDryAir() Gaskonstante für trockene Luft (gas constant for dry air) [J/kg/K].

• RWaterVapour() Gaskonstante für Wasserdampf (gas constant for water vapour) [J/kg/K].

• LW() Latente Verdunstungswärme bei 15°C (heat of condensation at at temperature of 15°C) [WT/kg)].

• LWE() Mittlere latente Verdunstungswärme für Wasser und Eis (average heat of condensation for water and ice) [WT/kg].

• CPLuft() Spezifische Wärmekapazität Luft (heat of condensation for a water temperature of 15°C) [WT/kg/K].

• Psy() Psychrometerkonstante bei Normaldruck (psychrometric constant at normal pressure) [hPa/K].

• PsyInv() Kehrwert der Psychrometerkonstante über Schnee und Eis bei 0°C (inverse psychrometric constant for ice and snow at 0°C) [K/hPa].

• Z0() Rauhigkeitslänge für Wiese (roughness length for short grass) [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) [WT/m³/K].

class hydpy.models.lland.FluxSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: FluxSequences

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/T].

• TemLTag() Tageswert der Lufttemperatur (daily air temperature) [°C].

• DailyRelativeHumidity() Daily relative humidity [%].

• DailySunshineDuration() Daily sunshine duration [h].

• DailyPossibleSunshineDuration() Astronomically possible daily sunshine duration [h].

• DailyGlobalRadiation() Daily global radiation [h].

• NKor() Korrigierter Niederschlag (corrected precipitation) [mm/T].

• 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 [hPa].

• DailySaturationVapourPressure() Daily satuarion vapour pressure [hPa].

• SaturationVapourPressureInz() Sättigungsdampdruck unmittelbar oberhalb der Oberfläche des interzepierten Schnees (saturation vapour pressure directly above the surface of the intercepted snow) [hPa].

• SaturationVapourPressureSnow() Saturation vapour pressure snow [hPa].

• SaturationVapourPressureSlope() The slope of the saturation vapour pressure curve [hPa/K].

• DailySaturationVapourPressureSlope() Daily satuarion vapour pressure [hPa/K].

• ActualVapourPressure() Actual vapour pressure [hPa].

• DailyActualVapourPressure() Daily actual vapour pressure [hPa].

• DryAirPressure() Dry air pressure [hPa].

• DensityAir() Air density [kg/m³]

• G() “MORECS” Bodenwärmestrom (“MORECS” soil heat flux) [W/m²].

• TZ() Bodentemperatur in der Tiefe z (soil temperature at depth z) [°C].

• WG() “Dynamischer” Bodenwärmestrom (“dynamic” soil heat flux) [W/m²].

• NetShortwaveRadiation() Netto kurzwellige Strahlungsbilanz (net shortwave radiation) [W/m²].

• NetShortwaveRadiationInz() Kurzwellige Netto-Strahlungsbilanz für den interzipierten Schnee (net shortwave radiation for intercepted snow) [W/m²].

• NetShortwaveRadiationSnow() Kurzwellige Netto-Strahlungsbilanz für Schneeoberflächen (net shortwave radiation for snow surfaces) [W/m²].

• DailyNetShortwaveRadiation() Daily not shortwave radiation [W/m²].

• DailyNetLongwaveRadiation() Daily net longwave radiation [W/m²].

• NetLongwaveRadiationInz() Langwellige Nettostrahlung des interzepierten Schnees (net longwave radiation of the intercepted snow [W/m²].

• NetLongwaveRadiationSnow() Net longwave radiation for snow-surfaces [W/m²].

• NetRadiation() Total net radiation [W/m²].

• NetRadiationInz() Nettostrahlung des interzepierten Schnees (total net radiation of the intercepted snow [W/m²].

• NetRadiationSnow() Total net radiation for snow-surfaces [W/m²].

• DailyNetRadiation() Daily net radiation [W/m²].

• 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/T].

• SBes() Schneeanteil Bestandsniederschlag (frozen stand precipitation) [mm/T].

• 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/T].

• SBesInz() Gefrorener Bestandsniederschlag, der den Schneeinterzeptionsspeicher erreicht (frozen amount of stand precipitation reaching the snow interception storage) [mm/T].

• WNiedInz() Niederschlagsbedingter Wärmestrom in den Schneeinterzeptionsspeicher (heat flux into the snow interception storage due to precipitation) [W/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/T].

• SchmPotInz() Potentielle Schmelze des interzepierten Schnees (potential amount of snow melting within the snow interception storage) [mm/T].

• SchmInz() Tatsächliche Schmelze des interzepierten Schnees (actual amount of snow melting within the snow cover) [mm/T].

• GefrPotInz() Potentielles Wiedergefrieren des interzipierten Schnees (potential amount of water refreezing within the snow interception storage) [mm/T].

• GefrInz() Tatsächliche Wiedergefrieren des interzipierten Schnees (actual amount of water refreezing within the snow interception storage) [mm/T].

• EvSInz() Tatsächliche Verdunstung des interzepierten Schnees (actual evaporation of the intercepted snow) [mm/T].

• ET0() Grasreferenzverdunstung (reference evapotranspiration) [mm/T].

• EvPo() Evapotranspiration (evapotranspiration) [mm/T].

• EvI() Tatsächliche Interzeptionsverdunstung (actual evaporation of intercepted water) [mm/T].

• EvB() Tatsächliche Verdunstung von Bodenwasser (actual evaporation of soil water) [mm/T].

• EvS() Tatsächliche Schneeverdunstung (actual evaporation of snow-water) [mm/T].

• WGTF() Mit dem Grad-Tag-Verfahren berechneter Wärmeestrom in die Schneedecke (heat flux into the snow layer calculated with the degree-day method) [W/m²].

• WNied() Niederschlagsbedingter Wärmestrom in die Schneedecke (heat flux into the snow layer due to precipitation) [W/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/T].

• Schm() Tatsächliche Schneeschmelze (actual amount of water melting within the snow cover) [mm/T].

• GefrPot() Potentielles Schnee-Wiedergefrieren (potential amount of water refreezing within the snow cover) [mm/T].

• Gefr() Tatsächliche Schnee-Wiedergefrieren (actual amount of water refreezing within the snow cover) [mm/T].

• WLatInz() Latente Wärmestrom interzepierter Schnee/Atmosphäre (latent heat flux between the intercepted snow and the atmosphere) [W/m²].

• WLatSnow() Latente Wärmestrom Schnee/Atmosphäre (latent heat flux between the snow-layer and the atmosphere) [W/m²].

• WSensInz() Fühlbare Wärmestrom interzipierter Schnee/Atmosphäre (sensible heat flux between the intercepted snow and the atmosphere) [W/m²].

• WSensSnow() Fühlbare Wärmestrom Schnee/Atmosphäre (sensible heat flux between the snow-layer and the atmosphere) [W/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) [W/m²].

• WSurf() Wärmestrom von der Schneedecke zur Schneeoberfläche (heat flux from the snow layer to the snow surface) [W/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/T].

• QDB() Direktabfluss-Abgabe aus dem Bodenspeicher (direct runoff release from the soil storage) [mm/T].

• QIB1() Erste Komponente der Interflow-Abgabe aus dem Bodenspeicher (first component of the interflow release from the soil storage) [mm/T].

• QIB2() Zweite Komponente der Interflow-Abgabe aus dem Bodenspeicher (second component of the interflow release from the soil storage) [mm/T].

• QBB() Basisabfluss-Abgabe aus dem Bodenspeicher (base flow release from the soil storage) [mm/T].

• QKap() Kapillarer Aufstieg in den Bodenspeicher (capillary rise to soil storage) [mm/T].

• QDGZ() Gesamtzufluss in beide Direktabfluss-Gebietsspeicher (total inflow into both storage compartments for direct runoff) [mm/T].

• QAH() Abflussspende des Teilgebiets (runoff at the catchment outlet) [mm/T].

• QA() Abfluss des Teilgebiets (runoff at the catchment outlet) [m³/s].

class hydpy.models.lland.InletSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: InletSequences

Inlet sequences of model lland.

The following classes are selected:

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

class hydpy.models.lland.InputSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: InputSequences

Input sequences of model lland.

The following classes are selected:

• Nied() Niederschlag (precipitation) [mm/T].

• TemL() Lufttemperatur (air temperature) [°C].

• SunshineDuration() Sonnenscheindauer (sunshine duration) [h].

• PossibleSunshineDuration() Astronomisch mögliche Sonnenscheindauer (astronomically possible sunshine duration) [h].

• GlobalRadiation() Globalstrahlung (global radiation) [W/m²].

• RelativeHumidity() Relative humidity [%].

• WindSpeed() Windgeschwindigkeit (wind speed) [m/s].

• PET() Potenzielle Verdunstung (potential evapotranspiration) [mm/T].

• AtmosphericPressure() Luftdruck (atmospheric pressure) [hPa].

class hydpy.models.lland.LogSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: LogSequences

Log sequences of model lland.

The following classes are selected:

• WET0() Zeitlich gewichtete Grasreferenzverdunstung (temporally weighted reference evapotranspiration) [mm/T].

• LoggedTemL() Logged air temperature [°C].

• LoggedRelativeHumidity() Logged relative humidity [%].

• LoggedSunshineDuration() Logged sunshine duration [h].

• LoggedPossibleSunshineDuration() Logged astronomically possible sunshine duration [h].

• LoggedGlobalRadiation() Logged global radiation [W/m²].

• LoggedWindSpeed2m() Logged wind speed [m/s].

class hydpy.models.lland.OutletSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: OutletSequences

Outlet sequences of model lland.

The following classes are selected:

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

class hydpy.models.lland.StateSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: StateSequences

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 [WT/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) [WT/m²].

• TauS() Dimensionsloses Alter der Schneedecke (dimensionless age of the snow layer) [-].

• EBdn() Energiegehalt des Bodenwassers (energy content of the soil water) [WT/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/T].

• QDGZ2() Zufluss in den dynamischeren Direktabfluss-Gebietsspeicher (inflow into the more responsive storage compartment for direct runoff) [mm/T].

• QIGZ1() “Zufluss in den ersten Zwischenabfluss-Gebietsspeicher (inflow into the first storage compartment for interflow) [mm/T].

• QIGZ2() Zufluss in den zweiten Zwischenabfluss-Gebietsspeicher (inflow into the second storage compartment for interflow) [mm/T].

• QBGZ() Zufluss in den Basisabfluss-Gebietsspeicher (inflow into the storage compartment for base flow) [mm/T].

• QDGA1() Abfluss aus dem trägeren Direktabfluss-Gebietsspeicher (outflow from the less responsive storage compartment for direct runoff) [mm/T].

• QDGA2() Abfluss aus dem dynamischeren Direktabfluss-Gebietsspeicher (outflow from the more responsive storage compartment for direct runoff) [mm/T].

• QIGA1() Abfluss aus dem “unteren” Zwischenabfluss-Gebietsspeicher (outflow from the storage compartment for the first interflow component) [mm/T].

• QIGA2() Abfluss aus dem “oberen” Zwischenabfluss-Gebietsspeicher (outflow from the storage compartment for the second interflow component) [mm/T].

• QBGA() Abfluss aus dem Basisabfluss-Gebietsspeicher (outflow from the storage compartment for base flow) [mm/T].