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.

• Process_RadiationModel_V1 Let a submodel that complies with the RadiationModel_V1 interface preprocess all eventually required data.

• Calc_PossibleSunshineDuration_V1 Query the possible sunshine duration from a submodel that complies with the RadiationModel_V1 or RadiationModel_V4 interface.

• Calc_SunshineDuration_V1 Query the actual sunshine duration from a submodel that complies with the RadiationModel_V1 or RadiationModel_V4 interface.

• Calc_GlobalRadiation_V1 Query the global radiation from a submodel that complies with the RadiationModel_V1 or RadiationModel_V4 interface.

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

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

• Calc_TKor_V1 Adjust the given air temperature value.

• Calc_WindSpeed2m_V1 Adjust the measured wind speed to a height of 2 meters above the ground according to LEG (2020).

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

• Calc_SaturationVapourPressure_V1 Calculate the saturation vapour pressure over arbitrary surfaces.

• Calc_ActualVapourPressure_V1 Calculate the actual vapour pressure.

• 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 snow albedo according to LEG (2020), based on LUBW (2006).

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

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

• 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_EvI_Inzp_V1 Let a submodel that follows the AETModel_V1 submodel interface calculate interception evaporation and adjust the amount of intercepted water.

• Calc_EvB_V1 Let a submodel that follows the AETModel_V1 submodel interface calculate 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.

• 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_SBG_V1 Update the base flow storage and calculate its outflow.

• Calc_QBGA_SBG_QBGZ_QDGZ_V1 Update the base flow storage and calculate its outflow, taking possible “groundwater restrictions” into account.

• Calc_QIGA1_SIG1_V1 Update the storage of the first interflow component and calculate its outflow.

• Calc_QIGA2_SIG2_V1 Update the storage of the second interflow component and calculate its outflow.

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

• Calc_QDGA1_SDG1_V1 Update the storage of the slow direct runoff component and calculate its outflow.

• Calc_QDGA2_SDG2_V1 Update the storage of the fast direct runoff component and calculate its outflow.

• 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 interface methods are available to main models using the defined model as a submodel:

• Get_Temperature_V1 Get the selected zone’s current temperature.

• Get_MeanTemperature_V1 Get the basin’s current mean temperature.

• Get_Precipitation_V1 Get the current precipitation from the selected hydrological response unit.

• Get_InterceptedWater_V1 Get the selected response unit’s current amount of intercepted water.

• Get_SoilWater_V1 Get the selected response unit’s current soil water content.

• Get_SnowCover_V1 Get the selected response unit’s current snow cover degree.

• Get_SnowyCanopy_V1 Get the selected response unit’s current snow cover degree in the canopies of tree-like vegetation (or nan if the zone’s vegetation is not tree-like).

• Get_SnowAlbedo_V1 Get the selected response unit’s current albedo as a fraction.

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:

• Calc_EvI_Inzp_AETModel_V1 Let a submodel that follows the AETModel_V1 submodel interface calculate interception evaporation and adjust the amount of intercepted water.

• Calc_EvB_AETModel_V1 Let a submodel that follows the AETModel_V1 submodel interface calculate soil evapotranspiration.

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

• Return_SG_V1 Return the new storage value after applying the analytical solution for the linear storage differential equation under the assumption of constant inflow.

• Calc_BoWa_Default_V1 Update the soil moisture and (if necessary) correct the fluxes to be added or subtracted.

• Calc_BoWa_SoilModel_V1 Apply a submodel following the SoilModel_V1 interface to include additional direct runoff and groundwater recharge components into the soil moisture update.

Users can hook submodels into the defined main model if they satisfy one of the following interfaces:

• AETModel_V1 Interface for calculating interception evaporation, evapotranspiration from soils, evaporation from water areas in separate steps.

• SoilModel_V1 Soil submodel interface for calculating infiltration and percolation in multiple soil compartments.

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.

radiationmodel

Required submodel that complies with one of the following interfaces: RadiationModel_V1 or RadiationModel_V4.

radiationmodel_is_mainmodel

radiationmodel_typeid

aetmodel

Required submodel that complies with the following interface: AETModel_V1.

aetmodel_is_mainmodel

aetmodel_typeid

soilmodel

Optional submodel that complies with the following interface: SoilModel_V1.

soilmodel_is_mainmodel

soilmodel_typeid

REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()

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.Process_RadiationModel_V1

Bases: Method

Let a submodel that complies with the RadiationModel_V1 interface preprocess all eventually required data.

Example:

We use the combination of lland_v1 and meteo_v003 as an example:

>>> from hydpy import pub
>>> pub.timegrids = "1997-08-01", "1997-08-02", "1d"
>>> from hydpy.models.lland_v3 import *
>>> parameterstep()
>>> with model.add_radiationmodel_v1("meteo_v003"):
...     latitude(54.1)
...     longitude(9.7)
...     angstromconstant(0.25)
...     angstromfactor(0.5)
...     angstromalternative(0.15)
...     inputs.sunshineduration = 6.3
>>> model.process_radiationmodel_v1()
>>> model.radiationmodel.sequences.fluxes.globalradiation
globalradiation(190.25149)

class hydpy.models.lland.lland_model.Calc_PossibleSunshineDuration_V1

Bases: Method

Query the possible sunshine duration from a submodel that complies with the RadiationModel_V1 or RadiationModel_V4 interface.

Calculates the factor sequence:

PossibleSunshineDuration

Examples:

We combine lland_v3 with submodels that comply with different interfaces. First, with meteo_v003, which complies with RadiationModel_V1:

>>> from hydpy.models.lland_v3 import *
>>> parameterstep()
>>> with model.add_radiationmodel_v1("meteo_v003", update=False):
...     factors.possiblesunshineduration = 10.0
>>> model.calc_possiblesunshineduration()
>>> factors.possiblesunshineduration
possiblesunshineduration(10.0)

Second, with meteo_psun_sun_glob_io, which complies with RadiationModel_V4:

>>> with model.add_radiationmodel_v4("meteo_psun_sun_glob_io", update=False):
...     inputs.possiblesunshineduration = 14.0
>>> model.calc_possiblesunshineduration()
>>> factors.possiblesunshineduration
possiblesunshineduration(14.0)

class hydpy.models.lland.lland_model.Calc_SunshineDuration_V1

Bases: Method

Query the actual sunshine duration from a submodel that complies with the RadiationModel_V1 or RadiationModel_V4 interface.

Calculates the factor sequence:

SunshineDuration

We combine lland_v3 with submodels that comply with different interfaces. First, with meteo_v001, which complies with RadiationModel_V1:

>>> from hydpy.models.lland_v3 import *
>>> parameterstep()
>>> with model.add_radiationmodel_v1("meteo_v003", update=False):
...     inputs.sunshineduration = 10.0
>>> model.calc_sunshineduration()
>>> factors.sunshineduration
sunshineduration(10.0)

Second, with meteo_psun_sun_glob_io, which complies with RadiationModel_V4:

>>> with model.add_radiationmodel_v4("meteo_psun_sun_glob_io", update=False):
...     inputs.sunshineduration = 14.0
>>> model.calc_sunshineduration()
>>> factors.sunshineduration
sunshineduration(14.0)

class hydpy.models.lland.lland_model.Calc_GlobalRadiation_V1

Bases: Method

Query the global radiation from a submodel that complies with the RadiationModel_V1 or RadiationModel_V4 interface.

Calculates the flux sequence:

GlobalRadiation

Examples:

We combine lland_v3 with submodels that comply with different interfaces. First, with meteo_v003, which complies with RadiationModel_V1:

>>> from hydpy.models.lland_v3 import *
>>> parameterstep()
>>> with model.add_radiationmodel_v1("meteo_v003", update=False):
...     fluxes.globalradiation = 100.0
>>> model.calc_globalradiation()
>>> fluxes.globalradiation
globalradiation(100.0)

Second, with meteo_psun_sun_glob_io, which complies with RadiationModel_V4:

>>> with model.add_radiationmodel_v4("meteo_psun_sun_glob_io", update=False):
...     inputs.globalradiation = 400.0
>>> model.calc_globalradiation()
>>> fluxes.globalradiation
globalradiation(400.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 factor 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=(factors.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 factor 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=(factors.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_WindSpeed2m_V1

Bases: Method

Adjust the measured wind speed to a height of 2 meters above the ground according to LEG (2020).

Requires the control parameter:

MeasuringHeightWindSpeed

Requires the fixed parameter:

Z0

Requires the input sequence:

WindSpeed

Calculates the flux sequence:

WindSpeed2m

Basic equation:

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

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> 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_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 flux sequences:

GlobalRadiation 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()
>>> fluxes.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_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.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_ActualVapourPressure_V1

Bases: Method

Calculate the actual vapour pressure.

Requires the control parameter:

NHRU

Requires the input sequence:

RelativeHumidity

Requires the flux sequence:

SaturationVapourPressure

Calculates the flux sequence:

ActualVapourPressure

Basic equation:

\(ActualVapourPressure = SaturationVapourPressure \cdot RelativeHumidity / 100\)

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_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)
>>> 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 snow albedo according to LEG (2020), based on LUBW (2006).

Requires the control parameters:

NHRU SnowAgingFactor Albedo0Snow

Requires the state sequences:

TauS WAeS

Calculates the flux sequence:

ActualAlbedo

For snow-free surfaces, method Calc_ActualAlbedo_V1 sets ActualAlbedo to nan. For snow conditions, it estimates the albedo based on the snow age, as shown by the following equation.

Basic equation:

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

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(4)
>>> albedo0snow(0.8)
>>> snowagingfactor(0.35)
>>> states.waes = 0.0, 1.0, 1.0, 1.0
>>> states.taus = nan, 0.0, 1.0, 3.0
>>> model.calc_actualalbedo_v1()
>>> fluxes.actualalbedo
actualalbedo(nan, 0.8, 0.66, 0.59)

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 flux sequences:

GlobalRadiation 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()
>>> fluxes.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)

>>> fluxes.actualalbedo = nan
>>> model.calc_netshortwaveradiationsnow_v1()
>>> fluxes.netshortwaveradiationsnow
netshortwaveradiationsnow(0.0, 0.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.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:

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.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)
>>> 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)
>>> 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.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.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()
>>> 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.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()
>>> 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_AETModel_V1

Bases: Method

Let a submodel that follows the AETModel_V1 submodel interface calculate soil evapotranspiration.

Required by the method:

Calc_EvB_V1

Requires the control parameters:

NHRU Lnk

Calculates the flux sequence:

EvB

Examples:

We build an example based on evap_minhas:

>>> from hydpy.models.lland_v1 import *
>>> parameterstep("1h")
>>> nhru(5)
>>> lnk(VERS, ACKER, ACKER, MISCHW, WASSER)
>>> ft(1.0)
>>> fhru(0.05, 0.1, 0.2, 0.3, 0.35)
>>> wmax(100.0)
>>> with model.add_aetmodel_v1("evap_minhas"):
...     dissefactor(5.0)

Calc_EvB_AETModel_V1 stores the flux returned by the submodel without any modifications:

>>> states.bowa = 0.0, 0.0, 50.0, 100.0, 0.0
>>> model.aetmodel.sequences.fluxes.potentialinterceptionevaporation = 5.0
>>> model.aetmodel.sequences.fluxes.potentialsoilevapotranspiration = 5.0
>>> model.aetmodel.sequences.fluxes.interceptionevaporation = 3.0
>>> model.calc_evb_v1()
>>> fluxes.evb
evb(0.0, 0.0, 1.717962, 2.0, 0.0)

class hydpy.models.lland.lland_model.Calc_EvB_V1

Bases: Method

Let a submodel that follows the AETModel_V1 submodel interface calculate soil evapotranspiration.

Required submethod:

Calc_EvB_AETModel_V1

Requires the control parameters:

NHRU Lnk

Calculates the flux sequence:

EvB

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_AETModel_V1

Bases: Method

Let a submodel that follows the AETModel_V1 submodel interface calculate interception evaporation and adjust the amount of intercepted water.

Required by the method:

Calc_EvI_Inzp_V1

Requires the control parameters:

NHRU Lnk

Updates the state sequence:

Inzp

Calculates the flux sequence:

EvI

Basic equation:

\(\frac{dInzp_i}{dt} = -EvI_i\)

Examples:

We build an example based on evap_minhas for calculating interception evaporation, which uses evap_io for querying potential evapotranspiration:

>>> from hydpy.models.lland_v1 import *
>>> parameterstep("1h")
>>> nhru(5)
>>> lnk(VERS, ACKER, ACKER, MISCHW, WASSER)
>>> ft(1.0)
>>> fhru(0.05, 0.1, 0.2, 0.3, 0.35)
>>> derived.kinz.jun = 3.0
>>> wmax(50.0)
>>> derived.moy.shape = 1
>>> derived.moy(5)
>>> fluxes.nbes = 0.5
>>> with model.add_aetmodel_v1("evap_minhas"):
...     with model.add_petmodel_v1("evap_io"):
...         evapotranspirationfactor(0.6, 0.8, 1.0, 1.2, 1.4)
...         inputs.referenceevapotranspiration = 1.0

For non-water areas, Calc_EvI_Inzp_AETModel_V1 uses the flux returned by the submodel to adjust Inzp:

>>> states.inzp = 2.0
>>> model.calc_evi_inzp_v1()
>>> fluxes.evi
evi(0.6, 0.8, 1.0, 1.2, 1.4)
>>> states.inzp
inzp(1.4, 1.2, 1.0, 0.8, 0.0)
>>> fluxes.nbes
nbes(0.5, 0.5, 0.5, 0.5, 0.5)

Calc_EvI_Inzp_AETModel_V1 eventually reduces EvI so that Inzp does not become negative:

>>> model.aetmodel.petmodel.sequences.inputs.referenceevapotranspiration = 5.0
>>> states.inzp = 2.0
>>> model.calc_evi_inzp_v1()
>>> fluxes.evi
evi(2.0, 2.0, 2.0, 2.0, 7.0)
>>> states.inzp
inzp(0.0, 0.0, 0.0, 0.0, 0.0)
>>> fluxes.nbes
nbes(0.5, 0.5, 0.5, 0.5, 0.5)

In contrast, Calc_EvI_Inzp_AETModel_V1 does not reduce negative EvI values (condensation) that cause an overshoot of the interception storage capacity:

>>> model.aetmodel.petmodel.sequences.inputs.referenceevapotranspiration = -3.0
>>> states.inzp = 2.0
>>> model.calc_evi_inzp_v1()
>>> fluxes.evi
evi(-1.8, -2.4, -3.0, -3.6, -4.2)
>>> states.inzp
inzp(3.8, 4.4, 5.0, 5.6, 0.0)
>>> fluxes.nbes
nbes(0.5, 0.5, 0.5, 0.5, 0.5)

class hydpy.models.lland.lland_model.Calc_EvI_Inzp_V1

Bases: Method

Let a submodel that follows the AETModel_V1 submodel interface calculate interception evaporation and adjust the amount of intercepted water.

Required submethod:

Calc_EvI_Inzp_AETModel_V1

Requires the control parameters:

NHRU Lnk

Updates the state sequence:

Inzp

Calculates the flux sequence:

EvI

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 FK \;\; \land \;\; RBeta) \\ Beta_{eff} \cdot (BoWa - PWP) &|\ BoWa > FK \;\; \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_Default_V1

Bases: Method

Update the soil moisture and (if necessary) correct the fluxes to be added or subtracted.

Required by the method:

Calc_BoWa_V1

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 can 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_default_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 from exceeding 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_default_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 overflows, we might need to decrease EvB if it is negative (when 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_default_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 values, we might need to decrease QBB, QIB2, 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_default_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 modify negative EvB values (condensation) when preventing 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_default_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_BoWa_SoilModel_V1

Bases: Method

Apply a submodel following the SoilModel_V1 interface to include additional direct runoff and groundwater recharge components into the soil moisture update.

Required by the method:

Calc_BoWa_V1

Requires the control parameters:

NHRU Lnk

Requires the flux sequence:

WaDa

Updates the flux sequences:

EvB QBB QIB1 QIB2 QDB QKap

Updates the state sequence:

BoWa

Examples:

We prepare a lland model instance consisting of four hydrological response units, which will serve as the main model:

>>> from hydpy.models.lland_v1 import *
>>> simulationstep("1h")
>>> parameterstep("1h")
>>> nhru(4)

As an example, we select ga_garto_submodel1 as the submodel. We define its parameter values like in the initial examples of the documentation on ga_garto_submodel1 and its stand-alone counterpart ga_garto (soil type loam) but prepare - analogue to the main model’s setting - four soil compartments. The two first compartments have a soil depth of 1.0 m (“deep soils”) and the two last of 0.1 m (“flat soils”):

>>> from hydpy import prepare_model, pub
>>> with model.add_soilmodel_v1("ga_garto_submodel1"):
...     nmbsoils(4)
...     nmbbins(3)
...     with pub.options.parameterstep("1s"):
...         dt(1.0)
...     sealed(False)
...     soildepth(1000.0, 1000.0, 100.0, 100.0)
...     residualmoisture(0.027)
...     saturationmoisture(0.434)
...     saturatedconductivity(13.2)
...     poresizedistribution(0.252)
...     airentrypotential(111.5)

For water areas and sealed surfaces, lland does not apply its submodel and just sets BoWa to zero:

>>> lnk(FLUSS, SEE, WASSER, VERS)
>>> states.bowa = 100.0
>>> model.calc_bowa_v1()
>>> states.bowa
bowa(0.0, 0.0, 0.0, 0.0)

Calc_BoWa_SoilModel_V1 works the same for all other land use types. We randomly select ACKER (arable land):

>>> lnk(ACKER)

The water reaching the soil routine (WaDa) is 40 mm/h for each response unit in all examples:

>>> fluxes.wada = 40.0

We define a function that will help us to execute the following test runs. It sets the values of the main model’s flux sequences for direct runoff (QDB), both interflow components (QIB2 and QIB1), base flow (QBB), evapotranspiration (EvB), and capillary rise (QKap). Direct runoff is predefined to 40 mm/h for the first (deep) and third (flat) response unit and 0 mm/h for the second (deep) and fourth (flat) response unit. The other flux sequences’ values are customisable (default value 0 mm/h). The initial relative soil moisture (Moisture) is 10 %, which makes an absolute soil water content (BoWa) of 100 mm for the first two and 10 mm for the last two response units. After applying method Calc_BoWa_SoilModel_V1, our test function checks for possible water balance violations and (if it does not find any) prints the updated soil moisture content and the eventually adjusted flux sequences’s values:

>>> garto = model.soilmodel
>>> from numpy import array, round
>>> from hydpy.core.objecttools import repr_values
>>> def check(qib2=0, qib1=0, qbb=0, evb=0, qkap=0):
...     fluxes.qdb = 40.0, 0.0, 40, 0.0
...     fluxes.qib2 = qib2
...     fluxes.qib1 = qib1
...     fluxes.qbb = qbb
...     fluxes.evb = evb
...     fluxes.qkap = qkap
...     garto.sequences.states.moisture = 0.1
...     garto.sequences.states.frontdepth = 0.0
...     garto.sequences.states.moisturechange = 0.0
...     old_bowa = array([garto.get_soilwatercontent(k) for k in range(4)])
...     model.calc_bowa_v1()
...     new_bowa = states.bowa.values.copy()
...     delta = (fluxes.wada + fluxes.qkap - fluxes.qdb - fluxes.qib2
...              - fluxes.qib1 - fluxes.qbb - fluxes.evb)
...     assert all(round(new_bowa, 11) == round(old_bowa + delta, 11))
...     print("bowa:", repr_values(states.bowa))
...     print("qdb:", repr_values(fluxes.qdb))
...     print("qib2:", repr_values(fluxes.qib2))
...     print("qib1:", repr_values(fluxes.qib1))
...     print("qbb:", repr_values(fluxes.qbb))
...     print("evb:", repr_values(fluxes.evb))
...     print("qkap:", repr_values(fluxes.qkap))

If WaDa (the potential direct runoff amount) and QDB (the already calculated direct runoff amount) are equal, like for the hydrological response units one and three, there is no water left that could infiltrate into the soil. For zero previously calculated direct runoff, WaDa could infiltrate completely. Here, about 38.9 mm enter the deep soil, and the remainder (1.1 mm) becomes direct runoff (compare with example deep soil). The flat soil becomes completely saturated so that there is a larger amount of direct runoff (4.5 mm) and also a considerable amount of groundwater recharge (2.1 mm) (see example 100 mm depth):

>>> check()
bowa: 100.0, 138.896943, 10.0, 43.4
qdb: 40.0, 1.103057, 40.0, 4.502667
qib2: 0.0, 0.0, 0.0, 0.0
qib1: 0.0, 0.0, 0.0, 0.0
qbb: 0.0, 0.0, 0.0, 2.097333
evb: 0.0, 0.0, 0.0, 0.0
qkap: 0.0, 0.0, 0.0, 0.0

Calc_BoWa_SoilModel_V1 adds externally defined capillary rise after performing the infiltration and percolation routine. Hence, passing a capillary rise value of 1.0 mm does not result in direct runoff or groundwater recharge differences compared to the previous example Note that the fourths soil compartment cannot receive capillary rise due to its saturation. Hence, Calc_BoWa_SoilModel_V1 corrects QKap to zero:

>>> check(qkap=1.0)
bowa: 101.0, 139.896943, 11.0, 43.4
qdb: 40.0, 1.103057, 40.0, 4.502667
qib2: 0.0, 0.0, 0.0, 0.0
qib1: 0.0, 0.0, 0.0, 0.0
qbb: 0.0, 0.0, 0.0, 2.097333
evb: 0.0, 0.0, 0.0, 0.0
qkap: 1.0, 1.0, 1.0, 0.0

Passing an (extremely unrealistic) capillary rise of 40.0 mm requires also a reduction for the third soil compartment:

>>> check(qkap=40.0)
bowa: 140.0, 178.896943, 43.4, 43.4
qdb: 40.0, 1.103057, 40.0, 4.502667
qib2: 0.0, 0.0, 0.0, 0.0
qib1: 0.0, 0.0, 0.0, 0.0
qbb: 0.0, 0.0, 0.0, 2.097333
evb: 0.0, 0.0, 0.0, 0.0
qkap: 40.0, 40.0, 33.4, 0.0

Calc_BoWa_SoilModel_V1 allows for negative evapotranspiration values and handles them like capillary rise. If their sum exceeds the available soil water storage, Calc_BoWa_SoilModel_V1 reduces both by the same factor:

>>> check(qkap=30.0, evb=-10.0)
bowa: 140.0, 178.896943, 43.4, 43.4
qdb: 40.0, 1.103057, 40.0, 4.502667
qib2: 0.0, 0.0, 0.0, 0.0
qib1: 0.0, 0.0, 0.0, 0.0
qbb: 0.0, 0.0, 0.0, 2.097333
evb: -10.0, -10.0, -8.35, 0.0
qkap: 30.0, 30.0, 25.05, 0.0

The last process triggered by Calc_BoWa_SoilModel_V1 is removing of a defined water demand. This demand is the sum of both interflow components, base flow, and evapotranspiration:

>>> check(qib2=6.0, qib1=3.0, qbb=2.0, evb=1.0)
bowa: 88.0, 126.896943, 2.7, 31.4
qdb: 40.0, 1.103057, 40.0, 4.502667
qib2: 6.0, 6.0, 3.65, 6.0
qib1: 3.0, 3.0, 1.825, 3.0
qbb: 2.0, 2.0, 1.216667, 4.097333
evb: 1.0, 1.0, 0.608333, 1.0
qkap: 0.0, 0.0, 0.0, 0.0

For soils that do not contain enough water to satisfy the whole demand, Calc_BoWa_SoilModel_V1 reduces all mentioned components by the same factor:

>>> check(qib2=12.0, qib1=6.0, qbb=4.0, evb=2.0)
bowa: 76.0, 114.896943, 2.7, 19.4
qdb: 40.0, 1.103057, 40.0, 4.502667
qib2: 12.0, 12.0, 3.65, 12.0
qib1: 6.0, 6.0, 1.825, 6.0
qbb: 4.0, 4.0, 1.216667, 6.097333
evb: 2.0, 2.0, 0.608333, 2.0
qkap: 0.0, 0.0, 0.0, 0.0

Negative evapotranspiration values cannot contribute to soil overdrying. Hence, Calc_BoWa_SoilModel_V1 does not modify negative evapotranspiration values when reducing the “real” loss terms:

>>> check(qib2=6.0, qib1=3.0, qbb=2.0, evb=-1.0, qkap=1.0)
bowa: 91.0, 129.896943, 2.7, 32.4
qdb: 40.0, 1.103057, 40.0, 4.502667
qib2: 6.0, 6.0, 5.072727, 6.0
qib1: 3.0, 3.0, 2.536364, 3.0
qbb: 2.0, 2.0, 1.690909, 4.097333
evb: -1.0, -1.0, -1.0, 0.0
qkap: 1.0, 1.0, 1.0, 0.0

class hydpy.models.lland.lland_model.Calc_BoWa_V1

Bases: Method

Update the soil moisture.

Required submethods:

Calc_BoWa_Default_V1 Calc_BoWa_SoilModel_V1

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

Calc_BoWa_V1 serves as a switch method. Its behaviour depends on whether the user activates a soil submodel following the SoilModel_V1 interface or not. If not, Calc_BoWa_V1 applies Calc_BoWa_Default_V1 to perform a “simple” soil moisture update. If so, Calc_BoWa_V1 uses Calc_BoWa_SoilModel_V1 to include additional direct runoff and groundwater recharge components into the soil moisture update. See the documentation of the mentioned submethods for more information.

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 flux 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()
>>> fluxes.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()
>>> fluxes.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 flux 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()
>>> fluxes.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 flux 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()
>>> fluxes.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 flux 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, fluxes.qdgz1, fluxes.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.Return_SG_V1

Bases: Method

Return the new storage value after applying the analytical solution for the linear storage differential equation under the assumption of constant inflow.

Required by the method:

Calc_QBGA_SBG_V1

Basic equation:

\(k \cdot qz - (k \cdot qz - s) \cdot exp(-1 / k)\)

Examples:

The first “normal” test relies on the given basic equation:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> from hydpy import round_
>>> round_(model.return_sg_v1(3.0, 1.0, 2.0, 1.0))
2.417343

Zero concentration time does not result in zero division errors:

>>> round_(model.return_sg_v1(0.0, 1.0, 2.0, 1.0))
0.0

Also, it is safe to apply infinite concentration time:

>>> round_(model.return_sg_v1(inf, 1.0, 2.0, 1.0))
3.0

class hydpy.models.lland.lland_model.Calc_QBGA_SBG_V1

Bases: Method

Update the base flow storage and calculate its outflow.

Required by the method:

Calc_QBGA_SBG_QBGZ_QDGZ_V1

Required submethod:

Return_SG_V1

Requires the derived parameter:

KB

Requires the flux sequence:

QBGZ

Updates the state sequence:

SBG

Calculates the flux sequence:

QBGA

Basic equations:

\(SBG = Return\_SG\_V1(KB, SBG, QBGZ)\)

\(QBGA = SBG_{old} - SBG_{new} + QBGZ\)

Example:

Method Calc_QBGA_SBG_V1 relies on the analytical solution of the linear storage equation implemented by method Return_SG_V1, from which we take the following test configuration:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> derived.kb(3.0)
>>> states.sbg.old = 1.0
>>> fluxes.qbgz = 2.0
>>> model.calc_qbga_sbg_v1()
>>> states.sbg
sbg(2.417343)
>>> fluxes.qbga
qbga(0.582657)

class hydpy.models.lland.lland_model.Calc_QBGA_SBG_QBGZ_QDGZ_V1

Bases: Method

Update the base flow storage and calculate its outflow, taking possible “groundwater restrictions” into account.

Required submethod:

Calc_QBGA_SBG_V1

Requires the control parameters:

VolBMax GSBMax GSBGrad1 GSBGrad2

Requires the derived parameter:

KB

Updates the flux sequences:

QDGZ QBGZ

Updates the state sequence:

SBG

Calculates the flux sequence:

QBGA

Without active restrictions, method Calc_QBGA_SBG_QBGZ_QDGZ_V1 works like Calc_QBGA_SBG_V1. There are two restrictions, one being volume- and the other one rise-related.

In the “volume-related” case, Calc_QBGA_SBG_QBGZ_QDGZ_V1 redirects groundwater recharge to the direct flow components as soon as the groundwater amount reaches its limit (the available aquifer volume), defined by the parameters VolBMax and GSBMax.

The “rise-related” restriction redirects water in the same direction but reacts to a too fast rise of the groundwater table instead of a too high groundwater amount. It is a linear interpolation approach, with parameter GSBGrad1 representing the highest possible rise without any reduction of the groundwater inflow and GSBGrad2 representing the rise where groundwater recharge would become zero.

Conceptually, both restrictions follow LEG (2020) but their implementations differ in a way that may lead to relevant differences in the results.

The implementation of Calc_QBGA_SBG_QBGZ_QDGZ_V1 is quite complex due to a huge of edge cases requiring special handling. See issue issue 87 for a detailed discussion of its development and the underlying math (there, you can also report edge cases we might not handle well so far). Here, we give only the basic ordinary differential equation solved by Calc_QBGA_SBG_QBGZ_QDGZ_V1.

Basic equation:

\[ \begin{align}\begin{aligned}\begin{split}SBG'(t) = \begin{cases} 0 &|\ SBG(t) = GSBMax \cdot VolBMax \ \land \ SBG'(t) > 0 \\[5pt] QBGZ - \frac{SBG(t)}{KB} &|\ (SBG(t) < GSBMax \cdot VolBMax \ \lor \ SBG'(t) \leq 0) \ \land \ SBG'(t) \leq GSBGrad1 \\[5pt] \frac{GSBGrad2-SBG'(t)}{GSBGrad2-GSBGrad1} \cdot QBGZ - \frac{SBG(t)}{KB} &|\ (SBG(t) < GSBMax \cdot VolBMax \ \lor \ SBG'(t) \leq 0) \ \land\ SBG'(t) > GSBGrad1 \end{cases}\end{split}\\Examples:\\ To give some context, we start our explanations based on method |Calc_QBGA_SBG_V1|:\\ >>> from hydpy.models.lland import * >>> simulationstep("1d") >>> parameterstep("1d") >>> derived.kb(10.0) >>> states.sbg.old = 5.0 >>> fluxes.qbgz = 2.0 >>> model.calc_qbga_sbg_v1() >>> states.sbg sbg(6.427439) >>> fluxes.qbga qbga(0.572561)\\ The content of the storage for base flow (groundwater amount) increases from 5 mm to about 6.43 mm.\\ At the beginning of the interval, the increase of the content of the base flow storage (groundwater rise) is 1.5 mm/d:\\ >>> from hydpy import round_ >>> round_(fluxes.qbgz - states.sbg.old / derived.kb) 1.5\\ With increasing groundwater amount during the interval, base flow also increases, dampening the groundwater rise. Hence, it is only about 1.36 at the end of the interval:\\ >>> round_(fluxes.qbgz - states.sbg.new / derived.kb) 1.357256\\ Capturing all branches of |Calc_QBGA_SBG_QBGZ_QDGZ_V1| requires extensive testing. Therefore, we define function `check`, which compares the given analytical solution with a numerical approximation of the original ODE and performs some balance-related tests (`sm` stands for the maximum groundwater amount and `g1` and `g2` for |GSBGrad1| and |GSBGrad2|):\\ >>> from numpy import exp >>> from scipy.integrate import ode >>> def check(sm, g1, g2): ... # update the parameters: ... volbmax(sm) ... gsbgrad1.value = g1 ... gsbgrad2.value = g2 ... # reset the fluxes (eventually changed by previous calls): ... fluxes.qbgz = 2.0 ... fluxes.qdgz = 1.0 ... # apply a numerical solver: ... integrator = ode(f_ode) ... _ = integrator.set_integrator("zvode", method="bdf", rtol=1e-10) ... _ = integrator.set_initial_value([min(states.sbg.old, sm), 0.0]) ... sbg_est, qbga_est = integrator.integrate(1.0).real ... qbga_est += max(states.sbg.old - sm, 0.0) ... # calculate the analytical solution: ... model.calc_qbga_sbg_qbgz_qdgz_v1() ... # compare the analytical with the numerical solution: ... assert round(states.sbg.new, 6) == round(sbg_est, 6) ... assert round(fluxes.qbga, 6) == round(qbga_est, 6) ... # check water balances: ... assert states.sbg.new == states.sbg.old + fluxes.qbgz - fluxes.qbga ... assert 2.0 + 1.0 == fluxes.qbgz + fluxes.qdgz ... # print the resulting values of all modified sequences: ... print(states.sbg, fluxes.qbga, fluxes.qbgz, fluxes.qdgz, sep=", ")\\ Function `check` requires a function that implements the given ODE. We define function `f_ode` for this purpose, which needs lot of special casing. It returns the current groundwater change (inflow minus outflow) and the outflow itself. Note that handling :math:`k = \infty` is highly ad hoc and only thought to work for the following tests:\\ >>> def f_ode(t, x): ... k = derived.kb.value ... z = fluxes.qbgz.value ... sm = control.gsbmax.value * control.volbmax.value ... g1 = control.gsbgrad1.value ... g2 = control.gsbgrad2.value ... s = x[0] ... if s <= 0.0: ... ds = 0.0 ... elif s >= sm: ... ds = 0.0 ... elif k == 0.0: ... ds = -5e3 ... elif z - s / k <= g1: ... ds = z - s / k ... elif g1 == g2: ... ds = g1 ... elif numpy.isinf(k): ... ds = g2 / ((g2 - g1) / z + 1.0) ... else: ... ds = (g2 * (s - k * z) - g1 * s) / (k * (g1 - g2 - z)) ... if s <= 0.0: ... return [[ds, 0.0]] ... elif k == 0.0: ... return [[ds, 7e3]] ... return [[ds, s / k]]\\ We start by demonstrating pure volume-related restrictions. Therefore, we set |GSBMax| to one so that values for `sm` correspond to the highest possible groundwater amount:\\ >>> gsbmax(1.0)\\ If `sm` is higher than the final groundwater amount, applying |Calc_QBGA_SBG_QBGZ_QDGZ_V1| leads to the same results as |Calc_QBGA_SBG_V1|:\\ >>> check(sm=10.0, g1=1.5, g2=2.0) sbg(6.427439), qbga(0.572561), qbgz(2.0), qdgz(1.0)\\ An active volume-related restriction decreases the groundwater inflow (which reduces base flow) and increases the amount of direct runoff:\\ >>> check(sm=6.0, g1=1.5, g2=2.0) sbg(6.0), qbga(0.5659), qbgz(1.5659), qdgz(1.4341)\\ Starting with an already activated volume-related restriction works as expected:\\ >>> check(sm=5.0, g1=1.5, g2=2.0) sbg(5.0), qbga(0.5), qbgz(0.5), qdgz(2.5)\\ |Calc_QBGA_SBG_QBGZ_QDGZ_V1| handles possible initial violations of volume-related restrictions by adding the excess to base flow:\\ >>> check(sm=4.0, g1=1.5, g2=2.0) sbg(4.0), qbga(1.4), qbgz(0.4), qdgz(2.6)\\ Setting |KB| to |numpy.inf| works (in case someone will ever need it):\\ >>> derived.kb(inf) >>> check(sm=10.0, g1=inf, g2=inf) sbg(7.0), qbga(0.0), qbgz(2.0), qdgz(1.0) >>> check(sm=6.0, g1=inf, g2=inf) sbg(6.0), qbga(0.0), qbgz(1.0), qdgz(2.0) >>> check(sm=5.0, g1=inf, g2=inf) sbg(5.0), qbga(0.0), qbgz(0.0), qdgz(3.0) >>> check(sm=4.0, g1=inf, g2=inf) sbg(4.0), qbga(1.0), qbgz(0.0), qdgz(3.0)\\ Next, we demonstrate pure rise-related restrictions.\\ If |GSBGrad1| (and subsequently |GSBGrad2|) is not smaller than the initial groundwater rise, |Calc_QBGA_SBG_QBGZ_QDGZ_V1| calculates the same results as |Calc_QBGA_SBG_V1|:\\ >>> derived.kb(10.0) >>> check(sm=10.0, g1=1.5, g2=2.0) sbg(6.427439), qbga(0.572561), qbgz(2.0), qdgz(1.0) >>> check(sm=inf, g1=1.5, g2=2.0) sbg(6.427439), qbga(0.572561), qbgz(2.0), qdgz(1.0)\\ The following examples deal with a situation where (only) |GSBGrad1| is smaller than the groundwater rise at the interval's start and end time:\\ >>> check(sm=10.0, g1=1.0, g2=2.0) sbg(6.147436), qbga(0.557691), qbgz(1.705127), qdgz(1.294873) >>> check(sm=inf, g1=1.0, g2=2.0) sbg(6.147436), qbga(0.557691), qbgz(1.705127), qdgz(1.294873) >>> check(sm=5.0, g1=1.0, g2=2.0) sbg(5.0), qbga(0.5), qbgz(0.5), qdgz(2.5) >>> check(sm=4.0, g1=1.0, g2=2.0) sbg(4.0), qbga(1.4), qbgz(0.4), qdgz(2.6)\\ Now, both |GSBGrad1| and |GSBGrad2| are smaller than the groundwater rise at the interval's start and end time:\\ >>> check(sm=10.0, g1=0.5, g2=1.0) sbg(5.693046), qbga(0.534768), qbgz(1.227814), qdgz(1.772186) >>> check(sm=inf, g1=0.5, g2=1.0) sbg(5.693046), qbga(0.534768), qbgz(1.227814), qdgz(1.772186) >>> check(sm=5.0, g1=0.5, g2=1.0) sbg(5.0), qbga(0.5), qbgz(0.5), qdgz(2.5) >>> check(sm=4.0, g1=0.5, g2=1.0) sbg(4.0), qbga(1.4), qbgz(0.4), qdgz(2.6)\\ It is acceptable to set |GSBGrad1| to zero:\\ >>> check(sm=10.0, g1=0.0, g2=1.0) sbg(5.491758), qbga(0.524725), qbgz(1.016483), qdgz(1.983517) >>> derived.kb(0.0) >>> check(sm=10.0, g1=0.0, g2=0.0) sbg(0.0), qbga(7.0), qbgz(2.0), qdgz(1.0)\\ The same holds for setting both |GSBGrad1| and |GSBGrad2| to zero:\\ >>> derived.kb(10.0) >>> check(sm=10.0, g1=0.0, g2=0.0) sbg(5.0), qbga(0.5), qbgz(0.5), qdgz(2.5)\\ Also, it is okay to set |GSBGrad1| and |GSBGrad2| to the same non-zero value:\\ >>> check(sm=10.0, g1=1.0, g2=1.0) sbg(6.0), qbga(0.55), qbgz(1.55), qdgz(1.45) >>> check(sm=10.0, g1=1.4, g2=1.4) sbg(6.39434), qbga(0.569946), qbgz(1.964286), qdgz(1.035714)\\ As for the volume-related case, one can apply rise-related restrictions when the value of |KB| is |numpy.inf|:\\ >>> derived.kb(inf) >>> check(sm=10.0, g1=0.0, g2=0.0) sbg(5.0), qbga(0.0), qbgz(0.0), qdgz(3.0) >>> check(sm=10.0, g1=1.0, g2=1.0) sbg(6.0), qbga(0.0), qbgz(1.0), qdgz(2.0) >>> check(sm=10.0, g1=0.0, g2=2.0) sbg(6.0), qbga(0.0), qbgz(1.0), qdgz(2.0) >>> check(sm=10.0, g1=1.0, g2=2.0) sbg(6.333333), qbga(0.0), qbgz(1.333333), qdgz(1.666667)\\ Finally, we demonstrate combinations of volume- and rise-related restrictions.\\ In the first combinational example, the rise-related restriction is active right from the start. After a while, the groundwater amount reaches its highest possible value (5.8 mm). From then on, the groundwater table is not allowed to rise anymore, which deactivates the rise-related restriction:\\ >>> derived.kb(10.0) >>> check(sm=5.8, g1=1.4, g2=1.4) sbg(5.8), qbga(0.557143), qbgz(1.357143), qdgz(1.642857)\\ The second combinational example is even more complex. The groundwater rise slows down until it does not exceed `g1` anymore. Then, no restriction is active anymore, and the evolution of |SGD| follows the simple linear storage model. However, this happens only for a short while due to |SGD| reaching `sm` soon afterwards:\\ >>> check(sm=6.2, g1=1.4, g2=1.4) sbg(6.2), qbga(0.568565), qbgz(1.768565), qdgz(1.231435)\end{aligned}\end{align} \]

class hydpy.models.lland.lland_model.Calc_QIGA1_SIG1_V1

Bases: Method

Update the storage of the first interflow component and calculate its outflow.

Requires the derived parameter:

KI1

Requires the flux sequence:

QIGZ1

Updates the state sequence:

SIG1

Calculates the flux sequence:

QIGA1

Basic equations:

\(SIG1 = Return\_SG\_V1(KI1, SIG1, QIGZ1)\)

\(QIGA1 = SIG1_{old} - SIG1_{new} + QIGZ1\)

Example:

Method Calc_QIGA1_SIG1_V1 relies on the analytical solution of the linear storage equation implemented by method Return_SG_V1, from which we take the following test configuration:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> derived.ki1(3.0)
>>> states.sig1.old = 1.0
>>> fluxes.qigz1 = 2.0
>>> model.calc_qiga1_sig1_v1()
>>> states.sig1
sig1(2.417343)
>>> fluxes.qiga1
qiga1(0.582657)

class hydpy.models.lland.lland_model.Calc_QIGA2_SIG2_V1

Bases: Method

Update the storage of the second interflow component and calculate its outflow.

Requires the derived parameter:

KI2

Requires the flux sequence:

QIGZ2

Updates the state sequence:

SIG2

Calculates the flux sequence:

QIGA2

Basic equations:

\(SIG2 = Return\_SG\_V2(KI2, SIG2, QIGZ2)\)

\(QIGA2 = SIG2_{old} - SIG2_{new} + QIGZ2\)

Example:

Method Calc_QIGA2_SIG2_V1 relies on the analytical solution of the linear storage equation implemented by method Return_SG_V1, from which we take the following test configuration:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> derived.ki2(3.0)
>>> states.sig2.old = 1.0
>>> fluxes.qigz2 = 2.0
>>> model.calc_qiga2_sig2_v1()
>>> states.sig2
sig2(2.417343)
>>> fluxes.qiga2
qiga2(0.582657)

class hydpy.models.lland.lland_model.Calc_QDGA1_SDG1_V1

Bases: Method

Update the storage of the slow direct runoff component and calculate its outflow.

Requires the derived parameter:

KD1

Requires the flux sequence:

QDGZ1

Updates the state sequence:

SDG1

Calculates the flux sequence:

QDGA1

Basic equations:

\(QBDA1 = Return\_SG\_V1(KD1, SDG1, QDGZ1)\)

\(QDGA1 = SDG1_{old} - SDG1_{new} + QDGZ1\)

Example:

Method Calc_QDGA1_SDG1_V1 relies on the analytical solution of the linear storage equation implemented by method Return_SG_V1, from which we take the following test configuration:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> derived.kd1(3.0)
>>> states.sdg1.old = 1.0
>>> fluxes.qdgz1 = 2.0
>>> model.calc_qdga1_sdg1_v1()
>>> states.sdg1
sdg1(2.417343)
>>> fluxes.qdga1
qdga1(0.582657)

class hydpy.models.lland.lland_model.Calc_QDGA2_SDG2_V1

Bases: Method

Update the storage of the fast direct runoff component and calculate its outflow.

Requires the derived parameter:

KD2

Requires the flux sequence:

QDGZ2

Updates the state sequence:

SDG2

Calculates the flux sequence:

QDGA2

Basic equations:

\(QBDA2 = Return\_SG\_V1(KD2, SDG2, QDGZ2)\)

\(QDGA2 = SDG2_{old} - SDG2_{new} + QDGZ2\)

Example:

Method Calc_QDGA2_SDG2_V1 relies on the analytical solution of the linear storage equation implemented by method Return_SG_V1, from which we take the following test configuration:

>>> from hydpy.models.lland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> derived.kd2(3.0)
>>> states.sdg2.old = 1.0
>>> fluxes.qdgz2 = 2.0
>>> model.calc_qdga2_sdg2_v1()
>>> states.sdg2
sdg2(2.417343)
>>> fluxes.qdga2
qdga2(0.582657)

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:

QBGA QIGA1 QIGA2 QDGA1 QDGA2 NKor QZH

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 EvI 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)
>>> fluxes.qbga = 0.1
>>> fluxes.qiga1 = 0.2
>>> fluxes.qiga2 = 0.3
>>> fluxes.qdga1 = 0.4
>>> fluxes.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)
>>> fluxes.qbga = -1.0
>>> fluxes.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 sequence EvI for 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.Get_Temperature_V1

Bases: Method

Get the selected zone’s current temperature.

Requires the flux sequence:

TKor

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(2)
>>> fluxes.tkor = 2.0, 4.0
>>> model.get_temperature_v1(0)
2.0
>>> model.get_temperature_v1(1)
4.0

class hydpy.models.lland.lland_model.Get_MeanTemperature_V1

Bases: Method

Get the basin’s current mean temperature.

Requires the input sequence:

TemL

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> inputs.teml = 2.0
>>> from hydpy import round_
>>> round_(model.get_meantemperature_v1())
2.0

class hydpy.models.lland.lland_model.Get_Precipitation_V1

Bases: Method

Get the current precipitation from the selected hydrological response unit.

Requires the flux sequence:

NKor

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(2)
>>> fluxes.nkor = 2.0, 4.0
>>> model.get_precipitation_v1(0)
2.0
>>> model.get_precipitation_v1(1)
4.0

class hydpy.models.lland.lland_model.Get_InterceptedWater_V1

Bases: Method

Get the selected response unit’s current amount of intercepted water.

Requires the state sequence:

Inzp

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(2)
>>> states.inzp = 2.0, 4.0
>>> model.get_interceptedwater_v1(0)
2.0
>>> model.get_interceptedwater_v1(1)
4.0

class hydpy.models.lland.lland_model.Get_SoilWater_V1

Bases: Method

Get the selected response unit’s current soil water content.

Requires the state sequence:

BoWa

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(2)
>>> states.bowa = 2.0, 4.0
>>> model.get_soilwater_v1(0)
2.0
>>> model.get_soilwater_v1(1)
4.0

class hydpy.models.lland.lland_model.Get_SnowCover_V1

Bases: Method

Get the selected response unit’s current snow cover degree.

Requires the state sequence:

WATS

Example:

Each response unit with a non-zero amount of snow counts as completely covered:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(2)
>>> states.wats = 0.0, 2.0
>>> model.get_snowcover_v1(0)
0.0
>>> model.get_snowcover_v1(1)
1.0

class hydpy.models.lland.lland_model.Get_SnowyCanopy_V1

Bases: Method

Get the selected response unit’s current snow cover degree in the canopies of tree-like vegetation (or nan if the zone’s vegetation is not tree-like).

Requires the control parameter:

Lnk

Requires the state sequence:

STInz

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(4)
>>> lnk(LAUBW, MISCHW, NADELW, ACKER)
>>> states.stinz = 0.0
>>> from hydpy import print_values
>>> print_values(model.get_snowycanopy_v1(i) for i in range(4))
0.0, 0.0, 0.0, nan
>>> states.stinz = 0.1
>>> print_values(model.get_snowycanopy_v1(i) for i in range(4))
1.0, 1.0, 1.0, nan

class hydpy.models.lland.lland_model.Get_SnowAlbedo_V1

Bases: Method

Get the selected response unit’s current albedo as a fraction.

Requires the flux sequence:

ActualAlbedo

Example:

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(2)
>>> fluxes.actualalbedo = 2.0, 4.0
>>> model.get_snowalbedo_v1(0)
2.0
>>> model.get_snowalbedo_v1(1)
4.0

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: ClassVar[str] = '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: ClassVar[str] = '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: ClassVar[str] = 'pegasustempssurface'

class hydpy.models.lland.lland_model.Main_RadiationModel_V1

Bases: AdHocModel

Base class for HydPy-L models that support submodels that comply with the RadiationModel_V1 interface.

radiationmodel: SubmodelProperty

radiationmodel_is_mainmodel

radiationmodel_typeid

add_radiationmodel_v1

Add the given radiation model that follows the RadiationModel_V1 interface.

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> from hydpy.models.lland_v3 import *
>>> parameterstep()
>>> with model.add_radiationmodel_v1("meteo_v004"):
...     latitude(50.0)
>>> model.radiationmodel.parameters.control.latitude
latitude(50.0)

REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()

class hydpy.models.lland.lland_model.Main_RadiationModel_V4

Bases: AdHocModel

Base class for HydPy-Evap models that support submodels that comply with the RadiationModel_V4 interface.

radiationmodel: SubmodelProperty

radiationmodel_is_mainmodel

radiationmodel_typeid

add_radiationmodel_v4

Add the given radiation model that follows the RadiationModel_V4 interface.

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> from hydpy.models.lland_v3 import *
>>> parameterstep()
>>> with model.add_radiationmodel_v4("meteo_psun_sun_glob_io"):
...     inputs.globalradiation = 100.0
>>> model.radiationmodel.sequences.inputs.globalradiation
globalradiation(100.0)

REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()

class hydpy.models.lland.lland_model.Main_AETModel_V1A

Bases: _Main_AETModel_V1

Base class for HydPy-L models that support submodels that comply with the AETModel_V1 interface and cannot provide information on the measuring height of wind speed.

add_aetmodel_v1

Initialise the given submodel that follows the AETModel_V1 interface and is responsible for calculating the different kinds of actual evapotranspiration.

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2001-01-01", "1d"
>>> from hydpy.models.lland_v1 import *
>>> parameterstep()
>>> nhru(9)
>>> ft(10.0)
>>> fhru(0.07, 0.08, 0.09, 0.1, 0.11, 0.12, 0.13, 0.14, 0.16)
>>> lnk(ACKER, LAUBW, NADELW, VERS, WASSER, FLUSS, SEE, BODEN, GLETS)
>>> lai(1.0)
>>> lai.acker_jan = 2.0
>>> lai.laubw_dec = 3.0
>>> wmax(50.0)
>>> with model.add_aetmodel_v1("evap_morsim"):
...     nmbhru
...     hrutype
...     water
...     interception
...     soil
...     tree
...     conifer
...     maxsoilwater
...     soilmoisturelimit(acker=0.7, laubw=0.8, nadelw=0.9, boden=1.0, glets=1.1)
...     my_lai = leafareaindex
...     "my_lai", my_lai.nadelw_jun, my_lai.acker_jan, my_lai.laubw_dec
...     for method, arguments in model.preparemethod2arguments.items():
...         print(method, arguments[0][0], sep=": ")  
nmbhru(9)
hrutype(ACKER, LAUBW, NADELW, VERS, WASSER, FLUSS, SEE, BODEN, GLETS)
water(acker=False, boden=False, fluss=True, glets=False, laubw=False,
      nadelw=False, see=True, vers=False, wasser=True)
interception(acker=True, boden=True, fluss=False, glets=True,
             laubw=True, nadelw=True, see=False, vers=True,
             wasser=False)
soil(acker=True, boden=True, fluss=False, glets=True, laubw=True,
     nadelw=True, see=False, vers=False, wasser=False)
tree(acker=False, boden=False, fluss=False, glets=False, laubw=True,
     nadelw=True, see=False, vers=False, wasser=False)
conifer(acker=False, boden=False, fluss=False, glets=False,
        laubw=False, nadelw=True, see=False, vers=False, wasser=False)
maxsoilwater(50.0)
('my_lai', 1.0, 2.0, 3.0)
prepare_nmbzones: 9
prepare_zonetypes: [ 4 14 13  3 16 17 18  7  8]
prepare_subareas: [0.7 0.8 0.9 1.  1.1 1.2 1.3 1.4 1.6]
prepare_leafareaindex: [[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
...
prepare_maxsoilwater: [50. 50. 50. 50. 50. 50. 50. 50. 50.]
prepare_water: [False False False  True  True  True  True  True  True]
prepare_interception: [ True  True  True  True False False False  True  True]
prepare_soil: [ True  True  True False False False False  True  True]
prepare_plant: [ True  True  True False False False False False False]
prepare_conifer: [False  True  True False False False False False False]
prepare_tree: [False  True  True False False False False False False]

>>> model.aetmodel.parameters.control.leafareaindex.acker_jan
2.0

>>> sml = model.aetmodel.parameters.control.soilmoisturelimit
>>> sml
soilmoisturelimit(acker=0.7, boden=1.0, glets=1.0, laubw=0.8,
                  nadelw=0.9)
>>> lnk(NADELW, LAUBW, ACKER, VERS, WASSER, FLUSS, SEE, BODEN, GLETS)
>>> sml
soilmoisturelimit(acker=0.9, boden=1.0, glets=1.0, laubw=0.8,
                  nadelw=0.7)
>>> from hydpy import round_
>>> round_(sml.average_values())
0.914815

REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()

class hydpy.models.lland.lland_model.Main_AETModel_V1B

Bases: _Main_AETModel_V1

Base class for HydPy-L models that support submodels that comply with the AETModel_V1 interface and can provide information on the measuring height of wind speed.

add_aetmodel_v1

Initialise the given submodel that follows the AETModel_V1 interface and is responsible for calculating the different kinds of actual evapotranspiration.

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2001-01-01", "1d"
>>> from hydpy.models.lland_v3 import *
>>> parameterstep()
>>> nhru(2)
>>> ft(10.0)
>>> fhru(0.5, 0.5)
>>> lnk(ACKER, LAUBW)
>>> measuringheightwindspeed(10.0)
>>> lai(1.0)
>>> wmax(50.0)
>>> with model.add_aetmodel_v1("evap_morsim"):
...     nmbhru
...     hrutype
...     measuringheightwindspeed
nmbhru(2)
hrutype(ACKER, LAUBW)
measuringheightwindspeed(10.0)

REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()

class hydpy.models.lland.lland_model.Main_SoilModel_V1

Bases: AdHocModel

Base class for HydPy-L models that support submodels that comply with the SoilModel_V1 interface.

soilmodel: SubmodelProperty

soilmodel_is_mainmodel

soilmodel_typeid

add_soilmodel_v1

Initialise the given soil model that follows the SoilModel_V1 interface.

>>> from hydpy.models.lland_v1 import *
>>> parameterstep()
>>> nhru(2)
>>> ft(10.0)
>>> fhru(0.2, 0.8)
>>> with model.add_soilmodel_v1("ga_garto_submodel1", update=False):
...     nmbsoils
nmbsoils(2)
>>> model.soilmodel.parameters.control.nmbsoils
nmbsoils(2)

REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()

class hydpy.models.lland.lland_model.Sub_TempModel_V1

Bases: AdHocModel, TempModel_V1

Base class for HydPy-L models that comply with the TempModel_V1 submodel interface.

REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()

class hydpy.models.lland.lland_model.Sub_PrecipModel_V1

Bases: AdHocModel, PrecipModel_V1

Base class for HydPy-L models that comply with the PrecipModel_V1 submodel interface.

REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()

class hydpy.models.lland.lland_model.Sub_IntercModel_V1

Bases: AdHocModel, IntercModel_V1

Base class for HydPy-L models that comply with the IntercModel_V1 submodel interface.

REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()

class hydpy.models.lland.lland_model.Sub_SoilWaterModel_V1

Bases: AdHocModel, SoilWaterModel_V1

Base class for HydPy-L models that comply with the SoilWaterModel_V1 submodel interface.

REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()

class hydpy.models.lland.lland_model.Sub_SnowCoverModel_V1

Bases: AdHocModel, SnowCoverModel_V1

Base class for HydPy-L models that comply with the SnowCoverModel_V1 submodel interface.

REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()

class hydpy.models.lland.lland_model.Sub_SnowyCanopyModel_V1

Bases: AdHocModel, SnowyCanopyModel_V1

Base class for HydPy-L models that comply with the SnowyCanopyModel_V1 submodel interface.

REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()

class hydpy.models.lland.lland_model.Sub_SnowAlbedoModel_V1

Bases: AdHocModel, SnowAlbedoModel_V1

Base class for HydPy-L models that comply with the SnowAlbedoModel_V1 submodel interface.

REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()

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

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}

Mapping of the constants’ names and values.

mask: masktools.IndexMask

property refweights

Alias for the associated instance of FHRU for calculating areal mean values.

name: str = 'parametercomplete'

Name of the variable in lowercase 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: masktools.IndexMask

name: str = 'parameterland'

Name of the variable in lowercase 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: masktools.IndexMask

name: str = 'parametersoil'

Name of the variable in lowercase 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 lowercase 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.

columnnames: tuple[str, ...] = ('jan', 'feb', 'mar', 'apr', 'mai', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec')

rownames: 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 lowercase letters.

unit: str = '?'

Unit of the variable.

Constants

The HydPy-L-Land model (lland) allows for the subdivision of subbasins into hydrological response units. Some processes, e.g. interception, are calculated separately for each response unit. This is why some parameters (e.g. the field capacity FK) 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, HydPy-L-Land allows for arbitrary response unit definitions. Nevertheless, the original distinction in accordance with sixteen different landuse types is still supported. The parameter Lnk defines which entry of e.g. parameter FK is related to which land use type via integer values. Note that for the response units of the most land types, the same equations are applied. Only units of type VERS, WASSER, FLUSS, SEE, and NADELW are partly connected to different process equations.

For comprehensibility, this module introduces the relevant integer constants. After 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) [-].

• KG() Niederschlagskorrekturfaktor (adjustment factor for precipitation) [-].

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

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

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

• 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²].

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

• 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 (highest possible base flow storage) [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 baseflow storage increase without inflow reductions) [mm/T].

• GSBGrad2() Volumenzunahme des Gebietsspeichers für Basisabfluss, oberhalb der jeglicher Zufluss ausgeschlossen ist (highest possible baseflow storage increase) [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 whether 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 lowercase 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_ActualVapourPressure_V1 Calc_BoWa_Default_V1 Calc_BoWa_SoilModel_V1 Calc_BoWa_V1 Calc_EvB_AETModel_V1 Calc_EvB_V1 Calc_EvI_Inzp_AETModel_V1 Calc_EvI_Inzp_V1 Calc_EvSInz_SInz_STInz_V1 Calc_EvS_WAeS_WATS_V1 Calc_FVG_V1 Calc_GefrInz_STInz_V1 Calc_GefrPotInz_V1 Calc_GefrPot_V1 Calc_Gefr_WATS_V1 Calc_NBesInz_V1 Calc_NBes_Inzp_V1 Calc_NKor_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_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_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_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. 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,)
>>> 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 lowercase 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_BoWa_Default_V1 Calc_BoWa_SoilModel_V1 Calc_BoWa_V1 Calc_EvB_AETModel_V1 Calc_EvB_V1 Calc_EvI_Inzp_AETModel_V1 Calc_EvI_Inzp_V1 Calc_EvSInz_SInz_STInz_V1 Calc_EvS_WAeS_WATS_V1 Calc_FVG_V1 Calc_GefrInz_STInz_V1 Calc_Gefr_WATS_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_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 Get_SnowyCanopy_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_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)

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 lowercase 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 lowercase letters.

unit: str = '-'

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 lowercase 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 method:

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 lowercase letters.

unit: str = '°C'

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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase letters.

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

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

Calc_WindSpeed2m_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 lowercase 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 lowercase 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 lowercase 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_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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 method:

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 lowercase letters.

unit: str = 'W/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_Default_V1 Calc_BoWa_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) → bool

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
>>> assert wmax.trim() is True
>>> wmax
wmax(60.0, 60.0, 90.0)

name: str = 'wmax'

Name of the variable in lowercase 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) → bool

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

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) → bool

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
>>> assert pwp.trim() is True
>>> pwp
pwp(0.0, 50.0, 80.0)

name: str = 'pwp'

Name of the variable in lowercase 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 lowercase 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 lowercase 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 lowercase 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) → bool

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 lowercase 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) → bool

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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 FK, 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 lowercase 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 lowercase 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 (highest possible base flow storage) [mm].

Required by the method:

Calc_QBGA_SBG_QBGZ_QDGZ_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 = inf

name: str = 'volbmax'

Name of the variable in lowercase 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) [-].

Required by the method:

Calc_QBGA_SBG_QBGZ_QDGZ_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.0

name: str = 'gsbmax'

Name of the variable in lowercase 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 baseflow storage increase without inflow reductions) [mm/T].

Required by the method:

Calc_QBGA_SBG_QBGZ_QDGZ_V1

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) → bool

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 lowercase 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 baseflow storage increase) [mm/T].

Required by the method:

Calc_QBGA_SBG_QBGZ_QDGZ_V1

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) → bool

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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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) → bool

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 lowercase 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) → bool

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 lowercase 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) → bool

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 lowercase 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) → bool

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 lowercase 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 whether 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 lowercase 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].

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

• KB() Konzentrationszeit des Basisabflusses (concentration time of the baseflow storage) [T].

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

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

• KD1() Konzentrationszeit des “langsamen” Direktabflusses (concentration time of the slow direct runoff storage) [T].

• KD2() Konzentrationszeit des “schnellen” Direktabflusses (concentration time of the fast direct runoff storage) [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_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 lowercase 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:

Update_ASInz_V1 Update_TauS_V1

name: str = 'seconds'

Name of the variable in lowercase 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].

name: str = 'hours'

Name of the variable in lowercase 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].

name: str = 'days'

Name of the variable in lowercase 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_DailyPossibleSunshineDuration_V1 Calc_DailySunshineDuration_V1 Update_LoggedPossibleSunshineDuration_V1 Update_LoggedSunshineDuration_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 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
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)

To prevent from loosing information, updating parameter NmbLogEntries resets the shape of the relevant log sequences only when necessary:

>>> logs.loggedsunshineduration = 2.0
>>> logs.loggedpossiblesunshineduration.shape = (6,)
>>> logs.loggedpossiblesunshineduration = 3.0
>>> derived.nmblogentries.update()
>>> logs   
loggedsunshineduration(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)
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)

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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase letters.

unit: str = '-'

Unit of the variable.

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

Bases: Parameter

Konzentrationszeit des Basisabflusses (concentration time of the baseflow storage) [T].

Required by the methods:

Calc_QBGA_SBG_QBGZ_QDGZ_V1 Calc_QBGA_SBG_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 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 lowercase 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 storage) [T].

Required by the method:

Calc_QIGA1_SIG1_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 lowercase 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 storage) [T].

Required by the method:

Calc_QIGA2_SIG2_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 lowercase 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 slow direct runoff storage) [T].

Required by the method:

Calc_QDGA1_SDG1_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 lowercase 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 fast direct runoff storage) [T].

Required by the method:

Calc_QDGA2_SDG2_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 lowercase letters.

unit: str = '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 lowercase 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].

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

• 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 = 0.04845833333333333

name: str = 'cpwasser'

Name of the variable in lowercase 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 = 0.024189814814814813

name: str = 'cpeis'

Name of the variable in lowercase 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 = 3.865740740740741

name: str = 'rschmelz'

Name of the variable in lowercase 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 = 3.141592653589793

name: str = 'pi'

Name of the variable in lowercase 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 = 0.1

name: str = 'z'

Name of the variable in lowercase 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 = 80.0

name: str = 'bowa2z'

Name of the variable in lowercase 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 = 0.6

name: str = 'lambdag'

Name of the variable in lowercase 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_RLAtm_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 = 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 = 5.67e-08

name: str = 'sigma'

Name of the variable in lowercase letters.

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

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 = 30.87326388888889

name: str = 'lwe'

Name of the variable in lowercase letters.

unit: str = 'WT/kg'

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 = 1.76

name: str = 'psyinv'

Name of the variable in lowercase 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 method:

Calc_WindSpeed2m_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 = 0.003

name: str = 'z0'

Name of the variable in lowercase 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 method:

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 = 1.28

name: str = 'fratm'

Name of the variable in lowercase 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 = 17.36111111111111

name: str = 'cg'

Name of the variable in lowercase 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 lowercase 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 lowercase 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].

• RelativeHumidity() Relative humidity [%].

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

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

STANDARD_NAME: ClassVar[StandardInputNames] = 'precipitation'

name: str = 'nied'

Name of the variable in lowercase 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 Get_MeanTemperature_V1

NDIM: int = 0

NUMERIC: bool = False

STANDARD_NAME: ClassVar[StandardInputNames] = 'air_temperature'

name: str = 'teml'

Name of the variable in lowercase letters.

unit: str = '°C'

Unit of the variable.

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

Bases: InputSequence

Relative humidity [%].

Required by the method:

Calc_ActualVapourPressure_V1

NDIM: int = 0

NUMERIC: bool = False

STANDARD_NAME: ClassVar[StandardInputNames] = 'relative_humidity'

name: str = 'relativehumidity'

Name of the variable in lowercase 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 method:

Calc_WindSpeed2m_V1

NDIM: int = 0

NUMERIC: bool = False

STANDARD_NAME: ClassVar[StandardInputNames] = 'wind_speed'

name: str = 'windspeed'

Name of the variable in lowercase letters.

unit: str = 'm/s'

Unit of the variable.

Factor sequences

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

Bases: FactorSequences

Factor sequences of model lland.

The following classes are selected:

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

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

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

Bases: FactorSequence

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

Calculated by the method:

Calc_PossibleSunshineDuration_V1

Required by the method:

Update_LoggedPossibleSunshineDuration_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'possiblesunshineduration'

Name of the variable in lowercase letters.

unit: str = 'h'

Unit of the variable.

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

Bases: FactorSequence

Sonnenscheindauer (sunshine duration) [h].

Calculated by the method:

Calc_SunshineDuration_V1

Required by the method:

Update_LoggedSunshineDuration_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'sunshineduration'

Name of the variable in lowercase letters.

unit: str = 'h'

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

• DailySunshineDuration() Daily sunshine duration [h].

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

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

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

• TKor() Korrigierte Lufttemperatur (corrected air temperature) [°C].

• WindSpeed2m() Wind speed at a height of 2 m above the ground for grass [m/s].

• ReducedWindSpeed2m() Land-use-specific wind speed at a height of 2 m above the ground [m/s].

• SaturationVapourPressure() Saturation 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].

• ActualVapourPressure() Actual vapour pressure [hPa].

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

• WG() “Dynamischer” Bodenwärmestrom (“dynamic” soil heat flux) [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²].

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

• NetLongwaveRadiationSnow() Net longwave radiation for snow-surfaces [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²].

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

• EvI() Tatsächliche Verdunstung von Interzeptions- und permanenten Wasserflächen (actual evaporation from interception storages and water areas) [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 to both direct runoff storages) [mm/T].

• QDGZ1() Zufluss in den trägeren Direktabfluss-Gebietsspeicher (inflow to the slow direct runoff storage) [mm/T].

• QDGZ2() Zufluss in den dynamischeren Direktabfluss-Gebietsspeicher (inflow to the fast direct runoff storage) [mm/T].

• QIGZ1() “Zufluss in den ersten Zwischenabfluss-Gebietsspeicher (inflow to the first interflow storage) [mm/T].

• QIGZ2() Zufluss in den zweiten Zwischenabfluss-Gebietsspeicher (inflow to the second interflow storage) [mm/T].

• QBGZ() Zufluss in den Basisabfluss-Gebietsspeicher (inflow to the base flow storage) [mm/T].

• QDGA1() Abfluss aus dem trägeren Direktabfluss-Gebietsspeicher (outflow from the slow direct runoff storage) [mm/T].

• QDGA2() Abfluss aus dem dynamischeren Direktabfluss-Gebietsspeicher (outflow from the fast direct runoff storage) [mm/T].

• QIGA1() Abfluss aus dem “unteren” Zwischenabfluss-Gebietsspeicher (outflow from the first interflow storage) [mm/T].

• QIGA2() Abfluss aus dem “oberen” Zwischenabfluss-Gebietsspeicher (outflow from the second interflow storage) [mm/T].

• QBGA() Abfluss aus dem Basisabfluss-Gebietsspeicher (outflow from the base flow storage) [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 lowercase 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 lowercase letters.

unit: str = 'mm/T'

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

Calc_RLAtm_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'dailysunshineduration'

Name of the variable in lowercase 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 method:

Calc_RLAtm_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'dailypossiblesunshineduration'

Name of the variable in lowercase letters.

unit: str = 'h'

Unit of the variable.

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

Bases: FluxSequence

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

Calculated by the method:

Calc_GlobalRadiation_V1

Required by the methods:

Calc_NetShortwaveRadiationInz_V1 Calc_NetShortwaveRadiationSnow_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'globalradiation'

Name of the variable in lowercase letters.

unit: str = 'W/m²'

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 Get_Precipitation_V1

NDIM: int = 1

NUMERIC: bool = False

mask

name: str = 'nkor'

Name of the variable in lowercase 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_RLAtm_V1 Calc_SNRatio_V1 Calc_SaturationVapourPressure_V1 Calc_SnowIntMax_V1 Calc_WGTF_V1 Calc_WG_V1 Calc_WNiedInz_ESnowInz_V1 Calc_WNied_ESnow_V1 Calc_WNied_V1 Get_Temperature_V1 Return_BackwardEulerErrorInz_V1 Return_BackwardEulerError_V1 Return_EnergyGainSnowSurface_V1 Return_NetLongwaveRadiationSnow_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 lowercase 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 method:

Calc_ReducedWindSpeed2m_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'windspeed2m'

Name of the variable in lowercase 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 lowercase 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 method:

Calc_ActualVapourPressure_V1

NDIM: int = 1

NUMERIC: bool = False

mask

name: str = 'saturationvapourpressure'

Name of the variable in lowercase 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 lowercase 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 lowercase 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].

NDIM: int = 1

NUMERIC: bool = False

mask

name: str = 'saturationvapourpressureslope'

Name of the variable in lowercase 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_RLAtm_V1 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 = 1

NUMERIC: bool = False

mask

name: str = 'actualvapourpressure'

Name of the variable in lowercase letters.

unit: str = 'hPa'

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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase letters.

unit: str = 'W/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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

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

Bases: Flux1DSequence

Tatsächliche Verdunstung von Interzeptions- und permanenten Wasserflächen (actual evaporation from interception storages and water areas) [mm/T].

Calculated by the methods:

Calc_EvI_Inzp_AETModel_V1 Calc_EvI_Inzp_V1

Updated by the method:

Calc_QAH_V1

Required by the methods:

Calc_QBGZ_V1 Calc_QDGZ_V1

NDIM: int = 1

NUMERIC: bool = False

mask

name: str = 'evi'

Name of the variable in lowercase 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_AETModel_V1 Calc_EvB_V1

Updated by the methods:

Calc_BoWa_Default_V1 Calc_BoWa_SoilModel_V1 Calc_BoWa_V1

NDIM: int = 1

NUMERIC: bool = False

mask

name: str = 'evb'

Name of the variable in lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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_NetShortwaveRadiationSnow_V1 Get_SnowAlbedo_V1

NDIM: int = 1

NUMERIC: bool = False

mask

name: str = 'actualalbedo'

Name of the variable in lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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_Default_V1 Calc_BoWa_SoilModel_V1 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 lowercase 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_Default_V1 Calc_BoWa_SoilModel_V1 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 lowercase 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 methods:

Calc_BoWa_Default_V1 Calc_BoWa_SoilModel_V1 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 lowercase 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 methods:

Calc_BoWa_Default_V1 Calc_BoWa_SoilModel_V1 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 lowercase 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 methods:

Calc_BoWa_Default_V1 Calc_BoWa_SoilModel_V1 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 lowercase 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 methods:

Calc_BoWa_Default_V1 Calc_BoWa_SoilModel_V1 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 lowercase 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 to both direct runoff storages) [mm/T].

Calculated by the method:

Calc_QDGZ_V1

Updated by the method:

Calc_QBGA_SBG_QBGZ_QDGZ_V1

Required by the method:

Calc_QDGZ1_QDGZ2_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'qdgz'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

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

Bases: FluxSequence

Zufluss in den trägeren Direktabfluss-Gebietsspeicher (inflow to the slow direct runoff storage) [mm/T].

Calculated by the method:

Calc_QDGZ1_QDGZ2_V1

Required by the method:

Calc_QDGA1_SDG1_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'qdgz1'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

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

Bases: FluxSequence

Zufluss in den dynamischeren Direktabfluss-Gebietsspeicher (inflow to the fast direct runoff storage) [mm/T].

Calculated by the method:

Calc_QDGZ1_QDGZ2_V1

Required by the method:

Calc_QDGA2_SDG2_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'qdgz2'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

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

Bases: FluxSequence

“Zufluss in den ersten Zwischenabfluss-Gebietsspeicher (inflow to the first interflow storage) [mm/T].

Calculated by the method:

Calc_QIGZ1_V1

Required by the method:

Calc_QIGA1_SIG1_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'qigz1'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

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

Bases: FluxSequence

Zufluss in den zweiten Zwischenabfluss-Gebietsspeicher (inflow to the second interflow storage) [mm/T].

Calculated by the method:

Calc_QIGZ2_V1

Required by the method:

Calc_QIGA2_SIG2_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'qigz2'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

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

Bases: FluxSequence

Zufluss in den Basisabfluss-Gebietsspeicher (inflow to the base flow storage) [mm/T].

Calculated by the method:

Calc_QBGZ_V1

Updated by the method:

Calc_QBGA_SBG_QBGZ_QDGZ_V1

Required by the method:

Calc_QBGA_SBG_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'qbgz'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

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

Bases: FluxSequence

Abfluss aus dem trägeren Direktabfluss-Gebietsspeicher (outflow from the slow direct runoff storage) [mm/T].

Calculated by the method:

Calc_QDGA1_SDG1_V1

Required by the method:

Calc_QAH_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'qdga1'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

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

Bases: FluxSequence

Abfluss aus dem dynamischeren Direktabfluss-Gebietsspeicher (outflow from the fast direct runoff storage) [mm/T].

Calculated by the method:

Calc_QDGA2_SDG2_V1

Required by the method:

Calc_QAH_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'qdga2'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

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

Bases: FluxSequence

Abfluss aus dem “unteren” Zwischenabfluss-Gebietsspeicher (outflow from the first interflow storage) [mm/T].

Calculated by the method:

Calc_QIGA1_SIG1_V1

Required by the method:

Calc_QAH_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'qiga1'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

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

Bases: FluxSequence

Abfluss aus dem “oberen” Zwischenabfluss-Gebietsspeicher (outflow from the second interflow storage) [mm/T].

Calculated by the method:

Calc_QIGA2_SIG2_V1

Required by the method:

Calc_QAH_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'qiga2'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

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

Bases: FluxSequence

Abfluss aus dem Basisabfluss-Gebietsspeicher (outflow from the base flow storage) [mm/T].

Calculated by the methods:

Calc_QBGA_SBG_QBGZ_QDGZ_V1 Calc_QBGA_SBG_V1

Required by the method:

Calc_QAH_V1

NDIM: int = 0

NUMERIC: bool = False

name: str = 'qbga'

Name of the variable in lowercase 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 lowercase 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 lowercase 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].

• SDG1() Träger Direktabfluss-Gebietsspeicher (slow direct runoff storage) [mm].

• SDG2() Dynamischer Direktabfluss-Gebietsspeicher (fast direct runoff storage) [mm].

• SIG1() Erster Zwischenabfluss-Gebietsspeicher (first interflow storage) [mm].

• SIG2() Zweiter Zwischenabfluss-Gebietsspeicher (second interflow storage) [mm].

• SBG() Basisabfluss-Gebietsspeicher (base flow storage) [mm].

class hydpy.models.lland.lland_states.Inzp(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: State1DSequence

Interzeptionsspeicherung (interception storage) [mm].

Updated by the methods:

Calc_EvI_Inzp_AETModel_V1 Calc_EvI_Inzp_V1 Calc_NBes_Inzp_V1

Required by the method:

Get_InterceptedWater_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 lowercase 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 Get_SnowyCanopy_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) → bool

Trim values in accordance with \(SInz / PWMax \leq STInz \leq SInz\), or at least in accordance with if \(STInz \geq 0\).

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> nhru(7)
>>> pwmax(2.0)
>>> states.stinz(-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0)
>>> states.stinz
stinz(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0)

>>> states.sinz = -1.0, 0.0, 1.0, 5.0, 10.0, 20.0, 3.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, 10.0, 3.0)

name: str = 'stinz'

Name of the variable in lowercase 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_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) → bool

Trim values in accordance with \(SInz / PWMax \leq STInz \leq SInz\), or at least in accordance with if \(SInz \geq 0\).

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(7)
>>> pwmax(2.0)
>>> states.sinz(-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0)
>>> states.sinz
sinz(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0)

>>> states.stinz = -1.0, 0.0, 0.0, 5.0, 5.0, 5.0, 5.0
>>> states.sinz(-1.0, 0.0, 1.0, 5.0, 10.0, 20.0, 3.0)
>>> states.sinz
sinz(0.0, 0.0, 0.0, 5.0, 10.0, 10.0, 5.0)

name: str = 'sinz'

Name of the variable in lowercase 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 lowercase 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 lowercase 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 Get_SnowCover_V1 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) → bool

Trim values in accordance with \(WAeS / PWMax \leq WATS \leq WAeS\), or at least in accordance with if \(WATS \geq 0\).

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(7)
>>> pwmax(2.0)
>>> states.wats(-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0)
>>> states.wats
wats(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0)

>>> states.waes = -1.0, 0.0, 1.0, 5.0, 10.0, 20.0, 3.0
>>> states.wats(-1.0, 0.0, 0.0, 5.0, 5.0, 5.0, 5.0)
>>> states.wats
wats(0.0, 0.0, 0.5, 5.0, 5.0, 10.0, 3.0)

name: str = 'wats'

Name of the variable in lowercase 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_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) → bool

Trim values in accordance with \(WAeS / PWMax \leq WATS \leq WAeS\), or at least in accordance with if \(WAeS \geq 0\)

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(7)
>>> pwmax(2.0)
>>> states.waes(-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0)
>>> states.waes
waes(0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0)

>>> states.wats = -1.0, 0.0, 0.0, 5.0, 5.0, 5.0, 5.0
>>> states.waes(-1.0, 0.0, 1.0, 5.0, 10.0, 20.0, 3.0)
>>> states.waes
waes(0.0, 0.0, 0.0, 5.0, 10.0, 10.0, 5.0)

name: str = 'waes'

Name of the variable in lowercase 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 lowercase 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 lowercase 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 lowercase 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 methods:

Calc_BoWa_Default_V1 Calc_BoWa_SoilModel_V1 Calc_BoWa_V1

Required by the methods:

Calc_QBB_V1 Calc_QDB_V1 Calc_QIB1_V1 Calc_QIB2_V1 Calc_QKap_V1 Get_SoilWater_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) → bool

Trim in accordance with \(0 \leq BoWa \leq WMax\).

>>> from hydpy.models.lland import *
>>> parameterstep("1d")
>>> nhru(5)
>>> wmax(200.0)
>>> states.bowa(-100.0, 0.0, 100.0, 200.0, 300.0)
>>> states.bowa
bowa(0.0, 0.0, 100.0, 200.0, 200.0)

name: str = 'bowa'

Name of the variable in lowercase letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_states.SDG1(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

Träger Direktabfluss-Gebietsspeicher (slow direct runoff storage) [mm].

Updated by the method:

Calc_QDGA1_SDG1_V1

NDIM: int = 0

NUMERIC: bool = False

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

name: str = 'sdg1'

Name of the variable in lowercase letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_states.SDG2(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

Dynamischer Direktabfluss-Gebietsspeicher (fast direct runoff storage) [mm].

Updated by the method:

Calc_QDGA2_SDG2_V1

NDIM: int = 0

NUMERIC: bool = False

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

name: str = 'sdg2'

Name of the variable in lowercase letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_states.SIG1(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

Erster Zwischenabfluss-Gebietsspeicher (first interflow storage) [mm].

Updated by the method:

Calc_QIGA1_SIG1_V1

NDIM: int = 0

NUMERIC: bool = False

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

name: str = 'sig1'

Name of the variable in lowercase letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_states.SIG2(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

Zweiter Zwischenabfluss-Gebietsspeicher (second interflow storage) [mm].

Updated by the method:

Calc_QIGA2_SIG2_V1

NDIM: int = 0

NUMERIC: bool = False

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

name: str = 'sig2'

Name of the variable in lowercase letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.lland.lland_states.SBG(subvars: ModelSequences[ModelSequence, FastAccess])

Bases: StateSequence

Basisabfluss-Gebietsspeicher (base flow storage) [mm].

Updated by the methods:

Calc_QBGA_SBG_QBGZ_QDGZ_V1 Calc_QBGA_SBG_V1

NDIM: int = 0

NUMERIC: bool = False

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

trim(lower=None, upper=None) → bool

Trim in accordance with \(SBG \leq GSBMax \cdot VolBMax\).

>>> from hydpy.models.lland import *
>>> parameterstep()
>>> volbmax(10.0)
>>> gsbmax(2.0)
>>> states.sbg(10.0)
>>> states.sbg
sbg(10.0)
>>> states.sbg(21.0)
>>> states.sbg
sbg(20.0)

name: str = 'sbg'

Name of the variable in lowercase letters.

unit: str = 'mm'

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:

• LoggedSunshineDuration() Logged sunshine duration [h].

• LoggedPossibleSunshineDuration() Logged astronomically possible sunshine duration [h].

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 lowercase 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 lowercase letters.

unit: str = 'h'

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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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 lowercase 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: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: IndexMask

Mask including all land uses.

relevant: tuple[int, ...] = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)

The integer values that are relevant to the referenced index parameter.

static get_refindices(variable: Variable) → Lnk

Reference to the associated instance of Lnk.

name: str = 'complete'

class hydpy.models.lland.lland_masks.Land(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask excluding the land uses WASSER, SEE and FLUSS.

relevant: tuple[int, ...] = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)

The integer values that are relevant to the referenced index parameter.

name: str = 'land'

class hydpy.models.lland.lland_masks.Soil(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask excluding the land uses WASSER, SEE, FLUSS, and VERS.

relevant: tuple[int, ...] = (1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)

The integer values that are relevant to the referenced index parameter.

name: str = 'soil'

class hydpy.models.lland.lland_masks.Forest(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask including the land uses LAUBW, MISCHW, and NADELW.

relevant: tuple[int, ...] = (14, 15, 13)

The integer values that are relevant to the referenced index parameter.

name: str = 'forest'

class hydpy.models.lland.lland_masks.Water(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask including the land uses WASSER, SEE, and FLUSS.

relevant: tuple[int, ...] = (16, 18, 17)

The integer values that are relevant to the referenced index parameter.

name: str = 'water'

class hydpy.models.lland.lland_masks.Sied_D(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use SIED_D.

relevant: tuple[int, ...] = (1,)

The integer values that are relevant to the referenced index parameter.

name: str = 'sied_d'

class hydpy.models.lland.lland_masks.Sied_L(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use SIED_L.

relevant: tuple[int, ...] = (2,)

The integer values that are relevant to the referenced index parameter.

name: str = 'sied_l'

class hydpy.models.lland.lland_masks.Vers(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use VERS.

relevant: tuple[int, ...] = (3,)

The integer values that are relevant to the referenced index parameter.

name: str = 'vers'

class hydpy.models.lland.lland_masks.Acker(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use ACKER.

relevant: tuple[int, ...] = (4,)

The integer values that are relevant to the referenced index parameter.

name: str = 'acker'

class hydpy.models.lland.lland_masks.Weinb(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use WEINB.

relevant: tuple[int, ...] = (5,)

The integer values that are relevant to the referenced index parameter.

name: str = 'weinb'

class hydpy.models.lland.lland_masks.Obstb(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use OBSTB.

relevant: tuple[int, ...] = (6,)

The integer values that are relevant to the referenced index parameter.

name: str = 'obstb'

class hydpy.models.lland.lland_masks.Boden(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use BODEN.

relevant: tuple[int, ...] = (7,)

The integer values that are relevant to the referenced index parameter.

name: str = 'boden'

class hydpy.models.lland.lland_masks.Glets(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use GLETS.

relevant: tuple[int, ...] = (8,)

The integer values that are relevant to the referenced index parameter.

name: str = 'glets'

class hydpy.models.lland.lland_masks.Grue_I(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use GRUE_I.

relevant: tuple[int, ...] = (9,)

The integer values that are relevant to the referenced index parameter.

name: str = 'grue_i'

class hydpy.models.lland.lland_masks.Feucht(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use FEUCHT.

relevant: tuple[int, ...] = (10,)

The integer values that are relevant to the referenced index parameter.

name: str = 'feucht'

class hydpy.models.lland.lland_masks.Grue_E(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use GRUE_E.

relevant: tuple[int, ...] = (11,)

The integer values that are relevant to the referenced index parameter.

name: str = 'grue_e'

class hydpy.models.lland.lland_masks.Baumb(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use BAUMB.

relevant: tuple[int, ...] = (12,)

The integer values that are relevant to the referenced index parameter.

name: str = 'baumb'

class hydpy.models.lland.lland_masks.Nadelw(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use NADELW.

relevant: tuple[int, ...] = (13,)

The integer values that are relevant to the referenced index parameter.

name: str = 'nadelw'

class hydpy.models.lland.lland_masks.Laubw(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use LAUBW.

relevant: tuple[int, ...] = (14,)

The integer values that are relevant to the referenced index parameter.

name: str = 'laubw'

class hydpy.models.lland.lland_masks.Mischw(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use MISCHW.

relevant: tuple[int, ...] = (15,)

The integer values that are relevant to the referenced index parameter.

name: str = 'mischw'

class hydpy.models.lland.lland_masks.Wasser(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use WASSER.

relevant: tuple[int, ...] = (16,)

The integer values that are relevant to the referenced index parameter.

name: str = 'wasser'

class hydpy.models.lland.lland_masks.Fluss(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use FLUSS.

relevant: tuple[int, ...] = (17,)

The integer values that are relevant to the referenced index parameter.

name: str = 'fluss'

class hydpy.models.lland.lland_masks.See(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)

Bases: Complete

Mask for land use SEE.

relevant: tuple[int, ...] = (18,)

The integer values that are relevant to the referenced index parameter.

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

• KG() Niederschlagskorrekturfaktor (adjustment factor for precipitation) [-].

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

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

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

• 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²].

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

• 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 (highest possible base flow storage) [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 baseflow storage increase without inflow reductions) [mm/T].

• GSBGrad2() Volumenzunahme des Gebietsspeichers für Basisabfluss, oberhalb der jeglicher Zufluss ausgeschlossen ist (highest possible baseflow storage increase) [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 whether 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].

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

• KB() Konzentrationszeit des Basisabflusses (concentration time of the baseflow storage) [T].

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

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

• KD1() Konzentrationszeit des “langsamen” Direktabflusses (concentration time of the slow direct runoff storage) [T].

• KD2() Konzentrationszeit des “schnellen” Direktabflusses (concentration time of the fast direct runoff storage) [T].

• QFactor() Factor for converting mm/T to m³/s.

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

Bases: FactorSequences

Factor sequences of model lland.

The following classes are selected:

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

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

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

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

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

• DailySunshineDuration() Daily sunshine duration [h].

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

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

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

• TKor() Korrigierte Lufttemperatur (corrected air temperature) [°C].

• WindSpeed2m() Wind speed at a height of 2 m above the ground for grass [m/s].

• ReducedWindSpeed2m() Land-use-specific wind speed at a height of 2 m above the ground [m/s].

• SaturationVapourPressure() Saturation 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].

• ActualVapourPressure() Actual vapour pressure [hPa].

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

• WG() “Dynamischer” Bodenwärmestrom (“dynamic” soil heat flux) [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²].

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

• NetLongwaveRadiationSnow() Net longwave radiation for snow-surfaces [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²].

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

• EvI() Tatsächliche Verdunstung von Interzeptions- und permanenten Wasserflächen (actual evaporation from interception storages and water areas) [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 to both direct runoff storages) [mm/T].

• QDGZ1() Zufluss in den trägeren Direktabfluss-Gebietsspeicher (inflow to the slow direct runoff storage) [mm/T].

• QDGZ2() Zufluss in den dynamischeren Direktabfluss-Gebietsspeicher (inflow to the fast direct runoff storage) [mm/T].

• QIGZ1() “Zufluss in den ersten Zwischenabfluss-Gebietsspeicher (inflow to the first interflow storage) [mm/T].

• QIGZ2() Zufluss in den zweiten Zwischenabfluss-Gebietsspeicher (inflow to the second interflow storage) [mm/T].

• QBGZ() Zufluss in den Basisabfluss-Gebietsspeicher (inflow to the base flow storage) [mm/T].

• QDGA1() Abfluss aus dem trägeren Direktabfluss-Gebietsspeicher (outflow from the slow direct runoff storage) [mm/T].

• QDGA2() Abfluss aus dem dynamischeren Direktabfluss-Gebietsspeicher (outflow from the fast direct runoff storage) [mm/T].

• QIGA1() Abfluss aus dem “unteren” Zwischenabfluss-Gebietsspeicher (outflow from the first interflow storage) [mm/T].

• QIGA2() Abfluss aus dem “oberen” Zwischenabfluss-Gebietsspeicher (outflow from the second interflow storage) [mm/T].

• QBGA() Abfluss aus dem Basisabfluss-Gebietsspeicher (outflow from the base flow storage) [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].

• RelativeHumidity() Relative humidity [%].

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

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:

• LoggedSunshineDuration() Logged sunshine duration [h].

• LoggedPossibleSunshineDuration() Logged astronomically possible sunshine duration [h].

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

• SDG1() Träger Direktabfluss-Gebietsspeicher (slow direct runoff storage) [mm].

• SDG2() Dynamischer Direktabfluss-Gebietsspeicher (fast direct runoff storage) [mm].

• SIG1() Erster Zwischenabfluss-Gebietsspeicher (first interflow storage) [mm].

• SIG2() Zweiter Zwischenabfluss-Gebietsspeicher (second interflow storage) [mm].

• SBG() Basisabfluss-Gebietsspeicher (base flow storage) [mm].