HydPy-W (base model)¶

Base model wland is the core of the HydPy implementation of all WALRUS type models (Brauer et al., 2014), focussing on the interaction between surface water and near-surface groundwater.

Method Features¶

class hydpy.models.wland.wland_model.Model[source]¶

Bases: ELSModel

HydPy-W (base model)

The following “receiver update methods” are called in the given sequence before performing a simulation step:

Pick_HS_V1 Take the surface water level from a submodel that complies with the WaterLevelModel_V1 interface, if available.

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

Calc_PE_PET_V1 Let a submodel that complies with the PETModel_V1 or PETModel_V2 interface calculate the potential evapotranspiration of the land areas and the potential evaporation of the surface water storage.
Calc_FR_V1 Determine the fraction between rainfall and total precipitation.
Calc_PM_V1 Calculate the potential snowmelt of the land areas.

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

Calc_FXS_V1 Query the current surface water supply/extraction.
Calc_FXG_V1 Query the current seepage/extraction.
Calc_PC_V1 Calculate the corrected precipitation.
Calc_TF_V1 Calculate the total amount of throughfall of the land areas.
Calc_EI_V1 Calculate the interception evaporation of the land areas.
Calc_SF_V1 Calculate the frozen amount of throughfall (snowfall) of the land areas.
Calc_RF_V1 Calculate the liquid amount of throughfall (rainfall) of the land areas.
Calc_AM_V1 Calculate the actual snowmelt of the land areas.
Calc_PS_V1 Calculate the precipitation entering the surface water reservoir.
Calc_WE_W_V1 Calculate the wetness index for the elevated and the lowland regions.
Calc_PVE_PV_V1 Calculate the rainfall (and snowmelt) entering the vadose zone in the elevated and lowland regions.
Calc_PQ_V1 Calculate the rainfall (and snowmelt) entering the quickflow reservoir.
Calc_BetaE_Beta_V1 Calculate the evapotranspiration reduction factor for the elevated and lowland regions.
Calc_ETVE_ETV_V1 Calculate the actual evapotranspiration from the elevated and lowland regions’ vadose zone.
Calc_ES_V1 Calculate the actual evaporation from the surface water reservoir.
Calc_FQS_V1 Calculate the quickflow.
Calc_FGSE_V1 Calculate the groundwater flow between the elevated and the lowland regions.
Calc_FGS_V1 Calculate the groundwater drainage or surface water infiltration.
Calc_RH_V1 Let a submodel that complies with the DischargeModel_V2 interface calculate the runoff height or, if no such submodel is available, equate it with all other flows in and out of the surface water storage.
Calc_DVEq_V1 Calculate the equilibrium storage deficit of the vadose zone.
Calc_DVEq_V2 Calculate the equilibrium storage deficit of the vadose zone.
Calc_DVEq_V3 Calculate the equilibrium storage deficit of the vadose zone.
Calc_DVEq_V4 Calculate the equilibrium storage deficit of the vadose zone.
Calc_DGEq_V1 Calculate the equilibrium groundwater depth.
Calc_GF_V1 Calculate the gain factor for changes in groundwater depth.
Calc_GR_V1 Calculate the elevated region’s groundwater recharge.
Calc_CDG_V1 Calculate the change in the groundwater depth due to percolation and capillary rise.
Calc_CDG_V2 Calculate the vadose zone’s storage deficit change due to percolation, capillary rise, macropore infiltration, seepage, groundwater flow, and channel water infiltration.

The following methods define the complete equations of an ODE system (e.g. change in storage of fast water due to effective precipitation and direct runoff):

Update_IC_V1 Update the interception storage.
Update_SP_V1 Update the storage deficit.
Update_DVE_V1 Update the elevated region’s storage deficit of the vadose zone.
Update_DV_V1 Update the lowland region’s storage deficit of the vadose zone.
Update_HGE_V1 Update the elevated region’s groundwater level.
Update_DG_V1 Update the lowland region’s groundwater depth.
Update_HQ_V1 Update the level of the quickflow reservoir.
Update_HS_V1 Update the surface water level.

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

Calc_ET_V1 Calculate the total actual evapotranspiration.
Calc_R_V1 Calculate the runoff in m³/s.
Pass_R_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 current subbasin-wide air temperature value (that applies to all hydrological response units so that the given index does not matter).
Get_MeanTemperature_V1 Get the current subbasin-wide air temperature value.
Get_Precipitation_V1 Get the current subbasin-wide precipitation value (that applies to all hydrological response units so that the given index does not matter).
Get_SnowCover_V1 Get the selected response unit’s current snow cover degree.

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_PE_PET_PETModel_V1 Let a submodel that complies with the PETModel_V1 interface calculate the potential evapotranspiration of the land areas and the potential evaporation of the surface water storage.
Calc_PE_PET_PETModel_V2 Let a submodel that complies with the PETModel_V2 interface calculate the potential interception evaporation and potential vadose zone evapotranspiration of the land areas and the potential evaporation of the surface water storage.
Return_ErrorDV_V1 Calculate the difference between the equilibrium and the actual storage deficit of the vadose zone.
Return_DVH_V1 Return the storage deficit of the vadose zone at a specific height above the groundwater table.
Return_DVH_V2 Return the storage deficit of the vadose zone at a specific height above the groundwater table.

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

PETModel_V1 Simple interface for calculating all potential evapotranspiration values in one step.
PETModel_V2 Interface for calculating separate potential interception, soil, and water evapotranspiration values.
DischargeModel_V2 Simple interface for calculating discharge in mm/T based on the current water depth.
WaterLevelModel_V1 Pure getter interface for querying the current water level.

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

PegasusDGEq Pegasus iterator for finding the equilibrium groundwater depth.
QuadDVEq_V1 Adaptive quadrature method for integrating the equilibrium storage deficit of the vadose zone.
QuadDVEq_V2 Adaptive quadrature method for integrating the equilibrium storage deficit of the vadose zone.

DOCNAME: DocName = ('W', 'base model')¶

petmodel¶: Required submodel that complies with one of the following interfaces: PETModel_V1 or PETModel_V2.

petmodel_is_mainmodel¶

petmodel_typeid¶

dischargemodel¶: Required submodel that complies with the following interface: DischargeModel_V2.

dischargemodel_is_mainmodel¶

dischargemodel_typeid¶

waterlevelmodel¶: Required submodel that complies with the following interface: WaterLevelModel_V1.

waterlevelmodel_is_mainmodel¶

waterlevelmodel_typeid¶

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

class hydpy.models.wland.wland_model.Pick_HS_V1[source]¶

Bases: Method

Take the surface water level from a submodel that complies with the WaterLevelModel_V1 interface, if available.

Requires the control parameter:: BL
Updates the state sequence:: HS
Calculates the factor sequence:: DHS
Basic equation:: \(HS = 1000 \cdot (WaterLevel - BL)\)

Examples:

>>> from hydpy.models.wland_wag import *
>>> parameterstep()
Without an available submodel, Pick_HS_V1 does not change the current value of sequence HS and sets DHS (the change of HS) accordingly to zero:
>>> states.hs(3000.0)
>>> model.pick_hs_v1()
>>> states.hs
hs(3000.0)
>>> factors.dhs
dhs(0.0)
We take exch_waterlevel as an example to demonstrate that Pick_HS_V1 correctly uses submodels that follow the WaterLevelModel_V1 interface and the defined channel bottom level (BL) for updating HS and logs such changes via sequence DHS:
>>> bl(3.0)
>>> with model.add_waterlevelmodel_v1("exch_waterlevel"):
...     pass
>>> from hydpy import Element, Node
>>> wl = Node("wl", variable="WaterLevel")
>>> wl.sequences.sim = 5.0
>>> e = Element("e", receivers=wl, outlets="q")
>>> e.model = model
>>> model.pick_hs_v1()
>>> states.hs
hs(2000.0)
>>> factors.dhs
dhs(-1000.0)

class hydpy.models.wland.wland_model.Calc_FXS_V1[source]¶

Bases: Method

Query the current surface water supply/extraction.

Requires the control parameter:: NU
Requires the derived parameter:: ASR
Requires the input sequence:: FXS
Calculates the flux sequence:: FXS
Basic equation:: \[\begin{split}FXS_{fluxes} = \begin{cases} 0 &|\ FXS_{inputs} = 0 \\ \frac{FXS_{inputs}}{ASR} &|\ FXS_{inputs} \neq 0 \land NU > 1 \\ inf &|\ FXS_{inputs} \neq 0 \land NU = 1 \end{cases}\end{split}\]

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(2)
>>> derived.asr(0.5)
>>> inputs.fxs = 2.0
>>> model.calc_fxs_v1()
>>> fluxes.fxs
fxs(4.0)
>>> nu(1)
>>> derived.asr(0.0)
>>> model.calc_fxs_v1()
>>> fluxes.fxs
fxs(inf)
>>> inputs.fxs = 0.0
>>> model.calc_fxs_v1()
>>> fluxes.fxs
fxs(0.0)

class hydpy.models.wland.wland_model.Calc_FXG_V1[source]¶

Bases: Method

Query the current seepage/extraction.

Requires the derived parameter:: AGR
Requires the input sequence:: FXG
Calculates the flux sequence:: FXG
Basic equation:: \[\begin{split}FXG_{fluxes} = \begin{cases} 0 &|\ FXG_{inputs} = 0 \\ \frac{FXG_{inputs}}{AGR} &|\ FXG_{inputs} \neq 0 \land AGR > 0 \\ inf &|\ FXG_{inputs} \neq 0 \land AGR = 0 \end{cases}\end{split}\]

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> derived.agr(0.4)
>>> inputs.fxg = 2.0
>>> model.calc_fxg_v1()
>>> fluxes.fxg
fxg(5.0)
>>> derived.agr(0.0)
>>> model.calc_fxg_v1()
>>> fluxes.fxg
fxg(inf)
>>> inputs.fxg = 0.0
>>> model.calc_fxg_v1()
>>> fluxes.fxg
fxg(0.0)

class hydpy.models.wland.wland_model.Calc_PC_V1[source]¶

Bases: Method

Calculate the corrected precipitation.

Requires the control parameter:: CP
Requires the input sequence:: P
Calculates the flux sequence:: PC
Basic equation:: \(PC = CP \cdot P\)

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> cp(1.2)
>>> inputs.p = 2.0
>>> model.calc_pc_v1()
>>> fluxes.pc
pc(2.4)

class hydpy.models.wland.wland_model.Calc_PE_PET_PETModel_V1[source]¶

Bases: Method

Let a submodel that complies with the PETModel_V1 interface calculate the potential evapotranspiration of the land areas and the potential evaporation of the surface water storage.

Required by the method:: Calc_PE_PET_V1
Requires the derived parameter:: NUL
Calculates the flux sequences:: PE PET

Example:

We use evap_ret_tw2002 as an example:

>>> from hydpy.models.wland_wag import *
>>> parameterstep()
>>> nu(4)
>>> at(1.0)
>>> aur(0.25, 0.15, 0.1, 0.5)
>>> lt(FIELD, FIELD, FIELD, WATER)
>>> derived.nul.update()
>>> from hydpy import prepare_model
>>> with model.add_petmodel_v1("evap_ret_tw2002"):
...     hrualtitude(200.0, 600.0, 1000.0, 100.0)
...     coastfactor(0.6)
...     evapotranspirationfactor(1.1)
...     with model.add_radiationmodel_v2("meteo_glob_io"):
...         inputs.globalradiation = 200.0
...     with model.add_tempmodel_v2("meteo_temp_io"):
...         temperatureaddend(1.0)
...         inputs.temperature = 14.0
>>> model.calc_pe_pet_v1()
>>> fluxes.pe
pe(3.07171, 2.86215, 2.86215, 3.128984)
>>> fluxes.pet
pet(3.07171, 2.86215, 2.86215, 0.0)

class hydpy.models.wland.wland_model.Calc_PE_PET_PETModel_V2[source]¶

Bases: Method

Let a submodel that complies with the PETModel_V2 interface calculate the potential interception evaporation and potential vadose zone evapotranspiration of the land areas and the potential evaporation of the surface water storage.

Required by the method:: Calc_PE_PET_V1
Requires the derived parameter:: NUL
Calculates the flux sequences:: PE PET

Examples:

We use evap_pet_ambav1 as an example. All data stems from the integration tests vegetation, snow, and water area:

>>> from hydpy import pub
>>> pub.timegrids = "2000-08-01", "2000-08-02", "1d"
>>> from hydpy.models.wland_wag import *
>>> parameterstep("1h")
>>> nu(3)
>>> at(1.0)
>>> aur(0.5, 0.3, 0.2)
>>> lt(FIELD, DECIDIOUS, WATER)
>>> lai(5.0)
>>> derived.nul.update()
>>> inputs.t = 15.0
>>> inputs.p = 0.0
>>> states.sp = 0.0, 1.0, 0.0
>>> from hydpy import prepare_model
>>> with model.add_petmodel_v2("evap_pet_ambav1") as ambav:
...     measuringheightwindspeed(10.0)
...     leafalbedo(0.2)
...     leafalbedosnow(0.8)
...     groundalbedo(0.2)
...     groundalbedosnow(0.8)
...     cropheight.field = 10.0
...     cropheight.decidious = 10.0
...     cropheight.water = 0.0
...     leafresistance(40.0)
...     wetsoilresistance(100.0)
...     soilresistanceincrease(1.0)
...     wetnessthreshold(0.5)
...     cloudtypefactor(0.2)
...     nightcloudfactor(1.0)
...     inputs.windspeed = 2.0
...     inputs.relativehumidity = 80.0
...     inputs.atmosphericpressure = 1000.0
...     states.soilresistance = 100.0
...     with model.add_radiationmodel_v4("meteo_psun_sun_glob_io"):
...         inputs.sunshineduration = 6.0
...         inputs.possiblesunshineduration = 16.0
...         inputs.globalradiation = 190.0

The first example reproduces the results for the first simulated day of the integration tests vegetation (first response unit) and water area (third response unit):

>>> ambav.sequences.logs.loggedprecipitation = [0.0]
>>> ambav.sequences.logs.loggedpotentialsoilevapotranspiration = [1.0]
>>> model.calc_pe_pet_v1()
>>> fluxes.pe
pe(3.301949, 1.146759, 1.890672)
>>> fluxes.pet
pet(2.292368, 0.796134, 0.0)

The second example reproduces the results for the third simulated day of the snow integration test (second response unit):

>>> ambav.sequences.logs.loggedprecipitation = [10.0]
>>> ambav.sequences.logs.loggedpotentialsoilevapotranspiration = [2.282495]
>>> model.calc_pe_pet_v1()
>>> fluxes.pe
pe(3.301949, 1.146759, 1.890672)
>>> fluxes.pet
pet(2.324763, 0.807385, 0.0)

class hydpy.models.wland.wland_model.Calc_PE_PET_V1[source]¶

Bases: Method

Let a submodel that complies with the PETModel_V1 or PETModel_V2 interface calculate the potential evapotranspiration of the land areas and the potential evaporation of the surface water storage.

Required submethods:: Calc_PE_PET_PETModel_V1 Calc_PE_PET_PETModel_V2
Requires the derived parameter:: NUL
Calculates the flux sequences:: PE PET

class hydpy.models.wland.wland_model.Calc_TF_V1[source]¶

Bases: Method

Calculate the total amount of throughfall of the land areas.

Requires the control parameters:: LT LAI IH
Requires the derived parameters:: MOY NUL RH1
Requires the flux sequence:: PC
Requires the state sequence:: IC
Calculates the flux sequence:: TF
Basic equation (discontinuous):: \[\begin{split}TF = \begin{cases} P &|\ IC > IT \\ 0 &|\ IC < IT \end{cases}\end{split}\]

Examples:

>>> from hydpy import pub, UnitTest
>>> pub.timegrids = '2000-03-30', '2000-04-03', '1d'
>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(2)
>>> lt(FIELD, WATER)
>>> ih(0.2)
>>> lai.field_mar = 5.0
>>> lai.field_apr = 10.0
>>> derived.moy.update()
>>> derived.nul.update()
>>> fluxes.pc = 5.0
>>> test = UnitTest(
...     model=model,
...     method=model.calc_tf_v1,
...     last_example=6,
...     parseqs=(states.ic, fluxes.tf),
... )
>>> test.nexts.ic = -4.0, 0.0, 1.0, 2.0, 3.0, 7.0

Without smoothing:

>>> sh(0.0)
>>> derived.rh1.update()
>>> model.idx_sim = pub.timegrids.init['2000-03-31']
>>> test()
| ex. |         ic |       tf |
-------------------------------
|   1 | -4.0  -4.0 | 0.0  0.0 |
|   2 |  0.0   0.0 | 0.0  0.0 |
|   3 |  1.0   1.0 | 2.5  0.0 |
|   4 |  2.0   2.0 | 5.0  0.0 |
|   5 |  3.0   3.0 | 5.0  0.0 |
|   6 |  7.0   7.0 | 5.0  0.0 |

With smoothing:

>>> sh(1.0)
>>> derived.rh1.update()
>>> model.idx_sim = pub.timegrids.init['2000-04-01']
>>> test()
| ex. |         ic |           tf |
-----------------------------------
|   1 | -4.0  -4.0 |     0.0  0.0 |
|   2 |  0.0   0.0 | 0.00051  0.0 |
|   3 |  1.0   1.0 |    0.05  0.0 |
|   4 |  2.0   2.0 |     2.5  0.0 |
|   5 |  3.0   3.0 |    4.95  0.0 |
|   6 |  7.0   7.0 |     5.0  0.0 |

class hydpy.models.wland.wland_model.Calc_EI_V1[source]¶

Bases: Method

Calculate the interception evaporation of the land areas.

Requires the derived parameters:: NUL RH1
Requires the flux sequence:: PE
Requires the state sequence:: IC
Calculates the flux sequence:: EI
Basic equation (discontinuous):: \[\begin{split}EI = \begin{cases} PE &|\ IC > 0 \\ 0 &|\ IC < 0 \end{cases}\end{split}\]

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(2)
>>> derived.nul.update()
>>> fluxes.pe = 5.0
>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model=model,
...     method=model.calc_ei_v1,
...     last_example=9,
...     parseqs=(states.ic, fluxes.ei)
... )
>>> test.nexts.ic = -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0

Without smoothing:

>>> sh(0.0)
>>> derived.rh1.update()
>>> test()
| ex. |         ic |       ei |
-------------------------------
|   1 | -4.0  -4.0 | 0.0  0.0 |
|   2 | -3.0  -3.0 | 0.0  0.0 |
|   3 | -2.0  -2.0 | 0.0  0.0 |
|   4 | -1.0  -1.0 | 0.0  0.0 |
|   5 |  0.0   0.0 | 2.5  0.0 |
|   6 |  1.0   1.0 | 5.0  0.0 |
|   7 |  2.0   2.0 | 5.0  0.0 |
|   8 |  3.0   3.0 | 5.0  0.0 |
|   9 |  4.0   4.0 | 5.0  0.0 |

With smoothing:

>>> sh(1.0)
>>> derived.rh1.update()
>>> test()
| ex. |         ic |            ei |
------------------------------------
|   1 | -4.0  -4.0 |      0.0  0.0 |
|   2 | -3.0  -3.0 | 0.000005  0.0 |
|   3 | -2.0  -2.0 |  0.00051  0.0 |
|   4 | -1.0  -1.0 |     0.05  0.0 |
|   5 |  0.0   0.0 |      2.5  0.0 |
|   6 |  1.0   1.0 |     4.95  0.0 |
|   7 |  2.0   2.0 |  4.99949  0.0 |
|   8 |  3.0   3.0 | 4.999995  0.0 |
|   9 |  4.0   4.0 |      5.0  0.0 |

class hydpy.models.wland.wland_model.Calc_FR_V1[source]¶

Bases: Method

Determine the fraction between rainfall and total precipitation.

Requires the control parameters:: TT TI
Requires the input sequence:: T
Calculates the aide sequence:: FR
Basic equation:: \(FR = \frac{T- \left( TT - TI / 2 \right)}{TI}\)
Restriction:: \(0 \leq FR \leq 1\)

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> tt(1.0)
>>> ti(4.0)
>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model=model,
...     method=model.calc_fr_v1,
...     last_example=9,
...     parseqs=(inputs.t, aides.fr)
... )
>>> test.nexts.t = -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0
>>> test()
| ex. |    t |   fr |
---------------------
|   1 | -3.0 |  0.0 |
|   2 | -2.0 |  0.0 |
|   3 | -1.0 |  0.0 |
|   4 |  0.0 | 0.25 |
|   5 |  1.0 |  0.5 |
|   6 |  2.0 | 0.75 |
|   7 |  3.0 |  1.0 |
|   8 |  4.0 |  1.0 |
|   9 |  5.0 |  1.0 |

class hydpy.models.wland.wland_model.Calc_RF_V1[source]¶

Bases: Method

Calculate the liquid amount of throughfall (rainfall) of the land areas.

Requires the derived parameter:: NUL
Requires the flux sequence:: TF
Requires the aide sequence:: FR
Calculates the flux sequence:: RF
Basic equation:: \(RF = FR \cdot TF\)

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(2)
>>> derived.nul.update()
>>> fluxes.tf = 2.0
>>> aides.fr = 0.8
>>> model.calc_rf_v1()
>>> fluxes.rf
rf(1.6, 0.0)

class hydpy.models.wland.wland_model.Calc_SF_V1[source]¶

Bases: Method

Calculate the frozen amount of throughfall (snowfall) of the land areas.

Requires the derived parameter:: NUL
Requires the flux sequence:: TF
Requires the aide sequence:: FR
Calculates the flux sequence:: SF
Basic equation:: \(SF = (1-FR) \cdot TF\)

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(2)
>>> derived.nul.update()
>>> fluxes.tf = 2.0
>>> aides.fr = 0.8
>>> model.calc_sf_v1()
>>> fluxes.sf
sf(0.4, 0.0)

class hydpy.models.wland.wland_model.Calc_PM_V1[source]¶

Bases: Method

Calculate the potential snowmelt of the land areas.

Requires the control parameters:: DDF DDT
Requires the derived parameters:: NUL RT2
Requires the input sequence:: T
Calculates the flux sequence:: PM
Basic equation (discontinous):: \(PM = max \left( DDF \cdot (T - DDT), 0 \right)\)

Examples:

>>> from hydpy.models.wland import *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nu(2)
>>> derived.nul.update()
>>> ddf(4.0)
>>> ddt(1.0)
>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model=model,
...     method=model.calc_pm_v1,
...     last_example=11,
...     parseqs=(inputs.t, fluxes.pm)
... )
>>> test.nexts.t = -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0

Without smoothing:

>>> st(0.0)
>>> derived.rt2.update()
>>> test()
| ex. |    t |        pm |
--------------------------
|   1 | -4.0 |  0.0  0.0 |
|   2 | -3.0 |  0.0  0.0 |
|   3 | -2.0 |  0.0  0.0 |
|   4 | -1.0 |  0.0  0.0 |
|   5 |  0.0 |  0.0  0.0 |
|   6 |  1.0 |  0.0  0.0 |
|   7 |  2.0 |  2.0  0.0 |
|   8 |  3.0 |  4.0  0.0 |
|   9 |  4.0 |  6.0  0.0 |
|  10 |  5.0 |  8.0  0.0 |
|  11 |  6.0 | 10.0  0.0 |

With smoothing:

>>> st(1.0)
>>> derived.rt2.update()
>>> test()
| ex. |    t |            pm |
------------------------------
|   1 | -4.0 |      0.0  0.0 |
|   2 | -3.0 | 0.000001  0.0 |
|   3 | -2.0 | 0.000024  0.0 |
|   4 | -1.0 | 0.000697  0.0 |
|   5 |  0.0 |     0.02  0.0 |
|   6 |  1.0 | 0.411048  0.0 |
|   7 |  2.0 |     2.02  0.0 |
|   8 |  3.0 | 4.000697  0.0 |
|   9 |  4.0 | 6.000024  0.0 |
|  10 |  5.0 | 8.000001  0.0 |
|  11 |  6.0 |     10.0  0.0 |

class hydpy.models.wland.wland_model.Calc_AM_V1[source]¶

Bases: Method

Calculate the actual snowmelt of the land areas.

Requires the derived parameters:: NUL RH1
Requires the flux sequence:: PM
Requires the state sequence:: SP
Calculates the flux sequence:: AM
Basic equation (discontinous):: \[\begin{split}AM = \begin{cases} PM &|\ SP > 0 \\ 0 &|\ SP < 0 \end{cases}\end{split}\]

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(2)
>>> derived.nul.update()
>>> fluxes.pm = 2.0
>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model=model,
...     method=model.calc_am_v1,
...     last_example=9,
...     parseqs=(states.sp, fluxes.am)
... )
>>> test.nexts.sp = -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0

Without smoothing:

>>> sh(0.0)
>>> derived.rh1.update()
>>> test()
| ex. |         sp |       am |
-------------------------------
|   1 | -4.0  -4.0 | 0.0  0.0 |
|   2 | -3.0  -3.0 | 0.0  0.0 |
|   3 | -2.0  -2.0 | 0.0  0.0 |
|   4 | -1.0  -1.0 | 0.0  0.0 |
|   5 |  0.0   0.0 | 1.0  0.0 |
|   6 |  1.0   1.0 | 2.0  0.0 |
|   7 |  2.0   2.0 | 2.0  0.0 |
|   8 |  3.0   3.0 | 2.0  0.0 |
|   9 |  4.0   4.0 | 2.0  0.0 |

With smoothing:

>>> sh(1.0)
>>> derived.rh1.update()
>>> test()
| ex. |         sp |            am |
------------------------------------
|   1 | -4.0  -4.0 |      0.0  0.0 |
|   2 | -3.0  -3.0 | 0.000002  0.0 |
|   3 | -2.0  -2.0 | 0.000204  0.0 |
|   4 | -1.0  -1.0 |     0.02  0.0 |
|   5 |  0.0   0.0 |      1.0  0.0 |
|   6 |  1.0   1.0 |     1.98  0.0 |
|   7 |  2.0   2.0 | 1.999796  0.0 |
|   8 |  3.0   3.0 | 1.999998  0.0 |
|   9 |  4.0   4.0 |      2.0  0.0 |

class hydpy.models.wland.wland_model.Calc_PS_V1[source]¶

Bases: Method

Calculate the precipitation entering the surface water reservoir.

Requires the flux sequence:: PC
Calculates the flux sequence:: PS
Basic equation:: \(PS = PC\)

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> fluxes.pc = 3.0
>>> model.calc_ps_v1()
>>> fluxes.ps
ps(3.0)

class hydpy.models.wland.wland_model.Calc_WE_W_V1[source]¶

Bases: Method

Calculate the wetness index for the elevated and the lowland regions.

Requires the control parameters:: CWE CW
Requires the derived parameters:: NUGE NUG
Requires the fixed parameter:: Pi
Requires the state sequences:: DVE DV
Calculates the aide sequences:: WE W
Basic equation for the lowland region (the elevated region is handled analogous):: \(W = cos \left( \frac{min \big( max(DV, \, 0), \, CW \big) \cdot Pi}{CW} \right) \cdot \frac{1}{2} + \frac{1}{2}\)

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> cwe(200.0)
>>> cw(400.0)

>>> derived.nuge(1)
>>> derived.nug(1)
>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model=model,
...     method=model.calc_we_w_v1,
...     last_example=11,
...     parseqs=(states.dve, states.dv, aides.we, aides.w)
... )
>>> test.nexts.dve = (
...     -50.0, -5.0, 0.0, 5.0, 50.0, 100.0, 150.0, 195.0, 200.0, 205.0, 250.0)
>>> test.nexts.dv = tuple(dv + 100.0 for dv in test.nexts.dve)
>>> test()
| ex. |   dve |    dv |       we |        w |
---------------------------------------------
|   1 | -50.0 |  50.0 |      1.0 |  0.96194 |
|   2 |  -5.0 |  95.0 |      1.0 | 0.867161 |
|   3 |   0.0 | 100.0 |      1.0 | 0.853553 |
|   4 |   5.0 | 105.0 | 0.998459 |   0.8394 |
|   5 |  50.0 | 150.0 | 0.853553 | 0.691342 |
|   6 | 100.0 | 200.0 |      0.5 |      0.5 |
|   7 | 150.0 | 250.0 | 0.146447 | 0.308658 |
|   8 | 195.0 | 295.0 | 0.001541 |   0.1606 |
|   9 | 200.0 | 300.0 |      0.0 | 0.146447 |
|  10 | 205.0 | 305.0 |      0.0 | 0.132839 |
|  11 | 250.0 | 350.0 |      0.0 |  0.03806 |

>>> derived.nuge(0)
>>> derived.nug(0)
>>> model.calc_we_w_v1()
>>> aides.we
we(nan)
>>> aides.w
w(nan)

class hydpy.models.wland.wland_model.Calc_PVE_PV_V1[source]¶

Bases: Method

Calculate the rainfall (and snowmelt) entering the vadose zone in the elevated and lowland regions.

Requires the control parameters:: LT ER AUR
Requires the derived parameters:: NUL AGRE AGR
Requires the flux sequences:: RF AM
Requires the aide sequences:: WE W
Calculates the flux sequences:: PVE PV
Basic equation for the lowland region (the elevated region is handled analogous):: \[\begin{split}PV = \sum_{i=1}^{NUL} \left ( \frac{AUR_i}{AGR} \cdot (RF_i + AM_i) \cdot \begin{cases} 0 &|\ LT_i = SEALED \\ 1-W &|\ LT_i \neq SEALED \end{cases} \right )\end{split}\]

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(4)
>>> derived.nul.update()
>>> lt(FIELD, SOIL, SEALED, WATER)
>>> aur(0.35, 0.1, 0.05, 0.5)
>>> fluxes.rf = 3.0, 2.0, 1.0, 0.0
>>> fluxes.am = 1.0, 2.0, 3.0, 0.0
>>> aides.we = 0.75
>>> aides.w = 0.25

>>> er(True)
>>> derived.agre.update()
>>> derived.agr.update()
>>> model.calc_pve_pv_v1()
>>> fluxes.pve
pve(1.0)
>>> fluxes.pv
pv(0.0)

>>> er(False)
>>> derived.agre.update()
>>> derived.agr.update()
>>> model.calc_pve_pv_v1()
>>> fluxes.pve
pve(0.0)
>>> fluxes.pv
pv(3.0)

class hydpy.models.wland.wland_model.Calc_PQ_V1[source]¶

Bases: Method

Calculate the rainfall (and snowmelt) entering the quickflow reservoir.

Requires the control parameters:: LT ER AUR
Requires the derived parameters:: NUL ALR
Requires the flux sequences:: RF AM
Requires the aide sequences:: WE W
Calculates the flux sequence:: PQ
Basic equation:: \[\begin{split}PQ = \sum_{i=1}^{NUL} \frac{AUR_i}{ALR} \cdot (RF_i + AM_i) \cdot \begin{cases} 1 &|\ LT_i = SEALED \\ WE &|\ LT_i \neq SEALED \ \land \ ER_i \\ W &|\ LT_i \neq SEALED \ \land \ \overline{ER_i} \end{cases}\end{split}\]

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(4)
>>> lt(FIELD, SOIL, SEALED, WATER)
>>> aur(0.3, 0.15, 0.05, 0.5)
>>> derived.nul.update()
>>> derived.alr.update()
>>> fluxes.rf = 3.0, 2.0, 1.0, 0.0
>>> fluxes.am = 1.0, 2.0, 2.0, 0.0
>>> aides.w = 0.75
>>> model.calc_pq_v1()
>>> fluxes.pq
pq(3.0)

class hydpy.models.wland.wland_model.Calc_BetaE_Beta_V1[source]¶

Bases: Method

Calculate the evapotranspiration reduction factor for the elevated and lowland regions.

Requires the control parameters:

Zeta1 Zeta2

Requires the derived parameters:

NUGE NUG

Requires the state sequences:

DVE DV

Calculates the aide sequences:

BetaE Beta

Basic equation for the lowland region (the elevated region is handled analogous):

\(Beta = \frac{1 - x}{1 + x} \cdot \frac{1}{2} + \frac{1}{2}\)

\(x = exp \left( Zeta1 \cdot (DV - Zeta2) \right)\)

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> zeta1(0.02)
>>> zeta2(400.0)

>>> derived.nuge(1)
>>> derived.nug(1)
>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model=model,
...     method=model.calc_betae_beta_v1,
...     last_example=12,
...     parseqs=(states.dve, states.dv, aides.betae, aides.beta)
... )
>>> test.nexts.dve = (
...     -100.0, 0.0, 100.0, 200.0, 300.0, 400.0,
...     500.0, 600.0, 700.0, 800.0, 900.0, 100000.0
... )
>>> test.nexts.dv = tuple(reversed(test.nexts.dve))
>>> test()
| ex. |      dve |       dv |    betae |     beta |
---------------------------------------------------
|   1 |   -100.0 | 100000.0 | 0.999955 |      0.0 |
|   2 |      0.0 |    900.0 | 0.999665 | 0.000045 |
|   3 |    100.0 |    800.0 | 0.997527 | 0.000335 |
|   4 |    200.0 |    700.0 | 0.982014 | 0.002473 |
|   5 |    300.0 |    600.0 | 0.880797 | 0.017986 |
|   6 |    400.0 |    500.0 |      0.5 | 0.119203 |
|   7 |    500.0 |    400.0 | 0.119203 |      0.5 |
|   8 |    600.0 |    300.0 | 0.017986 | 0.880797 |
|   9 |    700.0 |    200.0 | 0.002473 | 0.982014 |
|  10 |    800.0 |    100.0 | 0.000335 | 0.997527 |
|  11 |    900.0 |      0.0 | 0.000045 | 0.999665 |
|  12 | 100000.0 |   -100.0 |      0.0 | 0.999955 |

>>> derived.nuge(0)
>>> derived.nug(0)
>>> model.calc_betae_beta_v1()
>>> aides.betae
betae(nan)
>>> aides.beta
beta(nan)

class hydpy.models.wland.wland_model.Calc_ETVE_ETV_V1[source]¶

Bases: Method

Calculate the actual evapotranspiration from the elevated and lowland regions’ vadose zone.

Requires the control parameters:: LT ER AUR
Requires the derived parameters:: NUL AGRE AGR
Requires the flux sequences:: PE PET EI
Requires the aide sequences:: BetaE Beta
Calculates the flux sequences:: ETVE ETV

The following equation uses the Wigmosta et al. (1994) approach to extend the original WALRUS equation to cope with different potential values for PE and PET. (See the documentation on method Update_SoilEvapotranspiration_V3, which covers the corner cases of this approach in more detail.)

Basic equation for the lowland region (the elevated region is handled analogous):: \[\begin{split}ETV = \sum_{i=1}^{NUL} \frac{AUR_i}{AGR} \cdot \frac{PE_i - EI_i}{PE_i} \cdot PET_i \cdot \begin{cases} 0 &|\ LT_i = SEALED \\ Beta &|\ LT_i \neq SEALED \end{cases}\end{split}\]

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(4)
>>> lt(FIELD, SOIL, SEALED, WATER)
>>> aur(0.2, 0.2, 0.1, 0.5)
>>> fluxes.pe = 5.0
>>> fluxes.pet = 4.0
>>> fluxes.ei = 1.0, 3.0, 2.0, 0.0
>>> aides.betae = 0.75
>>> aides.beta = 0.25
>>> derived.nul.update()

>>> er(True)
>>> derived.agr.update()
>>> derived.agre.update()
>>> model.calc_etve_etv_v1()
>>> fluxes.etve
etve(1.8)

>>> er(False)
>>> derived.agr.update()
>>> derived.agre.update()
>>> model.calc_etve_etv_v1()
>>> fluxes.etv
etv(0.6)

class hydpy.models.wland.wland_model.Calc_ES_V1[source]¶

Bases: Method

Calculate the actual evaporation from the surface water reservoir.

Requires the derived parameters:: NUL RH1
Requires the flux sequence:: PE
Requires the state sequence:: HS
Calculates the flux sequence:: ES
Basic equation (discontinous):: \[\begin{split}ES = \begin{cases} PE &|\ HS > 0 \\ 0 &|\ HS \leq 0 \end{cases}\end{split}\]

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(2)
>>> derived.nul.update()
>>> fluxes.pe = 3.0, 5.0
>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model=model,
...     method=model.calc_es_v1,
...     last_example=9,
...     parseqs=(states.hs, fluxes.es)
... )
>>> test.nexts.hs = -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0

Without smoothing:

>>> sh(0.0)
>>> derived.rh1.update()
>>> test()
| ex. |   hs |  es |
--------------------
|   1 | -4.0 | 0.0 |
|   2 | -3.0 | 0.0 |
|   3 | -2.0 | 0.0 |
|   4 | -1.0 | 0.0 |
|   5 |  0.0 | 2.5 |
|   6 |  1.0 | 5.0 |
|   7 |  2.0 | 5.0 |
|   8 |  3.0 | 5.0 |
|   9 |  4.0 | 5.0 |

With smoothing:

>>> sh(1.0)
>>> derived.rh1.update()
>>> test()
| ex. |   hs |       es |
-------------------------
|   1 | -4.0 |      0.0 |
|   2 | -3.0 | 0.000005 |
|   3 | -2.0 |  0.00051 |
|   4 | -1.0 |     0.05 |
|   5 |  0.0 |      2.5 |
|   6 |  1.0 |     4.95 |
|   7 |  2.0 |  4.99949 |
|   8 |  3.0 | 4.999995 |
|   9 |  4.0 |      5.0 |

class hydpy.models.wland.wland_model.Calc_ET_V1[source]¶

Bases: Method

Calculate the total actual evapotranspiration.

Requires the control parameter:: AUR
Requires the derived parameters:: NUL ASR AGRE AGR
Requires the flux sequences:: EI ETVE ETV ES
Calculates the flux sequence:: ET
Basic equation:: \(ET = ASR \cdot ES + AGRE \cdot ETV\!E + AGR \cdot ETV + \sum_{i=1}^{NUL} AUR_i \cdot EI_i\)

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(3)
>>> lt(FIELD, SEALED, WATER)
>>> aur(0.5, 0.3, 0.2)
>>> er(False)
>>> derived.nul.update()
>>> derived.asr.update()
>>> derived.agr.update()
>>> derived.agre.update()
>>> fluxes.ei = 1.0, 2.0, 0.0
>>> fluxes.etv = 3.0
>>> fluxes.etve = 5.0
>>> fluxes.es = 4.0
>>> model.calc_et_v1()
>>> fluxes.et
et(3.4)

class hydpy.models.wland.wland_model.Calc_DVEq_V1[source]¶

Bases: Method

Calculate the equilibrium storage deficit of the vadose zone.

Requires the control parameters:: ThetaS PsiAE B
Requires the derived parameter:: NUG
Requires the state sequence:: DG
Calculates the aide sequence:: DVEq
Basic equation (discontinuous):: \[\begin{split}DV\!Eq = \begin{cases} 0 &|\ DG \leq PsiAE \\ ThetaS \cdot \left( DG - \frac{DG^{1-1/b}}{(1-1/b) \cdot PsiAE^{-1/B}} - \frac{PsiAE}{1-B} \right) &|\ PsiAE < DG \end{cases}\end{split}\]

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> thetas(0.4)
>>> psiae(300.0)
>>> b(5.0)
>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model=model,
...     method=model.calc_dveq_v1,
...     last_example=6,
...     parseqs=(states.dg, aides.dveq)
... )
>>> test.nexts.dg = 200.0, 300.0, 400.0, 800.0, 1600.0, 3200.0

Without smoothing:

>>> test()
| ex. |     dg |       dveq |
-----------------------------
|   1 |  200.0 |        0.0 |
|   2 |  300.0 |        0.0 |
|   3 |  400.0 |   1.182498 |
|   4 |  800.0 |  21.249634 |
|   5 | 1600.0 |  97.612368 |
|   6 | 3200.0 | 313.415248 |

class hydpy.models.wland.wland_model.Return_DVH_V1[source]¶

Bases: Method

Return the storage deficit of the vadose zone at a specific height above the groundwater table.

Required by the method:: Calc_DVEq_V2
Requires the control parameters:: ThetaS PsiAE B
Requires the derived parameter:: RH1
Basic equation (discontinous):: \[\begin{split}DVH = \begin{cases} 0 &|\ DG \leq PsiAE \\ ThetaS \cdot \left(1 - \left( \frac{h}{PsiAE} \right)^{-1/b} \right) &|\ PsiAE < DG \end{cases}\end{split}\]

This power law is the differential of the equation underlying method Calc_DVEq_V1 with respect to height. Brauer et al. (2014) also cites it (equation 6) but does not use it directly.

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> thetas(0.4)
>>> psiae(300.0)
>>> b(5.0)

With smoothing:

>>> from hydpy import repr_
>>> sh(0.0)
>>> derived.rh1.update()
>>> for h in [200.0, 299.0, 300.0, 301.0, 400.0, 500.0, 600.0]:
...     print(repr_(h), repr_(model.return_dvh_v1(h)))
200.0 0.0
299.0 0.0
300.0 0.0
301.0 0.000266
400.0 0.022365
500.0 0.038848
600.0 0.05178

Without smoothing:

>>> sh(1.0)
>>> derived.rh1.update()
>>> for h in [200.0, 299.0, 300.0, 301.0, 400.0, 500.0, 600.0]:
...     print(repr_(h), repr_(model.return_dvh_v1(h)))
200.0 0.0
299.0 0.000001
300.0 0.00004
301.0 0.000267
400.0 0.022365
500.0 0.038848
600.0 0.05178

class hydpy.models.wland.wland_model.Calc_DVEq_V2[source]¶

Bases: Method

Calculate the equilibrium storage deficit of the vadose zone.

Required submethod:: Return_DVH_V1
Requires the control parameters:: ThetaS PsiAE B SH
Requires the derived parameters:: NUG RH1
Requires the state sequence:: DG
Calculates the aide sequence:: DVEq
Basic equation:: \(DHEq = \int_{0}^{DG} Return\_DVH\_V1(h) \ \ dh\)

Method Calc_DVEq_V2 integrates Return_DVH_V1 numerically, based on the Lobatto-Gauß quadrature. Hence, it should give nearly identical results as method Calc_DVEq_V1, which provides the analytical solution to the underlying power law. The benefit of method Calc_DVEq_V2 is that it supports the regularisation of Return_DVH_V1, which Calc_DVEq_V1 does not. In our experience, this benefit does not justify the additional numerical cost. However, we keep it for educational purposes, mainly as a starting point to implement alternative relationships between the soil water deficit and the groundwater table that we cannot solve analytically.

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> derived.nug(0)
>>> model.calc_dveq_v2()
>>> aides.dveq
dveq(nan)

>>> derived.nug(1)
>>> thetas(0.4)
>>> psiae(300.0)
>>> b(5.0)
>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model=model,
...     method=model.calc_dveq_v2,
...     last_example=8,
...     parseqs=(states.dg, aides.dveq)
... )
>>> test.nexts.dg = 200.0, 299.0, 300.0, 301.0, 400.0, 800.0, 1600.0, 3200.0

Without smoothing:

>>> sh(0.0)
>>> derived.rh1.update()
>>> test()
| ex. |     dg |       dveq |
-----------------------------
|   1 |  200.0 |        0.0 |
|   2 |  299.0 |        0.0 |
|   3 |  300.0 |        0.0 |
|   4 |  301.0 |   0.000133 |
|   5 |  400.0 |   1.182498 |
|   6 |  800.0 |  21.249634 |
|   7 | 1600.0 |  97.612368 |
|   8 | 3200.0 | 313.415248 |

With smoothing:

>>> sh(1.0)
>>> derived.rh1.update()
>>> test()
| ex. |     dg |       dveq |
-----------------------------
|   1 |  200.0 |        0.0 |
|   2 |  299.0 |        0.0 |
|   3 |  300.0 |   0.000033 |
|   4 |  301.0 |   0.000176 |
|   5 |  400.0 |   1.182542 |
|   6 |  800.0 |   21.24972 |
|   7 | 1600.0 |  97.612538 |
|   8 | 3200.0 | 313.415588 |

class hydpy.models.wland.wland_model.Calc_DVEq_V3[source]¶

Bases: Method

Calculate the equilibrium storage deficit of the vadose zone.

Required by the method:: Return_ErrorDV_V1
Requires the control parameters:: ThetaS ThetaR PsiAE B
Requires the derived parameter:: NUG
Requires the state sequence:: DG
Calculates the aide sequence:: DVEq
Basic equation (discontinuous):: \[\begin{split}DHEq = ThetaR \cdot DG + \begin{cases} 0 &|\ DG \leq PsiAE \\ ThetaS \cdot \left( DG - \frac{DG^{1-1/b}}{(1-1/b) \cdot PsiAE^{-1/B}} - \frac{PsiAE}{1-B} \right) &|\ PsiAE < DG \end{cases}\end{split}\]

Method Calc_DVEq_V3 extends the original WALRUS relationship between the groundwater depth and the equilibrium water deficit of the vadose zone defined by equation 5 of Brauer et al. (2014) and implemented into application model wland by method Calc_DVEq_V1. Parameter ThetaR introduces a (small) amount of water to fill the tension-saturated area directly above the groundwater table. This “residual saturation” allows the direct injection of water into groundwater without risking infinitely fast groundwater depth changes.

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> thetas(0.4)
>>> thetar(0.01)
>>> psiae(300.0)
>>> b(5.0)
>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model=model,
...     method=model.calc_dveq_v3,
...     last_example=8,
...     parseqs=(states.dg, aides.dveq)
... )
>>> test.nexts.dg = 200.0, 299.0, 300.0, 301.0, 400.0, 800.0, 1600.0, 3200.0

Without smoothing:

>>> test()
| ex. |     dg |       dveq |
-----------------------------
|   1 |  200.0 |        2.0 |
|   2 |  299.0 |       2.99 |
|   3 |  300.0 |        3.0 |
|   4 |  301.0 |    3.01013 |
|   5 |  400.0 |   5.152935 |
|   6 |  800.0 |  28.718393 |
|   7 | 1600.0 | 111.172058 |
|   8 | 3200.0 | 337.579867 |

class hydpy.models.wland.wland_model.Return_DVH_V2[source]¶

Bases: Method

Return the storage deficit of the vadose zone at a specific height above the groundwater table.

Required by the methods:: Calc_DVEq_V4 Calc_GF_V1
Requires the control parameters:: ThetaS ThetaR PsiAE B
Requires the derived parameter:: RH1
Basic equation (discontinous):: \[\begin{split}DVH = ThetaR + \begin{cases} 0 &|\ DG \leq PsiAE \\ (ThetaS-ThetaR) \cdot \left(1 - \left( \frac{h}{PsiAE} \right)^{-1/b} \right) &|\ PsiAE < DG \end{cases}\end{split}\]

The given equation is the differential of the equation underlying method Calc_DVEq_V3 with respect to height.

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> thetas(0.4)
>>> thetar(0.01)
>>> psiae(300.0)
>>> b(5.0)

With smoothing:

>>> from hydpy import repr_
>>> sh(0.0)
>>> derived.rh1.update()
>>> for h in [200.0, 299.0, 300.0, 301.0, 400.0, 500.0, 600.0]:
...     print(repr_(h), repr_(model.return_dvh_v2(h)))
200.0 0.01
299.0 0.01
300.0 0.01
301.0 0.010259
400.0 0.031806
500.0 0.047877
600.0 0.060485

Without smoothing:

>>> sh(1.0)
>>> derived.rh1.update()
>>> for h in [200.0, 299.0, 300.0, 301.0, 400.0, 500.0, 600.0]:
...     print(repr_(h), repr_(model.return_dvh_v2(h)))
200.0 0.01
299.0 0.010001
300.0 0.010039
301.0 0.01026
400.0 0.031806
500.0 0.047877
600.0 0.060485

class hydpy.models.wland.wland_model.Calc_DVEq_V4[source]¶

Bases: Method

Calculate the equilibrium storage deficit of the vadose zone.

Required submethod:: Return_DVH_V2
Requires the control parameters:: ThetaS ThetaR PsiAE B SH
Requires the derived parameters:: NUG RH1
Requires the state sequence:: DG
Calculates the aide sequence:: DVEq
Basic equation:: \(DHEq = \int_{0}^{DG} Return\_DVH\_V2(h) \ \ dh\)

Method Calc_DVEq_V4 integrates Return_DVH_V2 numerically based on the Lobatto-Gauß quadrature. The short discussion in the documentation on Calc_DVEq_V2 (which integrates Return_DVH_V1) also applies to Calc_DVEq_V4.

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> derived.nug(0)
>>> model.calc_dveq_v4()
>>> aides.dveq
dveq(nan)

>>> derived.nug(1)
>>> thetas(0.4)
>>> thetar(0.01)
>>> psiae(300.0)
>>> b(5.0)
>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model=model,
...     method=model.calc_dveq_v4,
...     last_example=8,
...     parseqs=(states.dg, aides.dveq)
... )
>>> test.nexts.dg = 200.0, 299.0, 300.0, 301.0, 400.0, 800.0, 1600.0, 3200.0

Without smoothing:

>>> sh(0.0)
>>> derived.rh1.update()
>>> test()
| ex. |     dg |       dveq |
-----------------------------
|   1 |  200.0 |        2.0 |
|   2 |  299.0 |       2.99 |
|   3 |  300.0 |        3.0 |
|   4 |  301.0 |    3.01013 |
|   5 |  400.0 |   5.152935 |
|   6 |  800.0 |  28.718393 |
|   7 | 1600.0 | 111.172058 |
|   8 | 3200.0 | 337.579867 |

With smoothing:

>>> sh(1.0)
>>> derived.rh1.update()
>>> test()
| ex. |     dg |       dveq |
-----------------------------
|   1 |  200.0 |        2.1 |
|   2 |  299.0 |       3.09 |
|   3 |  300.0 |   3.100032 |
|   4 |  301.0 |   3.110172 |
|   5 |  400.0 |   5.252979 |
|   6 |  800.0 |  28.818477 |
|   7 | 1600.0 | 111.272224 |
|   8 | 3200.0 | 337.680198 |

class hydpy.models.wland.wland_model.Return_ErrorDV_V1[source]¶

Bases: Method

Calculate the difference between the equilibrium and the actual storage deficit of the vadose zone.

Required by the method:: Calc_DGEq_V1
Required submethod:: Calc_DVEq_V3
Requires the control parameters:: ThetaS ThetaR PsiAE B
Requires the derived parameter:: NUG
Requires the state sequence:: DV
Basic equation:: \(DV\!Eq_{Calc\_DV\!Eq\_V3} - DV\)

Method Return_ErrorDV_V1 uses Calc_DVEq_V3 to calculate the equilibrium deficit corresponding to the current groundwater depth. The following example shows that it resets the values DG and DVEq, which it needs to change temporarily, to their original states.

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> thetas(0.4)
>>> thetar(0.01)
>>> psiae(300.0)
>>> b(5.0)
>>> states.dg = -9.0
>>> aides.dveq = -99.0
>>> states.dv = 3.152935
>>> from hydpy import round_
>>> round_(model.return_errordv_v1(400.0))
2.0
>>> states.dg
dg(-9.0)
>>> aides.dveq
dveq(-99.0)

Technical checks:

As mentioned above, method Return_ErrorDV_V1 changes the values of the sequences DG and DVEq, but only temporarily. Hence, we do not include them in the method specifications, even if the following check considers this erroneous:
>>> from hydpy.core.testtools import check_selectedvariables
>>> from hydpy.models.wland.wland_model import Return_ErrorDV_V1
>>> print(check_selectedvariables(Return_ErrorDV_V1))
Definitely missing: dg and dveq
Possibly missing (REQUIREDSEQUENCES):
    Calc_DVEq_V3: DG
Possibly missing (RESULTSEQUENCES):
    Calc_DVEq_V3: DVEq

class hydpy.models.wland.wland_model.Calc_DGEq_V1[source]¶

Bases: Method

Calculate the equilibrium groundwater depth.

Required submethod:: Return_ErrorDV_V1
Requires the control parameters:: ThetaS ThetaR PsiAE B
Requires the derived parameter:: NUG
Requires the state sequence:: DV
Calculates the aide sequence:: DGEq

Method Calc_DGEq_V1 calculates the equilibrium groundwater depth for the current water deficit of the vadose zone, following methods Return_DVH_V2 and Calc_DVEq_V3. As we are not aware of an analytical solution, we solve it numerically via class PegasusDGEq, which performs an iterative root-search based on the Pegasus method.

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> thetas(0.4)
>>> thetar(0.01)
>>> psiae(300.0)
>>> b(5.0)
>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model=model,
...     method=model.calc_dgeq_v1,
...     last_example=13,
...     parseqs=(states.dv, aides.dgeq)
... )
>>> test.nexts.dv = (
...     -1.0, -0.01, 0.0, 0.01, 1.0, 2.0, 2.99, 3.0,
...     3.01012983, 5.1529353, 28.71839324, 111.1720584, 337.5798671)
>>> test()
| ex. |         dv |   dgeq |
-----------------------------
|   1 |       -1.0 |    0.0 |
|   2 |      -0.01 |    0.0 |
|   3 |        0.0 |    0.0 |
|   4 |       0.01 |    1.0 |
|   5 |        1.0 |  100.0 |
|   6 |        2.0 |  200.0 |
|   7 |       2.99 |  299.0 |
|   8 |        3.0 |  300.0 |
|   9 |    3.01013 |  301.0 |
|  10 |   5.152935 |  400.0 |
|  11 |  28.718393 |  800.0 |
|  12 | 111.172058 | 1600.0 |
|  13 | 337.579867 | 3200.0 |

class hydpy.models.wland.wland_model.Calc_GF_V1[source]¶

Bases: Method

Calculate the gain factor for changes in groundwater depth.

Required submethod:: Return_DVH_V2
Requires the control parameters:: ThetaS ThetaR PsiAE B
Requires the derived parameter:: RH1
Requires the state sequence:: DG
Requires the aide sequence:: DGEq
Calculates the aide sequence:: GF
Basic equation (discontinuous):: \[\begin{split}GF = \begin{cases} 0 &|\ DG \leq 0 \\ Return\_DVH\_V2(DGEq - DG)^{-1} &|\ 0 < DG \end{cases}\end{split}\]

The original WALRUS model attributes a passive role to groundwater dynamics. All water entering or leaving the underground is added to or subtracted from the vadose zone, and the groundwater table only reacts to such changes until it is in equilibrium with the updated water deficit in the vadose zone. Hence, the movement of the groundwater table is generally slow. However, in catchments with near-surface water tables, we often observe fast responses of groundwater to input forcings, maybe due to rapid infiltration along macropores or the re-infiltration of channel water. In such situations, where the input water somehow bypasses the vadose zone, the speed of the rise of the groundwater table depends not only on the effective pore size of the soil material but also on the soil’s degree of saturation directly above the groundwater table. The smaller the remaining pore size, the larger the fraction between the water table’s rise and the actual groundwater recharge. We call this fraction the “gain factor” (GF).

The WALRUS model does not explicitly account for the soil moisture in different depths above the groundwater table. To keep the vertically lumped approach, we use the difference between the actual (DG) and the equilibrium groundwater depth (DGEq) as an indicator for the wetness above the groundwater table. When DG is identical to DGEq, soil moisture and groundwater are in equilibrium. Then, the tension-saturated area is fully developed, and the groundwater table moves quickly (depending on ThetaR). The opposite case is when DG is much smaller than DGEq. Such a situation occurs after a fast rise of the groundwater table when the soil water still needs much redistribution before it can be in equilibrium with groundwater. In the most extreme case, the gain factor is just as large as indicated by the effective pore size alone (depending on ThetaS).

The above discussion only applies as long as the groundwater table is below the soil surface. For large-scale ponding (see Brauer et al. (2014), section 5.11), we set GF to zero. See the documentation on the methods Calc_CDG_V1 and Calc_FGS_V1 for related discussions.

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> thetas(0.4)
>>> thetar(0.01)
>>> psiae(300.0)
>>> b(5.0)
>>> sh(0.0)
>>> aides.dgeq = 5000.0
>>> derived.rh1.update()
>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model=model,
...     method=model.calc_gf_v1,
...     last_example=16,
...     parseqs=(states.dg, aides.gf)
... )
>>> test.nexts.dg = (
...     -10.0, -1.0, 0.0, 1.0, 10.0,
...     1000.0, 2000.0, 3000.0, 4000.0, 4500.0, 4600.0,
...     4690.0, 4699.0, 4700.0, 4701.0, 4710.0)
>>> test()
| ex. |     dg |        gf |
----------------------------
|   1 |  -10.0 |       0.0 |
|   2 |   -1.0 |       0.0 |
|   3 |    0.0 |   2.81175 |
|   4 |    1.0 |  5.623782 |
|   5 |   10.0 |  5.626316 |
|   6 | 1000.0 |  5.963555 |
|   7 | 2000.0 |  6.496601 |
|   8 | 3000.0 |  7.510869 |
|   9 | 4000.0 | 10.699902 |
|  10 | 4500.0 |  20.88702 |
|  11 | 4600.0 | 31.440737 |
|  12 | 4690.0 | 79.686112 |
|  13 | 4699.0 | 97.470815 |
|  14 | 4700.0 |     100.0 |
|  15 | 4701.0 |     100.0 |
|  16 | 4710.0 |     100.0 |

>>> sh(1.0)
>>> derived.rh1.update()
>>> test()
| ex. |     dg |        gf |
----------------------------
|   1 |  -10.0 |       0.0 |
|   2 |   -1.0 |  0.056232 |
|   3 |    0.0 |   2.81175 |
|   4 |    1.0 |  5.567544 |
|   5 |   10.0 |  5.626316 |
|   6 | 1000.0 |  5.963555 |
|   7 | 2000.0 |  6.496601 |
|   8 | 3000.0 |  7.510869 |
|   9 | 4000.0 | 10.699902 |
|  10 | 4500.0 |  20.88702 |
|  11 | 4600.0 | 31.440737 |
|  12 | 4690.0 | 79.686112 |
|  13 | 4699.0 | 97.465434 |
|  14 | 4700.0 | 99.609455 |
|  15 | 4701.0 | 99.994314 |
|  16 | 4710.0 |     100.0 |

class hydpy.models.wland.wland_model.Calc_GR_V1[source]¶

Bases: Method

Calculate the elevated region’s groundwater recharge.

Requires the control parameter:: AC
Requires the derived parameters:: NUGE RH2
Requires the state sequence:: DVE
Calculates the flux sequence:: GR

Basic equations (discontinous):

\[\begin{split}GR = \begin{cases} 0 &|\ AC \leq DV\!E \\ AC - DV\!E &|\ AC > DV\!E \end{cases}\end{split}\]

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> ac(200.0)
>>> rg(False)
>>> from hydpy import UnitTest
>>> test = UnitTest(model=model,
...                 method=model.calc_gr_v1,
...                 last_example=7,
...                 parseqs=(states.dve, fluxes.gr))
>>> test.nexts.dve = (100.0, 190.0, 199.0, 200.0, 201.0, 210.0, 300.0)

Discontinuous example:

>>> sh(0.0)
>>> derived.rh2.update()
>>> test()
| ex. |   dve |    gr |
-----------------------
|   1 | 100.0 | 100.0 |
|   2 | 190.0 |  10.0 |
|   3 | 199.0 |   1.0 |
|   4 | 200.0 |   0.0 |
|   5 | 201.0 |   0.0 |
|   6 | 210.0 |   0.0 |
|   7 | 300.0 |   0.0 |

Continuous example:

>>> sh(10.0)
>>> derived.rh2.update()
>>> test()
| ex. |   dve |       gr |
--------------------------
|   1 | 100.0 |    100.0 |
|   2 | 190.0 |    10.01 |
|   3 | 199.0 | 1.885788 |
|   4 | 200.0 | 1.320935 |
|   5 | 201.0 | 0.885788 |
|   6 | 210.0 |     0.01 |
|   7 | 300.0 |      0.0 |

class hydpy.models.wland.wland_model.Calc_CDG_V1[source]¶

Bases: Method

Calculate the change in the groundwater depth due to percolation and capillary rise.

Requires the control parameters:: CV ThetaS DGC
Requires the derived parameters:: NUG RH1
Requires the flux sequences:: FGS FGSE FXG
Requires the state sequences:: DG DV
Requires the aide sequence:: DVEq
Calculates the flux sequence:: CDG
Basic equation (discontinuous):: \[\begin{split}CDG = \frac{DV - min(DV\!Eq, \ DG)}{CV} + \begin{cases} \frac{FGS - FGSE - FXG}{ThetaS} &|\ DGC \\ 0 &|\ \overline{DGC} \end{cases}\end{split}\]

Note that this equation differs in two respects from equation 6 of Brauer et al. (2014).

First, in the case of large-scale ponding, DVEq always stays at zero, and we let DG take control of the speed of the water table movement. See the documentation on method Calc_FGS_V1 for additional information on the differences between wland and WALRUS for this rare situation.

Second, one can set DGC to True to enforce a more direct connection between the groundwater and surface water storage level. According to Brauer et al. (2014), groundwater drainage and extraction increase and surface water infiltration and seepage decrease the water deficit in the vadose zone but do not change groundwater depth directly. This abstraction is as if, for example, groundwater drainage would take water from the soil’s top. The groundwater level only reacts with some delay due to its tendency to advance towards the increased equilibrium depth. With DGC enabled, the mentioned fluxes change the vadose zone’s deficit and the groundwater depth simultaneously.

Examples:

Without large-scale ponding and a direct groundwater connection:

>>> from hydpy.models.wland import *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> dgc(False)
>>> cv(10.0)
>>> thetas(0.5)
>>> sh(0.0)
>>> derived.rh1.update()
>>> states.dv = 100.0
>>> states.dg = 1000.0
>>> fluxes.fgs = 2.0
>>> fluxes.fgse = 0.5
>>> fluxes.fxg = 2.5
>>> aides.dveq = 80.0
>>> model.calc_cdg_v1()
>>> fluxes.cdg
cdg(1.0)

Without large-scale ponding and with a direct groundwater connection:

>>> dgc(True)
>>> model.calc_cdg_v1()
>>> fluxes.cdg
cdg(-1.0)

With large-scale ponding and without smoothing:

>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model=model,
...     method=model.calc_cdg_v1,
...     last_example=5,
...     parseqs=(states.dg, fluxes.cdg)
... )
>>> dgc(False)
>>> states.dv = -10.0
>>> aides.dveq = 0.0
>>> test.nexts.dg = 10.0, 1.0, 0.0, -1.0, -10.0
>>> test()
| ex. |    dg |   cdg |
-----------------------
|   1 |  10.0 |  -0.5 |
|   2 |   1.0 |  -0.5 |
|   3 |   0.0 |  -0.5 |
|   4 |  -1.0 | -0.45 |
|   5 | -10.0 |   0.0 |

With large-scale ponding and smoothing:

>>> sh(1.0)
>>> derived.rh1.update()
>>> test()
| ex. |    dg |       cdg |
---------------------------
|   1 |  10.0 |      -0.5 |
|   2 |   1.0 | -0.499891 |
|   3 |   0.0 | -0.492458 |
|   4 |  -1.0 | -0.449891 |
|   5 | -10.0 |       0.0 |

class hydpy.models.wland.wland_model.Calc_CDG_V2[source]¶

Bases: Method

Calculate the vadose zone’s storage deficit change due to percolation, capillary rise, macropore infiltration, seepage, groundwater flow, and channel water infiltration.

Requires the control parameter:: CV
Requires the derived parameters:: NUG RH1
Requires the flux sequences:: PV FGS FGSE FXG
Requires the state sequences:: DG DV
Requires the aide sequences:: DVEq GF
Calculates the flux sequence:: CDG
Basic equation:: \(CDG = \frac{DV-min(DV\!Eq, \ DG)}{CV} + GF \cdot \big( FGS - FGSE - PV - FXG \big)\)

Method Calc_CDG_V2 extends Calc_CDG_V1, which implements the (nearly) original WALRUS relationship defined by equation 6 of Brauer et al. (2014)). See the documentation on method Calc_GF_V1 for a comprehensive explanation of the reason for this extension.

Examples:

Without large-scale ponding:

>>> from hydpy.models.wland import *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> cv(10.0)
>>> sh(0.0)
>>> derived.rh1.update()
>>> states.dv = 100.0
>>> states.dg = 1000.0
>>> fluxes.pv = 1.0
>>> fluxes.fxg = 0.5
>>> fluxes.fgse = 1.5
>>> fluxes.fgs = 4.0
>>> aides.dveq = 80.0
>>> aides.gf = 2.0
>>> model.calc_cdg_v2()
>>> fluxes.cdg
cdg(3.0)

With large-scale ponding and without smoothing:

>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model=model,
...     method=model.calc_cdg_v2,
...     last_example=5,
...     parseqs=(states.dg, fluxes.cdg)
... )
>>> aides.gf = 0.0
>>> states.dv = -10.0
>>> aides.dveq = 0.0
>>> test.nexts.dg = 10.0, 1.0, 0.0, -1.0, -10.0
>>> test()
| ex. |    dg |   cdg |
-----------------------
|   1 |  10.0 |  -0.5 |
|   2 |   1.0 |  -0.5 |
|   3 |   0.0 |  -0.5 |
|   4 |  -1.0 | -0.45 |
|   5 | -10.0 |   0.0 |

With large-scale ponding and with smoothing:

>>> sh(1.0)
>>> derived.rh1.update()
>>> test()
| ex. |    dg |       cdg |
---------------------------
|   1 |  10.0 |      -0.5 |
|   2 |   1.0 | -0.499891 |
|   3 |   0.0 | -0.492458 |
|   4 |  -1.0 | -0.449891 |
|   5 | -10.0 |       0.0 |

class hydpy.models.wland.wland_model.Calc_FGSE_V1[source]¶

Bases: Method

Calculate the groundwater flow between the elevated and the lowland regions.

Requires the control parameters:: GL CGE
Requires the derived parameter:: NUGE
Requires the state sequences:: HGE DG
Calculates the flux sequence:: FGSE

The basic equation of method Calc_FGSE_V1 relies on the one of Calc_FGS_V1 introduced by Brauer et al. (2014). We decided so to calculate FGSE in a WALRUS-like manner.

Basic equation:

\[\begin{split}FGSE = \frac{\Delta \cdot |\Delta|}{CGE} \\\\ \Delta = HGE - (1000 \cdot GL - DG)\end{split}\]

Examples:

>>> from hydpy.models.wland import *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> gl(5.0)
>>> cge(1000000.0)
>>> states.dg = 3000.0

Normal flow:

>>> states.hge = 4000.0
>>> model.calc_fgse_v1()
>>> fluxes.fgse
fgse(2.0)

No flow:

>>> states.hge = 2000.0
>>> model.calc_fgse_v1()
>>> fluxes.fgse
fgse(0.0)

Reversed flow:

>>> states.hge = 0.0
>>> model.calc_fgse_v1()
>>> fluxes.fgse
fgse(-2.0)

class hydpy.models.wland.wland_model.Calc_FGS_V1[source]¶

Bases: Method

Calculate the groundwater drainage or surface water infiltration.

Requires the control parameters:: CG RG CGF
Requires the derived parameters:: CD NUG RH2
Requires the state sequences:: DG HS
Calculates the flux sequence:: FGS

For large-scale ponding, wland and WALRUS calculate FGS differently (even for discontinuous parameterisations). In such cases, he WALRUS model redistributes water instantaneously (see Brauer et al. (2014), section 5.11), which relates to infinitely high flow velocities and cannot be handled by the numerical integration algorithm underlying wland. Hence, we introduce the parameter CGF instead. Setting it to a value larger than zero increases the flow velocity with increasing large-scale ponding. The larger the value of CGF, the stronger the functional similarity of both approaches. But note that very high values can result in increased computation times.

Basic equations (discontinous):

\[\begin{split}FGS = Gradient \cdot ContactSurface \cdot Conductivity \\ \\ HG^* = max(CD - DG, \ 0) \\ HS^* = max(HS, \ 0) \\ Gradient = \begin{cases} HG^* - HS^* &|\ RG \\ CD - DG - HS^* &|\ \overline{RG} \\ \end{cases} \\ ContactSurface = \begin{cases} |HG^* - HS^*| &|\ RG \\ max(HG^*, \ HS^*) &|\ \overline{RG} \\ \end{cases} \\ Excess = max(-DG, HS - CD, \ 0) \\ Conductivity = (1 + CGF \cdot Excess) / CG\end{split}\]

Examples:

>>> from hydpy.models.wland import *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> cg(10000.0)
>>> rg(False)
>>> derived.cd(600.0)
>>> states.hs = 300.0
>>> from hydpy import UnitTest
>>> test = UnitTest(model=model,
...                 method=model.calc_fgs_v1,
...                 last_example=15,
...                 parseqs=(states.dg, states.hs, fluxes.fgs))
>>> test.nexts.dg = (
...     -100.0, -1.0, 0.0, 1.0, 100.0, 200.0, 290.0, 299.0,
...     300.0, 301.0, 310.0, 400.0, 500.0, 600.0, 700.0)

Without smoothing and without increased conductivity for large-scale ponding:

>>> cgf(0.0)
>>> sh(0.0)
>>> derived.rh2.update()
>>> test()
| ex. |     dg |    hs |     fgs |
----------------------------------
|   1 | -100.0 | 300.0 |    14.0 |
|   2 |   -1.0 | 300.0 | 9.04505 |
|   3 |    0.0 | 300.0 |     9.0 |
|   4 |    1.0 | 300.0 | 8.95505 |
|   5 |  100.0 | 300.0 |     5.0 |
|   6 |  200.0 | 300.0 |     2.0 |
|   7 |  290.0 | 300.0 |   0.155 |
|   8 |  299.0 | 300.0 | 0.01505 |
|   9 |  300.0 | 300.0 |     0.0 |
|  10 |  301.0 | 300.0 |  -0.015 |
|  11 |  310.0 | 300.0 |   -0.15 |
|  12 |  400.0 | 300.0 |    -1.5 |
|  13 |  500.0 | 300.0 |    -3.0 |
|  14 |  600.0 | 300.0 |    -4.5 |
|  15 |  700.0 | 300.0 |    -6.0 |

Without smoothing but with increased conductivity for large-scale ponding:

>>> cgf(0.1)
>>> test()
| ex. |     dg |    hs |      fgs |
-----------------------------------
|   1 | -100.0 | 300.0 |    294.0 |
|   2 |   -1.0 | 300.0 | 10.85406 |
|   3 |    0.0 | 300.0 |      9.0 |
|   4 |    1.0 | 300.0 |  8.95505 |
|   5 |  100.0 | 300.0 |      5.0 |
|   6 |  200.0 | 300.0 |      2.0 |
|   7 |  290.0 | 300.0 |    0.155 |
|   8 |  299.0 | 300.0 |  0.01505 |
|   9 |  300.0 | 300.0 |      0.0 |
|  10 |  301.0 | 300.0 |   -0.015 |
|  11 |  310.0 | 300.0 |    -0.15 |
|  12 |  400.0 | 300.0 |     -1.5 |
|  13 |  500.0 | 300.0 |     -3.0 |
|  14 |  600.0 | 300.0 |     -4.5 |
|  15 |  700.0 | 300.0 |     -6.0 |

With smoothing and with increased conductivity for large-scale ponding:

>>> sh(1.0)
>>> derived.rh2.update()
>>> test()
| ex. |     dg |    hs |      fgs |
-----------------------------------
|   1 | -100.0 | 300.0 |    294.0 |
|   2 |   -1.0 | 300.0 | 10.87215 |
|   3 |    0.0 | 300.0 | 9.369944 |
|   4 |    1.0 | 300.0 |  8.97296 |
|   5 |  100.0 | 300.0 |      5.0 |
|   6 |  200.0 | 300.0 |      2.0 |
|   7 |  290.0 | 300.0 |    0.155 |
|   8 |  299.0 | 300.0 |  0.01505 |
|   9 |  300.0 | 300.0 |      0.0 |
|  10 |  301.0 | 300.0 |   -0.015 |
|  11 |  310.0 | 300.0 |    -0.15 |
|  12 |  400.0 | 300.0 |     -1.5 |
|  13 |  500.0 | 300.0 |     -3.0 |
|  14 |  600.0 | 300.0 |     -4.5 |
|  15 |  700.0 | 300.0 |     -6.0 |

Another difference to the original WALRUS model is optional. Enabling the RG option restricts the FGS in two ways. First, the groundwater depth used for calculating the gradient between the surface and the groundwater level is restricted to the channel depth so that extremely low groundwater levels do not result in extremely high surface water infiltration. Second, the contact surface is restricted to the difference between the surface and the (restricted) groundwater level so that uncertainties in channel depth estimates have a less severe effect both on groundwater drainage and surface water infiltration:

>>> rg(True)
>>> test()
| ex. |     dg |    hs |       fgs |
------------------------------------
|   1 | -100.0 | 300.0 |     168.0 |
|   2 |   -1.0 | 300.0 |   5.44512 |
|   3 |    0.0 | 300.0 |  4.684972 |
|   4 |    1.0 | 300.0 |   4.47899 |
|   5 |  100.0 | 300.0 |       2.0 |
|   6 |  200.0 | 300.0 |       0.5 |
|   7 |  290.0 | 300.0 |     0.005 |
|   8 |  299.0 | 300.0 |   0.00005 |
|   9 |  300.0 | 300.0 |       0.0 |
|  10 |  301.0 | 300.0 |  -0.00005 |
|  11 |  310.0 | 300.0 |    -0.005 |
|  12 |  400.0 | 300.0 |      -0.5 |
|  13 |  500.0 | 300.0 |      -2.0 |
|  14 |  600.0 | 300.0 | -4.493836 |
|  15 |  700.0 | 300.0 |      -4.5 |

class hydpy.models.wland.wland_model.Calc_FQS_V1[source]¶

Bases: Method

Calculate the quickflow.

Requires the control parameters:: NU CQ
Requires the state sequence:: HQ
Calculates the flux sequence:: FQS
Basic equation:: \(FQS = \frac{HQ}{CQ}\)

Examples:

>>> from hydpy.models.wland import *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nu(2)
>>> cq(10.0)
>>> states.hq = 100.0
>>> model.calc_fqs_v1()
>>> fluxes.fqs
fqs(5.0)

Without land areas, quickflow is zero:

>>> nu(1)
>>> model.calc_fqs_v1()
>>> fluxes.fqs
fqs(0.0)

class hydpy.models.wland.wland_model.Calc_RH_V1[source]¶

Bases: Method

Let a submodel that complies with the DischargeModel_V2 interface calculate the runoff height or, if no such submodel is available, equate it with all other flows in and out of the surface water storage.

Requires the derived parameters:: ASR ALR AGR
Requires the flux sequences:: PS ES FXS FQS FGS
Requires the state sequence:: HS
Calculates the flux sequence:: RH
Basic equation (without submodel):: \(RH = ASR \cdot (PS - ES + FXS) + ALR \cdot FQS + AGR \cdot FGS\)

Examples:

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

Without an available submodel, Calc_RH_V1 applies the given basic equation:

>>> derived.asr(0.2)
>>> derived.alr(0.8)
>>> derived.agr(0.6)
>>> fluxes.ps = 3.0
>>> fluxes.fxs = 1.0
>>> fluxes.es = 2.0
>>> fluxes.fqs(0.5)
>>> fluxes.fgs(0.2)
>>> model.calc_rh_v1()
>>> fluxes.rh
rh(0.92)

We use wq_walrus, which implements WALRUS’ standard approach for calculating RH, to demonstrate that Calc_RH_V1 correctly uses submodels that follow the DischargeModel_V2 interface:

>>> sh(0.1)
>>> states.hs(3000.0)
>>> derived.cd(5000.0)
>>> with model.add_dischargemodel_v2("wq_walrus"):
...     crestheight(2.0)
...     bankfulldischarge(2.0)
...     dischargeexponent(2.0)
>>> model.calc_rh_v1()
>>> fluxes.rh
rh(0.111111)

class hydpy.models.wland.wland_model.Update_IC_V1[source]¶

Bases: Method

Update the interception storage.

Requires the derived parameter:: NUL
Requires the flux sequences:: PC TF EI
Updates the state sequence:: IC
Basic equation:: \(\frac{dIC}{dt} = PC - TF - EI\)

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(2)
>>> derived.nul.update()
>>> fluxes.pc = 2.0
>>> fluxes.tf = 1.0
>>> fluxes.ei = 3.0
>>> states.ic.old = 4.0
>>> model.update_ic_v1()
>>> states.ic
ic(2.0, 0.0)

class hydpy.models.wland.wland_model.Update_SP_V1[source]¶

Bases: Method

Update the storage deficit.

Requires the derived parameter:: NUL
Requires the flux sequences:: SF AM
Updates the state sequence:: SP
Basic equation:: \(\frac{dSP}{dt} = SF - AM\)

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(2)
>>> derived.nul.update()
>>> fluxes.sf = 1.0
>>> fluxes.am = 2.0
>>> states.sp.old = 3.0
>>> model.update_sp_v1()
>>> states.sp
sp(2.0, 0.0)

class hydpy.models.wland.wland_model.Update_DVE_V1[source]¶

Bases: Method

Update the elevated region’s storage deficit of the vadose zone.

Requires the derived parameter:: NUGE
Requires the flux sequences:: PVE ETVE GR
Updates the state sequence:: DVE
Basic equation:: \(\frac{dDV\!E}{dt} = -(PV\!E - ETV\!E - GR)\)

Examples:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> derived.nuge(1)
>>> fluxes.pve = 1.0
>>> fluxes.etve = 2.0
>>> fluxes.gr = 3.0
>>> states.dve.old = 5.0
>>> model.update_dve_v1()
>>> states.dve
dve(9.0)

>>> derived.nuge(0)
>>> model.update_dve_v1()
>>> states.dve
dve(nan)

class hydpy.models.wland.wland_model.Update_DV_V1[source]¶

Bases: Method

Update the lowland region’s storage deficit of the vadose zone.

Requires the derived parameters:: NUG AGRE AGR
Requires the flux sequences:: FXG PV ETV FGSE FGS
Updates the state sequence:: DV
Basic equation:: \(\frac{dDV}{dt} = - \left( FXG + PV - ETV - FGS + FGSE \cdot \frac{AGRE}{AGR} \right)\)

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> derived.nug(1)
>>> derived.agre(0.2)
>>> derived.agr(0.4)
>>> fluxes.fxg = 1.0
>>> fluxes.pv = 2.0
>>> fluxes.etv = 3.0
>>> fluxes.fgs = 4.0
>>> fluxes.fgse = 5.0
>>> states.dv.old = 6.0
>>> model.update_dv_v1()
>>> states.dv
dv(7.5)

>>> derived.nug(0)
>>> model.update_dv_v1()
>>> states.dv
dv(nan)

class hydpy.models.wland.wland_model.Update_HGE_V1[source]¶

Bases: Method

Update the elevated region’s groundwater level.

Requires the control parameter:: ThetaS
Requires the derived parameter:: NUGE
Requires the flux sequences:: GR FGSE
Updates the state sequence:: HGE
Basic equation:: \(\frac{dDGE}{dt} = CDG\)

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> thetas(0.5)
>>> derived.nuge(1)
>>> fluxes.gr = 1.0
>>> fluxes.fgse = 2.0
>>> states.hge.old = 3.0
>>> model.update_hge_v1()
>>> states.hge
hge(1.0)

>>> derived.nuge(0)
>>> model.update_hge_v1()
>>> states.hge
hge(nan)

class hydpy.models.wland.wland_model.Update_DG_V1[source]¶

Bases: Method

Update the lowland region’s groundwater depth.

Requires the derived parameter:: NUG
Requires the flux sequence:: CDG
Updates the state sequence:: DG
Basic equation:: \(\frac{dDG}{dt} = CDG\)

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> derived.nug(1)
>>> states.dg.old = 2.0
>>> fluxes.cdg = 3.0
>>> model.update_dg_v1()
>>> states.dg
dg(5.0)

>>> derived.nug(0)
>>> model.update_dg_v1()
>>> states.dg
dg(nan)

class hydpy.models.wland.wland_model.Update_HQ_V1[source]¶

Bases: Method

Update the level of the quickflow reservoir.

Requires the flux sequences:: PQ FQS
Updates the state sequence:: HQ
Basic equation:: \(\frac{dHQ}{dt} = PQ - FQS\)

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> states.hq.old = 2.0
>>> fluxes.pq = 3.0
>>> fluxes.fqs = 4.0
>>> model.update_hq_v1()
>>> states.hq
hq(1.0)

class hydpy.models.wland.wland_model.Update_HS_V1[source]¶

Bases: Method

Update the surface water level.

Requires the derived parameters:: ALR ASR AGR
Requires the flux sequences:: FXS PS ES FGS FQS RH
Updates the state sequence:: HS
Basic equation:: \(\frac{dHS}{dt} = PS - ES + FXS + \frac{ALR \cdot FQS + AGR \cdot FGS - RH}{ASR}\)

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> derived.alr(0.8)
>>> derived.asr(0.2)
>>> derived.agr(0.8)
>>> states.hs.old = 2.0
>>> fluxes.fxs = 3.0
>>> fluxes.ps = 4.0
>>> fluxes.es = 5.0
>>> fluxes.fgs = 6.0
>>> fluxes.fqs = 7.0
>>> fluxes.rh = 8.0
>>> model.update_hs_v1()
>>> states.hs
hs(16.0)

class hydpy.models.wland.wland_model.Calc_R_V1[source]¶

Bases: Method

Calculate the runoff in m³/s.

Requires the derived parameter:: QF
Requires the flux sequence:: RH
Calculates the flux sequence:: R
Basic equation:: \(R = QF \cdot RH\)

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> derived.qf(2.0)
>>> fluxes.rh = 3.0
>>> model.calc_r_v1()
>>> fluxes.r
r(6.0)

class hydpy.models.wland.wland_model.Pass_R_V1[source]¶

Bases: Method

Update the outlet link sequence.

Requires the flux sequence:: R
Calculates the outlet sequence:: Q
Basic equation:: \(Q = R\)

class hydpy.models.wland.wland_model.Get_Temperature_V1[source]¶

Bases: Method

Get the current subbasin-wide air temperature value (that applies to all hydrological response units so that the given index does not matter).

Requires the input sequence:: T

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> inputs.t = 2.0
>>> model.get_temperature_v1(0)
2.0
>>> model.get_temperature_v1(1)
2.0

class hydpy.models.wland.wland_model.Get_MeanTemperature_V1[source]¶

Bases: Method

Get the current subbasin-wide air temperature value.

Requires the input sequence:: T

Example:

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

class hydpy.models.wland.wland_model.Get_Precipitation_V1[source]¶

Bases: Method

Get the current subbasin-wide precipitation value (that applies to all hydrological response units so that the given index does not matter).

Requires the flux sequence:: PC

Example:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(2)
>>> fluxes.pc = 2.0
>>> model.get_precipitation_v1(0)
2.0
>>> model.get_precipitation_v1(1)
2.0

class hydpy.models.wland.wland_model.Get_SnowCover_V1[source]¶

Bases: Method

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

Requires the state sequence:: SP

Example:

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

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(2)
>>> states.sp = 0.0, 2.0
>>> model.get_snowcover_v1(0)
0.0
>>> model.get_snowcover_v1(1)
1.0

class hydpy.models.wland.wland_model.PegasusDGEq(model: Model)[source]¶

Bases: Pegasus

Pegasus iterator for finding the equilibrium groundwater depth.

METHODS: ClassVar[tuple[type[Method], ...]] = (<class 'hydpy.models.wland.wland_model.Return_ErrorDV_V1'>,)¶

name: ClassVar[str] = 'pegasusdgeq'¶

class hydpy.models.wland.wland_model.QuadDVEq_V1(model: Model)[source]¶

Bases: Quad

Adaptive quadrature method for integrating the equilibrium storage deficit of the vadose zone.

METHODS: ClassVar[tuple[type[Method], ...]] = (<class 'hydpy.models.wland.wland_model.Return_DVH_V1'>,)¶

name: ClassVar[str] = 'quaddveq_v1'¶

class hydpy.models.wland.wland_model.QuadDVEq_V2(model: Model)[source]¶

Bases: Quad

Adaptive quadrature method for integrating the equilibrium storage deficit of the vadose zone.

METHODS: ClassVar[tuple[type[Method], ...]] = (<class 'hydpy.models.wland.wland_model.Return_DVH_V2'>,)¶

name: ClassVar[str] = 'quaddveq_v2'¶

class hydpy.models.wland.wland_model.BaseModel[source]¶

Bases: ELSModel

Base model for wland_wag and wland_gd.

check_waterbalance(initial_conditions: dict[str, dict[str, dict[str, float | ndarray[tuple[int, ...], dtype[float64]]]]]) → float[source]¶

Determine the water balance error of the previous simulation run in mm.

Method check_waterbalance() calculates the balance error as follows:

\[\begin{split}Error = \Sigma In - \Sigma Out + \Sigma \Delta H - \Delta Vol_{basin} - \Delta Vol_{hru} \\ \\ \Sigma In = \sum_{t=t_0}^{t_1} PC_t + FXG_t + FXS_t \\ \Sigma Out = \sum_{t=t_0}^{t_1} ET_t + RH_t \\ \Sigma \Delta H= ASR \cdot \sum_{t=t_0}^{t_1} DHS_t \\ \Delta Vol_{basin} = ALR \cdot f_{\Delta}(HQ) + AGRE \cdot \big( ThetaS \cdot f_{\Delta}(HGE) - f_{\Delta}(DV\!E) \big) - AGR \cdot f_{\Delta}(DV) + ASR \cdot f_{\Delta}(HS) \\ \Delta Vol_{hru} = \sum_{k=1}^{NUL} AUR^k \cdot \big( f_{\Delta}(IC^k) + f_{\Delta}(SP) \big) \\ \\ f_{\Delta}(x) = x_{t1} - x_{t0}\end{split}\]

The returned error should always be in scale with numerical precision so that it does not affect the simulation results in any relevant manner.

Pick the required initial conditions before starting the simulation via property conditions. See the integration tests of the application model wland_wag for some examples.

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

class hydpy.models.wland.wland_model.Main_PETModel_V1[source]¶

Bases: ELSModel

Base class for HydPy-W models that use submodels that comply with the PETModel_V1 interface.

petmodel: SubmodelProperty¶

petmodel_is_mainmodel¶

petmodel_typeid¶

add_petmodel_v1¶

Initialise the given petmodel that follows the PETModel_V1 interface.

>>> from hydpy.models.wland_wag import *
>>> parameterstep()
>>> nu(3)
>>> at(10.0)
>>> aur(0.5, 0.3, 0.2)
>>> lt(FIELD, TREES, WATER)
>>> with model.add_petmodel_v1("evap_ret_tw2002"):
...     nmbhru
...     hruarea
...     evapotranspirationfactor(field=1.0, trees=2.0, water=1.5)
...     for method, arguments in model.preparemethod2arguments.items():
...         print(method, arguments[0][0], sep=": ")
nmbhru(3)
hruarea(5.0, 3.0, 2.0)
prepare_nmbzones: 3
prepare_zonetypes: [13 19 23]
prepare_subareas: [5. 3. 2.]

>>> etf = model.petmodel.parameters.control.evapotranspirationfactor
>>> etf
evapotranspirationfactor(field=1.0, trees=2.0, water=1.5)
>>> lt(TREES, FIELD, WATER)
>>> etf
evapotranspirationfactor(field=2.0, trees=1.0, water=1.5)
>>> from hydpy import round_
>>> round_(etf.average_values())
1.4

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

class hydpy.models.wland.wland_model.Main_PETModel_V2[source]¶

Bases: ELSModel

Base class for HydPy-W models that use submodels that comply with the PETModel_V2 interface.

petmodel: SubmodelProperty¶

petmodel_is_mainmodel¶

petmodel_typeid¶

add_petmodel_v2¶

Initialise the given petmodel that follows the PETModel_V2 interface.

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2001-01-01", "1d"
>>> from hydpy.models.wland_wag import *
>>> parameterstep()
>>> nu(12)
>>> at(10.0)
>>> aur(0.006, 0.02, 0.034, 0.048, 0.062, 0.076,
...     0.09, 0.104, 0.118, 0.132, 0.146, 0.164)
>>> lt(SEALED, FIELD, WINE, ORCHARD, SOIL, PASTURE,
...    WETLAND, TREES, CONIFER, DECIDIOUS, MIXED, WATER)
>>> lai(1.0)
>>> lai.conifer_jan = 2.0
>>> lai.pasture_dec = 3.0
>>> with model.add_petmodel_v2("evap_pet_ambav1") as petmodel:
...     nmbhru
...     hrutype
...     water
...     interception
...     soil
...     plant
...     my_lai = leafareaindex
...     "my_lai", my_lai.field_jun, my_lai.conifer_jan, my_lai.pasture_dec
...     petmodel.preparemethod2arguments["prepare_nmbzones"]
...     petmodel.preparemethod2arguments["prepare_subareas"]
...     groundalbedo(conifer=0.05, decidious=0.1, field=0.15, mixed=0.2,
...                  orchard=0.25, pasture=0.3, sealed=0.35, soil=0.4,
...                  trees=0.45, water=0.5, wetland=0.55, wine=0.6)
...     for method, arguments in model.preparemethod2arguments.items():
...         print(method, arguments[0][0], sep=": ")
nmbhru(12)
hrutype(SEALED, FIELD, WINE, ORCHARD, SOIL, PASTURE, WETLAND, TREES,
        CONIFER, DECIDIOUS, MIXED, WATER)
water(conifer=False, decidious=False, field=False, mixed=False,
      orchard=False, pasture=False, sealed=False, soil=False,
      trees=False, water=True, wetland=False, wine=False)
interception(conifer=True, decidious=True, field=True, mixed=True,
             orchard=True, pasture=True, sealed=True, soil=True,
             trees=True, water=False, wetland=True, wine=True)
soil(conifer=True, decidious=True, field=True, mixed=True,
     orchard=True, pasture=True, sealed=False, soil=True, trees=True,
     water=False, wetland=True, wine=True)
plant(conifer=True, decidious=True, field=True, mixed=True,
      orchard=True, pasture=True, sealed=False, soil=False,
      trees=True, water=False, wetland=True, wine=True)
('my_lai', 1.0, 2.0, 3.0)
((12,), {})
((array([0.06, 0.2 , 0.34, 0.48, 0.62, 0.76, 0.9 , 1.04, 1.18, 1.32, 1.46,
       1.64]),), {})
prepare_nmbzones: 12
prepare_zonetypes: [12 13 14 15 16 17 18 19 20 21 22 23]
prepare_subareas: [0.06 0.2  0.34 0.48 0.62 0.76 0.9  1.04 1.18 1.32 1.46 1.64]
prepare_leafareaindex: [[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
...
prepare_water: [False False False False False False False False False False False  True]
prepare_interception: [ True  True  True  True  True  True  True  True  True  True  True False]
prepare_soil: [False  True  True  True  True  True  True  True  True  True  True False]
prepare_plant: [False  True  True  True False  True  True  True  True  True  True False]
prepare_tree: [False False False False False False False False  True  True  True False]

>>> assert model is model.petmodel.tempmodel
>>> assert model is model.petmodel.precipmodel
>>> assert model is model.petmodel.snowcovermodel

>>> ga = model.petmodel.parameters.control.groundalbedo
>>> ga
groundalbedo(conifer=0.05, decidious=0.1, field=0.15, mixed=0.2,
             orchard=0.25, pasture=0.3, sealed=0.35, soil=0.4,
             trees=0.45, water=0.5, wetland=0.55, wine=0.6)
>>> lt(FIELD, SEALED, WINE, ORCHARD, SOIL, PASTURE,
...    WETLAND, TREES, CONIFER, DECIDIOUS, MIXED, WATER)
>>> ga
groundalbedo(conifer=0.05, decidious=0.1, field=0.35, mixed=0.2,
             orchard=0.25, pasture=0.3, sealed=0.15, soil=0.4,
             trees=0.45, water=0.5, wetland=0.55, wine=0.6)
>>> from hydpy import round_
>>> round_(ga.average_values())
0.3117

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

class hydpy.models.wland.wland_model.Main_DischargeModel_V2[source]¶

Bases: ELSModel

Base class for HydPy-W models that use submodels that comply with the DischargeModel_V2 interface.

dischargemodel: SubmodelProperty¶

dischargemodel_is_mainmodel¶

dischargemodel_typeid¶

add_dischargemodel_v2¶

Initialise the given dischargemodel that follows the DischargeModel_V2 interface.

Note the dependency on the derived parameter CD:

>>> from hydpy.models.wland_wag import *
>>> parameterstep()
>>> sh(10.0)
>>> with model.add_dischargemodel_v2("wq_walrus", update=False):
...     pass
Traceback (most recent call last):
...
hydpy.core.exceptiontools.AttributeNotReady: While trying to add a submodel to the main model `wland_wag`, the following error occurred: While trying to determine the missing value of the derived parameter `cd` of element `?`, the following error occurred: While trying to subtract variable `gl` and `BL` instance `bl(?)`, the following error occurred: For variable `bl`, no value has been defined so far.

You can define its value manually for testing:

>>> derived.cd(2000.0)
>>> with model.add_dischargemodel_v2("wq_walrus", update=False):
...     channeldepth
...     crestheighttolerance
channeldepth(2.0)
crestheighttolerance(0.01)

>>> model.dischargemodel.parameters.control.channeldepth
channeldepth(2.0)
>>> model.dischargemodel.parameters.control.crestheighttolerance
crestheighttolerance(0.01)

However, add_dischargemodel_v2() updates the channel depth whenever possible to make the added submodel consistent with the main model’s current control parameter values:

>>> gl(4.0)
>>> bl(3.0)
>>> with model.add_dischargemodel_v2("wq_walrus", update=False):
...     channeldepth
...     crestheighttolerance
channeldepth(1.0)
crestheighttolerance(0.01)

>>> derived.cd
cd(1000.0)
>>> model.dischargemodel.parameters.control.channeldepth
channeldepth(1.0)
>>> model.dischargemodel.parameters.control.crestheighttolerance
crestheighttolerance(0.01)

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

class hydpy.models.wland.wland_model.Main_WaterLevelModel_V1[source]¶

Bases: ELSModel

Base class for HydPy-W models that use submodels that comply with the WaterLevelModel_V1 interface.

waterlevelmodel: SubmodelProperty¶

waterlevelmodel_is_mainmodel¶

waterlevelmodel_typeid¶

add_waterlevelmodel_v1¶

Initialise the given waterlevelmodel that follows the WaterLevelModel_V1 interface.

>>> from hydpy.models.wland_wag import *
>>> parameterstep()
>>> from hydpy.models import exch_waterlevel
>>> with model.add_waterlevelmodel_v1(exch_waterlevel):
...     pass
>>> assert isinstance(model.waterlevelmodel, exch_waterlevel.Model)

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

class hydpy.models.wland.wland_model.Sub_TempModel_V1[source]¶

Bases: ELSModel, TempModel_V1

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

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

numconsts: NumConstsELS¶

numvars: NumVarsELS¶

cymodel: CyModelProtocol | None¶

parameters: parametertools.Parameters¶

sequences: sequencetools.Sequences¶

masks: masktools.Masks¶

DOCNAME: DocName¶

class hydpy.models.wland.wland_model.Sub_PrecipModel_V1[source]¶

Bases: ELSModel, PrecipModel_V1

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

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

numconsts: NumConstsELS¶

numvars: NumVarsELS¶

cymodel: CyModelProtocol | None¶

parameters: parametertools.Parameters¶

sequences: sequencetools.Sequences¶

masks: masktools.Masks¶

DOCNAME: DocName¶

class hydpy.models.wland.wland_model.Sub_SnowCoverModel_V1[source]¶

Bases: ELSModel, SnowCoverModel_V1

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

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

numconsts: NumConstsELS¶

numvars: NumVarsELS¶

cymodel: CyModelProtocol | None¶

parameters: parametertools.Parameters¶

sequences: sequencetools.Sequences¶

masks: masktools.Masks¶

DOCNAME: DocName¶

Parameter Features¶

Parameter tools¶

class hydpy.models.wland.wland_parameters.SoilParameter(subvars: SubParameters)[source]¶

Bases: Parameter

Base class for parameters related to the soil character.

Some parameters of HydPy-W are strongly related to the soil character and come with default values. To apply these default values, use the soil keyword in combination with one of the available soil constants.

We take parameter B and the soil character SAND as an example, which has the default value 4.05:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> b(soil=SAND)
>>> b
b(soil=SAND)
>>> from hydpy import round_
>>> round_(b.value)
4.05

You are free to ignore the default values and to set anything you like:

>>> b.value = 3.0
>>> b
b(3.0)

The string representation relies on the soil keyword only when used to define the value directly beforehand:

>>> b(4.05)
>>> b
b(4.05)

For a list of the available defaults, see the respective parameter’s documentation or the error message that class SoilParameter raises if one passes a wrong value:

>>> b(soil=0)
Traceback (most recent call last):
...
ValueError: While trying the set the value of parameter `b` of element `?`, the following error occurred: The given soil constant `0` is not among the available ones.  Please use one of the following constants: SAND (1), LOAMY_SAND (2), SANDY_LOAM (3), SILT_LOAM (4), LOAM (5), SANDY_CLAY_LOAM (6), SILT_CLAY_LOAM (7), CLAY_LOAM (8), SANDY_CLAY (9), SILTY_CLAY (10), and CLAY (11).

Combining the soil keyword with other keywords is not allowed:

>>> b(soil=SAND, landuse='acre')
Traceback (most recent call last):
...
TypeError: While trying the set the value of parameter `b` of element `?`, the following error occurred: It is not allowed to combine keyword `soil` with other keywords, but the following ones are also used: landuse.

>>> b(landuse='acre')
Traceback (most recent call last):
...
NotImplementedError: While trying the set the value of parameter `b` of element `?`, the following error occurred: The value(s) of parameter `b` of element `?` could not be set based on the given keyword arguments.

classmethod print_defaults()[source]¶

Print the soil-related default values of the parameter.

See the documentation on class B for an example.

name: str = 'soilparameter'¶: Name of the variable in lowercase letters.

unit: str = '?'¶: Unit of the variable.

class hydpy.models.wland.wland_parameters.LanduseParameterLand(subvars: SubParameters)[source]¶

Bases: ZipParameter

Base class for 1-dimensional parameters relevant for all land-related units.

We take the parameter DDT as an example. You can define its values by using the names of all land use-related constants in lower-case as keywords:

>>> from hydpy import print_vector, round_
>>> from hydpy.models.wland import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> nu(13)
>>> lt(SEALED, FIELD, WINE, ORCHARD, SOIL, PASTURE, WETLAND,
...    TREES, CONIFER, DECIDIOUS, MIXED, SEALED, WATER)
>>> ddf(sealed=0.0, field=1.0, wine=2.0, orchard=3.0, soil=4.0, pasture=5.0,
...     wetland=6.0, trees=7.0, conifer=8.0, decidious=9.0, mixed=10.0)
>>> ddf
ddf(conifer=8.0, decidious=9.0, field=1.0, mixed=10.0, orchard=3.0,
    pasture=5.0, sealed=0.0, soil=4.0, trees=7.0, wetland=6.0,
    wine=2.0)
>>> print_vector(ddf.values)
0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 0.0, nan

You can average the current values with regard to the hydrological response area fractions, defined via parameter AUR:

>>> aur(0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.11, 0.12, 0.22)
>>> round_(ddf.average_values())
5.641026

You can query or change the values related to specific land use types via attribute access:

>>> print_vector(ddf.sealed)
0.0, 0.0
>>> ddf.sealed = 11.0, 12.0
>>> ddf
ddf(11.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 12.0, nan)
>>> ddf.sealed = 12.0
>>> ddf
ddf(conifer=8.0, decidious=9.0, field=1.0, mixed=10.0, orchard=3.0,
    pasture=5.0, sealed=12.0, soil=4.0, trees=7.0, wetland=6.0,
    wine=2.0)

constants: dict[str, int] = {'CONIFER': 20, 'DECIDIOUS': 21, 'FIELD': 13, 'MIXED': 22, 'ORCHARD': 15, 'PASTURE': 17, 'SEALED': 12, 'SOIL': 16, 'TREES': 19, 'WATER': 23, 'WETLAND': 18, 'WINE': 14}¶: Mapping of the constants’ names and values.

mask: masktools.IndexMask¶

property refweights¶: Alias for the associated instance of AUR for calculating areal mean values.

name: str = 'landuseparameterland'¶: Name of the variable in lowercase letters.

unit: str = '?'¶: Unit of the variable.

class hydpy.models.wland.wland_parameters.LanduseMonthParameter(subvars: SubParameters)[source]¶

Bases: KeywordParameter2D

Base class for parameters which values depend on the actual month and land-use type.

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

name: str = 'landusemonthparameter'¶: Name of the variable in lowercase letters.

rownames: tuple[str, ...] = ('sealed', 'field', 'wine', 'orchard', 'soil', 'pasture', 'wetland', 'trees', 'conifer', 'decidious', 'mixed', 'water')¶

unit: str = '?'¶: Unit of the variable.

Constants¶

HydPy-W provides two types of constants: those associated with the average soil character of a sub-catchment and those associated with the land-use type of the different hydrological response units of a sub-catchment. They are all available via wildcard-imports:

>>> from hydpy.models.wland import *
>>> (SAND, LOAMY_SAND, SANDY_LOAM, SILT_LOAM, LOAM, SANDY_CLAY_LOAM,
... SILT_CLAY_LOAM, CLAY_LOAM, SANDY_CLAY, SILTY_CLAY, CLAY)
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
>>> (SEALED, FIELD, WINE, ORCHARD, SOIL, PASTURE, WETLAND, TREES,
...  CONIFER, DECIDIOUS, MIXED)
(12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)

hydpy.models.wland.wland_constants.SAND = 1¶: Soil character constant for sand.

hydpy.models.wland.wland_constants.LOAMY_SAND = 2¶: Soil character constant for loamy sand.

hydpy.models.wland.wland_constants.SANDY_LOAM = 3¶: Soil character constant for sandy loam.

hydpy.models.wland.wland_constants.SILT_LOAM = 4¶: Soil character constant for silt loam.

hydpy.models.wland.wland_constants.LOAM = 5¶: Soil character constant for loam.

hydpy.models.wland.wland_constants.SANDY_CLAY_LOAM = 6¶: Soil character constant for sandy clay loam.

hydpy.models.wland.wland_constants.SILT_CLAY_LOAM = 7¶: Soil character constant for silt clay loam.

hydpy.models.wland.wland_constants.CLAY_LOAM = 8¶: Soil character constant for clay loam.

hydpy.models.wland.wland_constants.SANDY_CLAY = 9¶: Soil character constant for sandy clay.

hydpy.models.wland.wland_constants.SILTY_CLAY = 10¶: Soil character constant for silty clay.

hydpy.models.wland.wland_constants.CLAY = 11¶: Soil character constant for clay.

hydpy.models.wland.wland_constants.SEALED = 12¶: Land type constant for sealed surface.

hydpy.models.wland.wland_constants.FIELD = 13¶: Land type constant for fields.

hydpy.models.wland.wland_constants.WINE = 14¶: Land type constant for viticulture.

hydpy.models.wland.wland_constants.ORCHARD = 15¶: Land type constant for orchards.

hydpy.models.wland.wland_constants.SOIL = 16¶: Land type constant for bare, unsealed soils.

hydpy.models.wland.wland_constants.PASTURE = 17¶: Land type constant for pasture.

hydpy.models.wland.wland_constants.WETLAND = 18¶: Land type constant for wetlands.

hydpy.models.wland.wland_constants.TREES = 19¶: Land type constant for loose tree populations.

hydpy.models.wland.wland_constants.CONIFER = 20¶: Land type constant for coniferous forests.

hydpy.models.wland.wland_constants.DECIDIOUS = 21¶: Land type constant for deciduous forests.

hydpy.models.wland.wland_constants.MIXED = 22¶: Land type constant for mixed forests.

hydpy.models.wland.wland_constants.WATER = 23¶: Land type constant for the surface water storage.

Control parameters¶

class hydpy.models.wland.ControlParameters(master: Parameters, cls_fastaccess: type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)

Bases: SubParameters

Control parameters of model wland.

The following classes are selected:

AT() Total area [km²].
NU() Number of hydrological response units [-].
LT() Landuse type [-].
ER() Elevated region [-].
AUR() Relative area of each hydrological response unit [-].
GL() The lowland region’s average ground level [m].
BL() Channel bottom level [m].
CP() Factor for correcting precipitation [-].
LAI() Leaf area index [-].
IH() Interception capacity with respect to the leaf surface area [mm].
TT() Threshold temperature for snow/rain [°C].
TI() Temperature interval with a mixture of snow and rain [°C].
DDF() Day degree factor [mm/°C/T].
DDT() Day degree threshold temperature [°C].
CWE() Wetness index parameter for the elevated region [mm].
CW() Wetness index parameter for the lowland region [mm].
CV() Vadose zone relaxation time constant for the lowland region [T].
CGE() Groundwater reservoir constant for the elevated region [mm T].
CG() Groundwater reservoir constant for the lowland region [mm T].
RG() Groundwater reservoir restriction [-].
CGF() Groundwater reservoir flood factor [1/mm].
DGC() Direct groundwater connect [-].
CQ() Quickflow reservoir relaxation time [T].
B() Pore size distribution parameter [-].
PsiAE() Air entry pressure [mm].
ThetaS() Soil moisture content at saturation [-].
ThetaR() Residual soil moisture deficit at tension saturation [-].
AC() Air capacity for the elevated region [mm].
Zeta1() Curvature parameter of the evapotranspiration reduction function [-].
Zeta2() Inflection point of the evapotranspiration reduction function [mm].
SH() General smoothing parameter related to the height of water columns [mm].
ST() General smoothing parameter related to temperature [°C].

class hydpy.models.wland.wland_control.AT(subvars: SubParameters)[source]¶

Bases: Parameter

Total area [km²].

NDIM: int = 0¶

TYPE¶: alias of float

TIME: bool | None = None¶

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

name: str = 'at'¶: Name of the variable in lowercase letters.

unit: str = 'km²'¶: Unit of the variable.

class hydpy.models.wland.wland_control.NU(subvars: SubParameters)[source]¶

Bases: Parameter

Number of hydrological response units [-].

Required by the methods:: Calc_FQS_V1 Calc_FXS_V1

Parameter NU automatically sets the length of most 1-dimensional parameters and sequences of HydPy-W:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(3)
>>> lt.shape
(3,)
>>> states.ic.shape
(3,)

Changing the value of parameter NU reshapes the related parameters and sequences and eventually deletes predefined values:

>>> states.ic = 1.0
>>> states.ic
ic(1.0, 1.0, 1.0)
>>> nu(2)
>>> states.ic
ic(nan, nan)

Redefining the same value for parameter NU does not affect any related parameter and sequence object:

>>> states.ic = 1.0
>>> states.ic
ic(1.0, 1.0)
>>> nu(2)
>>> states.ic
ic(1.0, 1.0)

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 = 'nu'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_control.LT(subvars: SubParameters)[source]¶

Bases: NameParameter

Landuse type [-].

Required by the methods:: Calc_ETVE_ETV_V1 Calc_PQ_V1 Calc_PVE_PV_V1 Calc_TF_V1

For better readability, use the land-use-related constants defined in module wland_constants to set the individual hydrological response units’ land-use types:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(12)
>>> lt(SEALED, FIELD, WINE, ORCHARD, SOIL, PASTURE,
...    WETLAND, TREES, CONIFER, DECIDIOUS, MIXED, WATER)
>>> lt
lt(SEALED, FIELD, WINE, ORCHARD, SOIL, PASTURE, WETLAND, TREES,
   CONIFER, DECIDIOUS, MIXED, WATER)

Note that wland generally requires a single surface water storage unit, which must be placed at the last position. Trying to set another land type causes the following error:

>>> lt(SEALED, FIELD, WINE, ORCHARD, SOIL, PASTURE,
...    WETLAND, TREES, CONIFER, DECIDIOUS, MIXED, MIXED)
Traceback (most recent call last):
...
ValueError: While trying to set the land use types via parameter `lt` of element `?`, the following error occurred: The last land use type must be `WATER`, but `MIXED` is given.

Trying to define multiple such units results in the following error:

>>> lt(SEALED, FIELD, WINE, ORCHARD, SOIL, PASTURE,
...    WETLAND, TREES, CONIFER, DECIDIOUS, WATER, WATER)
Traceback (most recent call last):
...
ValueError: While trying to set the land use types via parameter `lt` of element `?`, the following error occurred: W-Land requires a single surface water storage unit, but 2 units are defined as such.

constants: Constants = {'CONIFER': 20, 'DECIDIOUS': 21, 'FIELD': 13, 'MIXED': 22, 'ORCHARD': 15, 'PASTURE': 17, 'SEALED': 12, 'SOIL': 16, 'TREES': 19, 'WATER': 23, 'WETLAND': 18, 'WINE': 14}¶

name: str = 'lt'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_control.ER(subvars: SubParameters)[source]¶

Bases: LanduseParameterLand

Elevated region [-].

Required by the methods:: Calc_ETVE_ETV_V1 Calc_PQ_V1 Calc_PVE_PV_V1

NDIM: int = 1¶

TYPE¶: alias of bool

TIME: bool | None = None¶

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

INIT: int | float | bool | None = False¶

name: str = 'er'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_control.AUR(subvars: SubParameters)[source]¶

Bases: Parameter

Relative area of each hydrological response unit [-].

Required by the methods:: Calc_ETVE_ETV_V1 Calc_ET_V1 Calc_PQ_V1 Calc_PVE_PV_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 = 'aur'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_control.GL(subvars: SubParameters)[source]¶

Bases: Parameter

The lowland region’s average ground level [m].

Required by the method:: Calc_FGSE_V1

NDIM: int = 0¶

TYPE¶: alias of float

TIME: bool | None = None¶

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

trim(lower=None, upper=None) → bool[source]¶

Ensure GL is above BL.

>>> from hydpy.models.wland import *
>>> parameterstep()

>>> gl(2.0)
>>> gl
gl(2.0)

>>> bl.value = 4.0
>>> gl(3.0)
>>> gl
gl(4.0)

name: str = 'gl'¶: Name of the variable in lowercase letters.

unit: str = 'm'¶: Unit of the variable.

class hydpy.models.wland.wland_control.BL(subvars: SubParameters)[source]¶

Bases: Parameter

Channel bottom level [m].

Required by the method:: Pick_HS_V1

NDIM: int = 0¶

TYPE¶: alias of float

TIME: bool | None = None¶

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

trim(lower=None, upper=None) → bool[source]¶

Ensure BL is below GL.

>>> from hydpy.models.wland import *
>>> parameterstep()

>>> from hydpy.models.wland import *
>>> parameterstep()

>>> bl(4.0)
>>> bl
bl(4.0)

>>> gl.value = 2.0
>>> bl(3.0)
>>> bl
bl(2.0)

name: str = 'bl'¶: Name of the variable in lowercase letters.

unit: str = 'm'¶: Unit of the variable.

class hydpy.models.wland.wland_control.CP(subvars: SubParameters)[source]¶

Bases: Parameter

Factor for correcting precipitation [-].

Required by the method:: Calc_PC_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)¶

name: str = 'cp'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_control.LAI(subvars: SubParameters)[source]¶

Bases: LanduseMonthParameter

Leaf area index [-].

Required by the method:: Calc_TF_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)¶

name: str = 'lai'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_control.IH(subvars: SubParameters)[source]¶

Bases: Parameter

Interception capacity with respect to the leaf surface area [mm].

Required by the method:: Calc_TF_V1

NDIM: int = 0¶

TYPE¶: alias of float

TIME: bool | None = None¶

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

name: str = 'ih'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_control.TT(subvars: SubParameters)[source]¶

Bases: Parameter

Threshold temperature for snow/rain [°C].

Required by the method:: Calc_FR_V1

NDIM: int = 0¶

TYPE¶: alias of float

TIME: bool | None = None¶

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

name: str = 'tt'¶: Name of the variable in lowercase letters.

unit: str = '°C'¶: Unit of the variable.

class hydpy.models.wland.wland_control.TI(subvars: SubParameters)[source]¶

Bases: Parameter

Temperature interval with a mixture of snow and rain [°C].

Required by the method:: Calc_FR_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)¶

name: str = 'ti'¶: Name of the variable in lowercase letters.

unit: str = '°C'¶: Unit of the variable.

class hydpy.models.wland.wland_control.DDF(subvars: SubParameters)[source]¶

Bases: LanduseParameterLand

Day degree factor [mm/°C/T].

Required by the method:: Calc_PM_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)¶

name: str = 'ddf'¶: Name of the variable in lowercase letters.

unit: str = 'mm/°C/T'¶: Unit of the variable.

class hydpy.models.wland.wland_control.DDT(subvars: SubParameters)[source]¶

Bases: Parameter

Day degree threshold temperature [°C].

Required by the method:: Calc_PM_V1

NDIM: int = 0¶

TYPE¶: alias of float

TIME: bool | None = None¶

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

name: str = 'ddt'¶: Name of the variable in lowercase letters.

unit: str = '°C'¶: Unit of the variable.

class hydpy.models.wland.wland_control.CWE(subvars: SubParameters)[source]¶

Bases: Parameter

Wetness index parameter for the elevated region [mm].

Required by the method:: Calc_WE_W_V1

NDIM: int = 0¶

TYPE¶: alias of float

TIME: bool | None = None¶

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

name: str = 'cwe'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_control.CW(subvars: SubParameters)[source]¶

Bases: Parameter

Wetness index parameter for the lowland region [mm].

Required by the method:: Calc_WE_W_V1

NDIM: int = 0¶

TYPE¶: alias of float

TIME: bool | None = None¶

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

name: str = 'cw'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_control.CV(subvars: SubParameters)[source]¶

Bases: Parameter

Vadose zone relaxation time constant for the lowland region [T].

Required by the methods:: Calc_CDG_V1 Calc_CDG_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)¶

name: str = 'cv'¶: Name of the variable in lowercase letters.

unit: str = 'T'¶: Unit of the variable.

class hydpy.models.wland.wland_control.CGE(subvars: SubParameters)[source]¶

Bases: Parameter

Groundwater reservoir constant for the elevated region [mm T].

Required by the method:: Calc_FGSE_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)¶

name: str = 'cge'¶: Name of the variable in lowercase letters.

unit: str = 'mm T'¶: Unit of the variable.

class hydpy.models.wland.wland_control.CG(subvars: SubParameters)[source]¶

Bases: Parameter

Groundwater reservoir constant for the lowland region [mm T].

Required by the method:: Calc_FGS_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)¶

name: str = 'cg'¶: Name of the variable in lowercase letters.

unit: str = 'mm T'¶: Unit of the variable.

class hydpy.models.wland.wland_control.RG(subvars: SubParameters)[source]¶

Bases: Parameter

Groundwater reservoir restriction [-].

Required by the method:: Calc_FGS_V1

NDIM: int = 0¶

TYPE¶: alias of bool

TIME: bool | None = None¶

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

name: str = 'rg'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_control.CGF(subvars: SubParameters)[source]¶

Bases: Parameter

Groundwater reservoir flood factor [1/mm].

Required by the method:: Calc_FGS_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)¶

name: str = 'cgf'¶: Name of the variable in lowercase letters.

unit: str = '1/mm'¶: Unit of the variable.

class hydpy.models.wland.wland_control.DGC(subvars: SubParameters)[source]¶

Bases: Parameter

Direct groundwater connect [-].

Required by the method:: Calc_CDG_V1

NDIM: int = 0¶

TYPE¶: alias of bool

TIME: bool | None = None¶

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

name: str = 'dgc'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_control.CQ(subvars: SubParameters)[source]¶

Bases: Parameter

Quickflow reservoir relaxation time [T].

Required by the method:: Calc_FQS_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)¶

name: str = 'cq'¶: Name of the variable in lowercase letters.

unit: str = 'T'¶: Unit of the variable.

class hydpy.models.wland.wland_control.B(subvars: SubParameters)[source]¶

Bases: SoilParameter

Pore size distribution parameter [-].

Required by the methods:: Calc_DGEq_V1 Calc_DVEq_V1 Calc_DVEq_V2 Calc_DVEq_V3 Calc_DVEq_V4 Calc_GF_V1 Return_DVH_V1 Return_DVH_V2 Return_ErrorDV_V1

Parameter B comes with the following default values:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> b.print_defaults()
SAND: 4.05
LOAMY_SAND: 4.38
SANDY_LOAM: 4.9
SILT_LOAM: 5.3
LOAM: 5.39
SANDY_CLAY_LOAM: 7.12
SILT_CLAY_LOAM: 7.75
CLAY_LOAM: 8.52
SANDY_CLAY: 10.4
SILTY_CLAY: 10.4
CLAY: 11.4

See the documentation on class SoilParameter for further information.

NDIM: int = 0¶

TYPE¶: alias of float

TIME: bool | None = None¶

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

name: str = 'b'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_control.PsiAE(subvars: SubParameters)[source]¶

Bases: SoilParameter

Air entry pressure [mm].

Required by the methods:: Calc_DGEq_V1 Calc_DVEq_V1 Calc_DVEq_V2 Calc_DVEq_V3 Calc_DVEq_V4 Calc_GF_V1 Return_DVH_V1 Return_DVH_V2 Return_ErrorDV_V1

Parameter PsiAE comes with the following default values:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> psiae.print_defaults()
SAND: 121.0
LOAMY_SAND: 90.0
SANDY_LOAM: 218.0
SILT_LOAM: 786.0
LOAM: 478.0
SANDY_CLAY_LOAM: 299.0
SILT_CLAY_LOAM: 356.0
CLAY_LOAM: 630.0
SANDY_CLAY: 153.0
SILTY_CLAY: 490.0
CLAY: 405.0

See the documentation on class SoilParameter for further information.

NDIM: int = 0¶

TYPE¶: alias of float

TIME: bool | None = None¶

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

name: str = 'psiae'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_control.ThetaS(subvars: SubParameters)[source]¶

Bases: SoilParameter

Soil moisture content at saturation [-].

Required by the methods:: Calc_CDG_V1 Calc_DGEq_V1 Calc_DVEq_V1 Calc_DVEq_V2 Calc_DVEq_V3 Calc_DVEq_V4 Calc_GF_V1 Return_DVH_V1 Return_DVH_V2 Return_ErrorDV_V1 Update_HGE_V1

Parameter ThetaS comes with the following default values:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> thetas.print_defaults()
SAND: 0.395
LOAMY_SAND: 0.41
SANDY_LOAM: 0.435
SILT_LOAM: 0.485
LOAM: 0.451
SANDY_CLAY_LOAM: 0.42
SILT_CLAY_LOAM: 0.477
CLAY_LOAM: 0.476
SANDY_CLAY: 0.426
SILTY_CLAY: 0.492
CLAY: 0.482

See the documentation on class SoilParameter for further information.

NDIM: int = 0¶

TYPE¶: alias of float

TIME: bool | None = None¶

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

trim(lower=None, upper=None) → bool[source]¶

Trim ThetaS following \(1e^{-6} \leq ThetaS \leq 1.0\) and, if ThetaR exists for the relevant application model, also following \(ThetaR \leq ThetaS\).

>>> from hydpy.models.wland import *
>>> parameterstep()

>>> thetas(0.0)
>>> thetas
thetas(0.000001)

>>> thetar.value = 0.5
>>> thetas(0.4)
>>> thetas
thetas(0.5)

>>> thetas(soil=SANDY_LOAM)
>>> thetas
thetas(0.5)

>>> thetas(1.01)
>>> thetas
thetas(1.0)

name: str = 'thetas'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_control.ThetaR(subvars: SubParameters)[source]¶

Bases: Parameter

Residual soil moisture deficit at tension saturation [-].

Required by the methods:: Calc_DGEq_V1 Calc_DVEq_V3 Calc_DVEq_V4 Calc_GF_V1 Return_DVH_V2 Return_ErrorDV_V1

NDIM: int = 0¶

TYPE¶: alias of float

TIME: bool | None = None¶

SPAN: tuple[int | float | bool | None, int | float | bool | None] = (1e-06, None)¶

INIT: int | float | bool | None = 0.01¶

trim(lower=None, upper=None) → bool[source]¶

Trim ThetaR following \(1e^{-6} \leq ThetaR \leq ThetaS\).

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> thetar(0.0)
>>> thetar
thetar(0.000001)
>>> thetas(0.41)
>>> thetar(0.42)
>>> thetar
thetar(0.41)

name: str = 'thetar'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_control.AC(subvars: SubParameters)[source]¶

Bases: Parameter

Air capacity for the elevated region [mm].

Required by the method:: Calc_GR_V1
ToDo: We should principally derive AC from SoilParameter, but: Brauer et al. (2014) provides no soil-specific default values for it because it is not part of the original WALRUS model. Do we want to determine consistent ones by ourselves?

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 = 200.0¶

name: str = 'ac'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_control.Zeta1(subvars: SubParameters)[source]¶

Bases: Parameter

Curvature parameter of the evapotranspiration reduction function [-].

Required by the method:: Calc_BetaE_Beta_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.02¶

name: str = 'zeta1'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_control.Zeta2(subvars: SubParameters)[source]¶

Bases: Parameter

Inflection point of the evapotranspiration reduction function [mm].

Required by the method:: Calc_BetaE_Beta_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 = 400.0¶

name: str = 'zeta2'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_control.SH(subvars: SubParameters)[source]¶

Bases: Parameter

General smoothing parameter related to the height of water columns [mm].

Required by the methods:: Calc_DVEq_V2 Calc_DVEq_V4

NDIM: int = 0¶

TYPE¶: alias of float

TIME: bool | None = None¶

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

name: str = 'sh'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_control.ST(subvars: SubParameters)[source]¶

Bases: Parameter

General smoothing parameter related to temperature [°C].

NDIM: int = 0¶

TYPE¶: alias of float

TIME: bool | None = None¶

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

name: str = 'st'¶: Name of the variable in lowercase letters.

unit: str = '°C'¶: Unit of the variable.

Derived parameters¶

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

Bases: SubParameters

Derived parameters of model wland.

The following classes are selected:

MOY() References the “global” month of the year index array [-].
NUL() Number of land-related hydrological response units [-].
NUGE() Number of groundwater-affected hydrological response units in the elevated region [-].
NUG() Number of groundwater-affected hydrological response units in the lowland region [-].
ALR() Relative land area [-].
ASR() Relative surface water area fraction [-].
AGRE() Relative groundwater area in the elevated region [-].
AGR() Relative groundwater area in the lowland region [-].
QF() Factor for converting mm/T to m³/s [T m³ / mm s].
CD() Channel depth [mm].
RH1() Regularisation parameter related to the height of water columns used when applying regularisation function smooth_logistic1() [mm].
RH2() Regularisation parameter related to the height of water columns used when applying regularisation function smooth_logistic2() [mm].
RT2() Regularisation parameter related to temperature for applying regularisation function smooth_logistic2()) [°C].

class hydpy.models.wland.wland_derived.MOY(subvars: SubParameters)[source]¶

Bases: MOYParameter

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

Required by the method:: Calc_TF_V1

name: str = 'moy'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_derived.NUL(subvars: SubParameters)[source]¶

Bases: Parameter

Number of land-related hydrological response units [-].

Required by the methods:: Calc_AM_V1 Calc_EI_V1 Calc_ES_V1 Calc_ETVE_ETV_V1 Calc_ET_V1 Calc_PE_PET_PETModel_V1 Calc_PE_PET_PETModel_V2 Calc_PE_PET_V1 Calc_PM_V1 Calc_PQ_V1 Calc_PVE_PV_V1 Calc_RF_V1 Calc_SF_V1 Calc_TF_V1 Update_IC_V1 Update_SP_V1

NDIM: int = 0¶

TYPE¶: alias of int

TIME: bool | None = None¶

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

update()[source]¶

Update NUL based on \(NUL = NU - 1\).

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(6)
>>> derived.nul.update()
>>> derived.nul
nul(5)

name: str = 'nul'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_derived.NUGE(subvars: SubParameters)[source]¶

Bases: Parameter

Number of groundwater-affected hydrological response units in the elevated region [-].

Required by the methods:: Calc_BetaE_Beta_V1 Calc_FGSE_V1 Calc_GR_V1 Calc_WE_W_V1 Update_DVE_V1 Update_HGE_V1

NDIM: int = 0¶

TYPE¶: alias of int

TIME: bool | None = None¶

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

update()[source]¶

Update NUG based on \(NUGE = \sum (ER \ \land \ LT \neq WATER \ \land \ LT \neq SEALED)\).

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(10)
>>> lt(SEALED, FIELD, SEALED, CONIFER, SEALED,
...    SEALED, FIELD, SEALED, SEALED, WATER)
>>> er(True, True, True, True, True,
...    False, False, False, False, False)
>>> derived.nuge.update()
>>> derived.nuge
nuge(2)

name: str = 'nuge'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_derived.NUG(subvars: SubParameters)[source]¶

Bases: Parameter

Number of groundwater-affected hydrological response units in the lowland region [-].

Required by the methods:: Calc_BetaE_Beta_V1 Calc_CDG_V1 Calc_CDG_V2 Calc_DGEq_V1 Calc_DVEq_V1 Calc_DVEq_V2 Calc_DVEq_V3 Calc_DVEq_V4 Calc_FGS_V1 Calc_WE_W_V1 Return_ErrorDV_V1 Update_DG_V1 Update_DV_V1

NDIM: int = 0¶

TYPE¶: alias of int

TIME: bool | None = None¶

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

update()[source]¶

Update NUG based on \(NUG = \sum (\overline{ER} \ \land \ LT \neq WATER \ \land \ LT \neq SEALED)\).

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(10)
>>> lt(SEALED, FIELD, SEALED, CONIFER, SEALED,
...    SEALED, FIELD, SEALED, SEALED, WATER)
>>> er(False, False, False, False, False,
...    True, True, True, True, False)
>>> derived.nug.update()
>>> derived.nug
nug(2)

name: str = 'nug'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_derived.ALR(subvars: SubParameters)[source]¶

Bases: Parameter

Relative land area [-].

Required by the methods:: Calc_PQ_V1 Calc_RH_V1 Update_HS_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()[source]¶

Update ALR based on \(ALR = \sum_{i = 1}^{NUL} AUR_i\).

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(3)
>>> aur(0.5, 0.3, 0.2)
>>> derived.alr.update()
>>> derived.alr
alr(0.8)

name: str = 'alr'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_derived.ASR(subvars: SubParameters)[source]¶

Bases: Parameter

Relative surface water area fraction [-].

Required by the methods:: Calc_ET_V1 Calc_FXS_V1 Calc_RH_V1 Update_HS_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()[source]¶

Update ASR based on \(ASR = AUR_{NU}\).

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(3)
>>> aur(0.5, 0.3, 0.2)
>>> derived.asr.update()
>>> derived.asr
asr(0.2)

name: str = 'asr'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_derived.AGRE(subvars: SubParameters)[source]¶

Bases: Parameter

Relative groundwater area in the elevated region [-].

Required by the methods:: Calc_ETVE_ETV_V1 Calc_ET_V1 Calc_PVE_PV_V1 Update_DV_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()[source]¶

Update AGR based on \(AGRE = \sum_{i=1}^{NU} AUR_i \cdot (ER_i \ \land \ LT_i \neq WATER \ \land \ LT_i \neq SEALED)\).

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(6)
>>> lt(SEALED, SOIL, SEALED, FIELD, FIELD, WATER)
>>> er(True, True, True, True, False, False)
>>> aur(0.02, 0.06, 0.1, 0.14, 0.18, 0.5)
>>> derived.agre.update()
>>> derived.agre
agre(0.2)

name: str = 'agre'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_derived.AGR(subvars: SubParameters)[source]¶

Bases: Parameter

Relative groundwater area in the lowland region [-].

Required by the methods:: Calc_ETVE_ETV_V1 Calc_ET_V1 Calc_FXG_V1 Calc_PVE_PV_V1 Calc_RH_V1 Update_DV_V1 Update_HS_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()[source]¶

Update AGR based on \(AGR = \sum_{i=1}^{NU} AUR_i \cdot (\overline{ER_i} \ \land \ LT_i \neq WATER \ \land \ LT_i \neq SEALED)\).

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(6)
>>> lt(SEALED, SOIL, SEALED, FIELD, FIELD, WATER)
>>> er(False, False, False, False, True, False)
>>> aur(0.02, 0.06, 0.1, 0.14, 0.18, 0.5)
>>> derived.agr.update()
>>> derived.agr
agr(0.2)

name: str = 'agr'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_derived.QF(subvars: SubParameters)[source]¶

Bases: Parameter

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

Required by the method:: Calc_R_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()[source]¶

Update QF based on AT and the current simulation step size.

>>> from hydpy.models.wland import *
>>> simulationstep('1d')
>>> parameterstep()
>>> at(10.0)
>>> derived.qf.update()
>>> derived.qf
qf(0.115741)

name: str = 'qf'¶: Name of the variable in lowercase letters.

unit: str = 'T m³ / mm s'¶: Unit of the variable.

class hydpy.models.wland.wland_derived.CD(subvars: SubParameters)[source]¶

Bases: Parameter

Channel depth [mm].

Required by the method:: Calc_FGS_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()[source]¶

Update CD based on \(CD = GL - BL\).

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> gl(5.0)
>>> bl(3.0)
>>> derived.cd.update()
>>> derived.cd
cd(2000.0)

name: str = 'cd'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_derived.RH1(subvars: SubParameters)[source]¶

Bases: Parameter

Regularisation parameter related to the height of water columns used when applying regularisation function smooth_logistic1() [mm].

Required by the methods:: Calc_AM_V1 Calc_CDG_V1 Calc_CDG_V2 Calc_DVEq_V2 Calc_DVEq_V4 Calc_EI_V1 Calc_ES_V1 Calc_GF_V1 Calc_TF_V1 Return_DVH_V1 Return_DVH_V2

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()[source]¶

Calculate the smoothing parameter value.

The documentation on module smoothtools explains the following example in some detail:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> sh(0.0)
>>> derived.rh1.update()
>>> from hydpy.cythons.smoothutils import smooth_logistic1
>>> from hydpy import round_
>>> round_(smooth_logistic1(0.1, derived.rh1))
1.0
>>> sh(2.5)
>>> derived.rh1.update()
>>> round_(smooth_logistic1(2.5, derived.rh1))
0.99

name: str = 'rh1'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_derived.RH2(subvars: SubParameters)[source]¶

Bases: Parameter

Regularisation parameter related to the height of water columns used when applying regularisation function smooth_logistic2() [mm].

Required by the methods:: Calc_FGS_V1 Calc_GR_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()[source]¶

Calculate the smoothing parameter value.

The documentation on module smoothtools explains the following example in some detail:

>>> from hydpy.models.wland import *
>>> from hydpy.cythons.smoothutils import smooth_logistic2
>>> from hydpy import round_
>>> parameterstep()
>>> sh(0.0)
>>> derived.rh2.update()
>>> round_(smooth_logistic2(0.0, derived.rh2))
0.0
>>> sh(2.5)
>>> derived.rh2.update()
>>> round_(smooth_logistic2(2.5, derived.rh2))
2.51

name: str = 'rh2'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_derived.RT2(subvars: SubParameters)[source]¶

Bases: Parameter

Regularisation parameter related to temperature for applying regularisation function smooth_logistic2()) [°C].

Required by the method:: Calc_PM_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()[source]¶

Calculate the smoothing parameter value.

The documentation on module smoothtools explains the following example in some detail:

>>> from hydpy.models.wland import *
>>> from hydpy.cythons.smoothutils import smooth_logistic2
>>> from hydpy import round_
>>> parameterstep()
>>> st(0.0)
>>> derived.rt2.update()
>>> round_(smooth_logistic2(0.0, derived.rt2))
0.0
>>> st(2.5)
>>> derived.rt2.update()
>>> round_(smooth_logistic2(2.5, derived.rt2))
2.51

name: str = 'rt2'¶: Name of the variable in lowercase letters.

unit: str = '°C'¶: Unit of the variable.

Fixed parameters¶

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

Bases: SubParameters

Fixed parameters of model wland.

The following classes are selected:

Pi() π [-].

class hydpy.models.wland.wland_fixed.Pi(subvars: SubParameters)[source]¶

Bases: FixedParameter

π [-].

Required by the method:: Calc_WE_W_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 = 3.141592653589793¶

name: str = 'pi'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

Solver parameters¶

class hydpy.models.wland.SolverParameters(master: Parameters, cls_fastaccess: type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)

Bases: SubParameters

Solver parameters of model wland.

The following classes are selected:

AbsErrorMax() Absolute numerical error tolerance [mm/T].
RelErrorMax() Relative numerical error tolerance [-].
RelDTMin() Smallest relative integration time step size allowed [-].
RelDTMax() Largest relative integration time step size allowed [-].

class hydpy.models.wland.wland_solver.AbsErrorMax(subvars)[source]¶

Bases: SolverParameter

Absolute numerical error tolerance [mm/T].

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.01¶

name: str = 'abserrormax'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_solver.RelErrorMax(subvars)[source]¶

Bases: SolverParameter

Relative numerical error tolerance [-].

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.01¶

name: str = 'relerrormax'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_solver.RelDTMin(subvars)[source]¶

Bases: SolverParameter

Smallest relative integration time step size allowed [-].

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 = 0.0¶

name: str = 'reldtmin'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_solver.RelDTMax(subvars)[source]¶

Bases: SolverParameter

Largest relative integration time step size allowed [-].

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 = 1.0¶

name: str = 'reldtmax'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

Sequence Features¶

Sequence tools¶

class hydpy.models.wland.wland_sequences.BaseFluxSequence1D(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Base class for FluxSequence1DComplete and FluxSequence1DLand that supports aggregation with respect to AUR.

property refweights¶: Alias for the associated instance of AUR for calculating areal values.

name: str = 'basefluxsequence1d'¶: Name of the variable in lowercase letters.

unit: str = '?'¶: Unit of the variable.

class hydpy.models.wland.wland_sequences.FluxSequence1DComplete(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: BaseFluxSequence1D

Base class for 1-dimensional flux sequences that contain values for all hydrological response units.

The following example shows how subclass PET works:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(4)
>>> lt(FIELD, CONIFER, SEALED, WATER)
>>> aur(0.1, 0.2, 0.3, 0.4)
>>> fluxes.pe = 5.0, 2.0, 4.0, 1.0
>>> from hydpy import round_
>>> round_(fluxes.pe.average_values())
2.5

mask¶

name: str = 'fluxsequence1dcomplete'¶: Name of the variable in lowercase letters.

unit: str = '?'¶: Unit of the variable.

class hydpy.models.wland.wland_sequences.FluxSequence1DLand(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: BaseFluxSequence1D

Base class for 1-dimensional flux sequences that contain values for the land-related hydrological response units.

The following example shows how subclass EI works:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(5)
>>> lt(FIELD, CONIFER, SEALED, FIELD, WATER)
>>> aur(0.05, 0.1, 0.15, 0.2, 0.5)
>>> fluxes.ei = 5.0, 2.0, 4.0, 1.0, nan
>>> from hydpy import round_
>>> round_(fluxes.ei.average_values())
2.5

mask¶

name: str = 'fluxsequence1dland'¶: Name of the variable in lowercase letters.

unit: str = '?'¶: Unit of the variable.

class hydpy.models.wland.wland_sequences.FluxSequence1DSoil(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: BaseFluxSequence1D

Base class for 1-dimensional flux sequences that contain values for the soil-related hydrological response units.

The following example shows how subclass PET works:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(5)
>>> lt(FIELD, CONIFER, SEALED, FIELD, WATER)
>>> aur(0.1, 0.2, 0.12, 0.3, 0.2)
>>> fluxes.pet = 5.0, 2.0, 4.0, 1.0, nan
>>> from hydpy import round_
>>> round_(fluxes.pet.average_values())
2.0

mask¶

name: str = 'fluxsequence1dsoil'¶: Name of the variable in lowercase letters.

unit: str = '?'¶: Unit of the variable.

class hydpy.models.wland.wland_sequences.StateSequence1DLand(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: StateSequence

Base class for 1-dimensional state sequences that support aggregation with respect to AUR for all land-related hydrological response units.

The following example shows how subclass IC works:

>>> from hydpy.models.wland import *
>>> parameterstep()
>>> nu(5)
>>> lt(FIELD, CONIFER, SEALED, FIELD, WATER)
>>> aur(0.05, 0.1, 0.15, 0.2, 0.5)
>>> states.ic = 5.0, 2.0, 4.0, 1.0, nan
>>> from hydpy import round_
>>> round_(states.ic.average_values())
2.5

mask¶

property refweights¶: Alias for the associated instance of AUR for calculating areal values.

name: str = 'statesequence1dland'¶: Name of the variable in lowercase letters.

unit: str = '?'¶: Unit of the variable.

Input sequences¶

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

Bases: InputSequences

Input sequences of model wland.

The following classes are selected:

T() Air temperature [°C].
P() Precipitation [mm/T].
FXG() Seepage/extraction (normalised to AT) [mm/T].
FXS() Surface water supply/extraction (normalised to AT) [mm/T].

class hydpy.models.wland.wland_inputs.T(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: InputSequence

Air temperature [°C].

Required by the methods:: Calc_FR_V1 Calc_PM_V1 Get_MeanTemperature_V1 Get_Temperature_V1

NDIM: int = 0¶

NUMERIC: bool = False¶

STANDARD_NAME: ClassVar[StandardInputNames] = 'air_temperature'¶

name: str = 't'¶: Name of the variable in lowercase letters.

unit: str = '°C'¶: Unit of the variable.

class hydpy.models.wland.wland_inputs.P(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: InputSequence

Precipitation [mm/T].

Required by the method:: Calc_PC_V1

NDIM: int = 0¶

NUMERIC: bool = False¶

STANDARD_NAME: ClassVar[StandardInputNames] = 'precipitation'¶

name: str = 'p'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_inputs.FXG(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: InputSequence

Seepage/extraction (normalised to AT) [mm/T].

Required by the method:: Calc_FXG_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

STANDARD_NAME: ClassVar[StandardInputNames] = 'artificial_groundwater_recharge'¶

name: str = 'fxg'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_inputs.FXS(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: InputSequence

Surface water supply/extraction (normalised to AT) [mm/T].

Required by the method:: Calc_FXS_V1

NDIM: int = 0¶

NUMERIC: bool = False¶

STANDARD_NAME: ClassVar[StandardInputNames] = 'artificial_surface_water_supply'¶

name: str = 'fxs'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

Factor sequences¶

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

Bases: FactorSequences

Factor sequences of model wland.

The following classes are selected:

DHS() External change of the surface water depth [mm/T].

class hydpy.models.wland.wland_factors.DHS(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FactorSequence

External change of the surface water depth [mm/T].

Calculated by the method:: Pick_HS_V1

NDIM: int = 0¶

NUMERIC: bool = False¶

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

name: str = 'dhs'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

Flux sequences¶

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

Bases: FluxSequences

Flux sequences of model wland.

The following classes are selected:

PC() Corrected precipitation [mm/T].
PE() Potential evaporation from the interception and the surface water storage [mm/T].
PET() Potential evapotranspiration from the vadose zone [mm/T].
TF() Total amount of throughfall [mm/T].
EI() Interception evaporation [mm/T].
RF() Rainfall (or, more concrete, the liquid amount of throughfall) [mm/T].
SF() Snowfall (or, more concrete, the frozen amount of throughfall) [mm/T].
PM() Potential snowmelt [mm/T].
AM() Actual snowmelt [mm/T].
PS() Precipitation that enters the surface water reservoir [mm/T].
PVE() Rainfall (and snowmelt) entering the vadose zone in the elevated region [mm/T].
PV() Rainfall (and snowmelt) entering the vadose zone in the lowland region [mm/T].
PQ() Rainfall (and snowmelt) entering the quickflow reservoir [mm/T].
ETVE() Actual evapotranspiration from the vadose zone in the elevated region [mm/T].
ETV() Actual evapotranspiration from the vadose zone in the lowland region [mm/T].
ES() Actual evaporation from the surface water [mm/T].
ET() Total actual evapotranspiration [mm/T].
GR() Groundwater recharge in the elevated region [mm/T].
FXS() Surface water supply/extraction (normalised to ASR) [mm/T].
FXG() Seepage/extraction (normalised to ALR) [mm/T].
CDG() Change in the groundwater depth due to percolation and capillary rise [mm/T].
FGSE() Groundwater flow between the elevated and the lowland region [mm/T].
FGS() Groundwater drainage/surface water infiltration [mm/T].
FQS() Quickflow [mm/T].
RH() Runoff height [mm/T].
R() Runoff [m³/s].

class hydpy.models.wland.wland_fluxes.PC(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Corrected precipitation [mm/T].

Calculated by the method:: Calc_PC_V1
Required by the methods:: Calc_PS_V1 Calc_TF_V1 Get_Precipitation_V1 Update_IC_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'pc'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.PE(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence1DComplete

Potential evaporation from the interception and the surface water storage [mm/T].

Calculated by the methods:: Calc_PE_PET_PETModel_V1 Calc_PE_PET_PETModel_V2 Calc_PE_PET_V1
Required by the methods:: Calc_EI_V1 Calc_ES_V1 Calc_ETVE_ETV_V1

NDIM: int = 1¶

NUMERIC: bool = False¶

name: str = 'pe'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.PET(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence1DSoil

Potential evapotranspiration from the vadose zone [mm/T].

Calculated by the methods:: Calc_PE_PET_PETModel_V1 Calc_PE_PET_PETModel_V2 Calc_PE_PET_V1
Required by the method:: Calc_ETVE_ETV_V1

NDIM: int = 1¶

NUMERIC: bool = False¶

name: str = 'pet'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.TF(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence1DLand

Total amount of throughfall [mm/T].

Calculated by the method:: Calc_TF_V1
Required by the methods:: Calc_RF_V1 Calc_SF_V1 Update_IC_V1

NDIM: int = 1¶

NUMERIC: bool = True¶

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

name: str = 'tf'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.EI(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence1DLand

Interception evaporation [mm/T].

Calculated by the method:: Calc_EI_V1
Required by the methods:: Calc_ETVE_ETV_V1 Calc_ET_V1 Update_IC_V1

NDIM: int = 1¶

NUMERIC: bool = True¶

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

name: str = 'ei'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.RF(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence1DLand

Rainfall (or, more concrete, the liquid amount of throughfall) [mm/T].

Calculated by the method:: Calc_RF_V1
Required by the methods:: Calc_PQ_V1 Calc_PVE_PV_V1

NDIM: int = 1¶

NUMERIC: bool = True¶

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

name: str = 'rf'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.SF(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence1DLand

Snowfall (or, more concrete, the frozen amount of throughfall) [mm/T].

Calculated by the method:: Calc_SF_V1
Required by the method:: Update_SP_V1

NDIM: int = 1¶

NUMERIC: bool = True¶

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

name: str = 'sf'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.PM(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence1DLand

Potential snowmelt [mm/T].

Calculated by the method:: Calc_PM_V1
Required by the method:: Calc_AM_V1

NDIM: int = 1¶

NUMERIC: bool = False¶

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

name: str = 'pm'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.AM(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence1DLand

Actual snowmelt [mm/T].

Calculated by the method:: Calc_AM_V1
Required by the methods:: Calc_PQ_V1 Calc_PVE_PV_V1 Update_SP_V1

NDIM: int = 1¶

NUMERIC: bool = True¶

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

name: str = 'am'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.PS(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Precipitation that enters the surface water reservoir [mm/T].

Calculated by the method:: Calc_PS_V1
Required by the methods:: Calc_RH_V1 Update_HS_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'ps'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.PVE(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Rainfall (and snowmelt) entering the vadose zone in the elevated region [mm/T].

Calculated by the method:: Calc_PVE_PV_V1
Required by the method:: Update_DVE_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'pve'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.PV(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Rainfall (and snowmelt) entering the vadose zone in the lowland region [mm/T].

Calculated by the method:: Calc_PVE_PV_V1
Required by the methods:: Calc_CDG_V2 Update_DV_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'pv'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.PQ(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Rainfall (and snowmelt) entering the quickflow reservoir [mm/T].

Calculated by the method:: Calc_PQ_V1
Required by the method:: Update_HQ_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'pq'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.ETVE(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Actual evapotranspiration from the vadose zone in the elevated region [mm/T].

Calculated by the method:: Calc_ETVE_ETV_V1
Required by the methods:: Calc_ET_V1 Update_DVE_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'etve'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.ETV(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Actual evapotranspiration from the vadose zone in the lowland region [mm/T].

Calculated by the method:: Calc_ETVE_ETV_V1
Required by the methods:: Calc_ET_V1 Update_DV_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'etv'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.ES(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Actual evaporation from the surface water [mm/T].

Calculated by the method:: Calc_ES_V1
Required by the methods:: Calc_ET_V1 Calc_RH_V1 Update_HS_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'es'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.ET(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Total actual evapotranspiration [mm/T].

Calculated by the method:: Calc_ET_V1

NDIM: int = 0¶

NUMERIC: bool = False¶

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

name: str = 'et'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.GR(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Groundwater recharge in the elevated region [mm/T].

Calculated by the method:: Calc_GR_V1
Required by the methods:: Update_DVE_V1 Update_HGE_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'gr'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.FXS(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Surface water supply/extraction (normalised to ASR) [mm/T].

Calculated by the method:: Calc_FXS_V1
Required by the methods:: Calc_RH_V1 Update_HS_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'fxs'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.FXG(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Seepage/extraction (normalised to ALR) [mm/T].

Calculated by the method:: Calc_FXG_V1
Required by the methods:: Calc_CDG_V1 Calc_CDG_V2 Update_DV_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'fxg'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.CDG(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Change in the groundwater depth due to percolation and capillary rise [mm/T].

Calculated by the methods:: Calc_CDG_V1 Calc_CDG_V2
Required by the method:: Update_DG_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'cdg'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.FGSE(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Groundwater flow between the elevated and the lowland region [mm/T].

Calculated by the method:: Calc_FGSE_V1
Required by the methods:: Calc_CDG_V1 Calc_CDG_V2 Update_DV_V1 Update_HGE_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'fgse'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.FGS(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Groundwater drainage/surface water infiltration [mm/T].

Calculated by the method:: Calc_FGS_V1
Required by the methods:: Calc_CDG_V1 Calc_CDG_V2 Calc_RH_V1 Update_DV_V1 Update_HS_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'fgs'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.FQS(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Quickflow [mm/T].

Calculated by the method:: Calc_FQS_V1
Required by the methods:: Calc_RH_V1 Update_HQ_V1 Update_HS_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'fqs'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.RH(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Runoff height [mm/T].

Calculated by the method:: Calc_RH_V1
Required by the methods:: Calc_R_V1 Update_HS_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'rh'¶: Name of the variable in lowercase letters.

unit: str = 'mm/T'¶: Unit of the variable.

class hydpy.models.wland.wland_fluxes.R(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: FluxSequence

Runoff [m³/s].

Calculated by the method:: Calc_R_V1
Required by the method:: Pass_R_V1

NDIM: int = 0¶

NUMERIC: bool = False¶

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

name: str = 'r'¶: Name of the variable in lowercase letters.

unit: str = 'm³/s'¶: Unit of the variable.

State sequences¶

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

Bases: StateSequences

State sequences of model wland.

The following classes are selected:

IC() Interception storage [mm].
SP() Snow pack [mm].
DVE() Storage deficit of the vadose zone in the elevated region [mm].
DV() Storage deficit of the vadose zone in the lowland region [mm].
HGE() Groundwater level in the elevated region [mm].
DG() Groundwater depth in the lowland region [mm].
HQ() Level of the quickflow reservoir [mm].
HS() Surface water level [mm].

class hydpy.models.wland.wland_states.IC(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: StateSequence1DLand

Interception storage [mm].

Updated by the method:: Update_IC_V1
Required by the methods:: Calc_EI_V1 Calc_TF_V1

NDIM: int = 1¶

NUMERIC: bool = True¶

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

name: str = 'ic'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_states.SP(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: StateSequence1DLand

Snow pack [mm].

Updated by the method:: Update_SP_V1
Required by the methods:: Calc_AM_V1 Get_SnowCover_V1

NDIM: int = 1¶

NUMERIC: bool = True¶

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

name: str = 'sp'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_states.DVE(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: StateSequence

Storage deficit of the vadose zone in the elevated region [mm].

Updated by the method:: Update_DVE_V1
Required by the methods:: Calc_BetaE_Beta_V1 Calc_GR_V1 Calc_WE_W_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'dve'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_states.DV(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: StateSequence

Storage deficit of the vadose zone in the lowland region [mm].

Updated by the method:: Update_DV_V1
Required by the methods:: Calc_BetaE_Beta_V1 Calc_CDG_V1 Calc_CDG_V2 Calc_DGEq_V1 Calc_WE_W_V1 Return_ErrorDV_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'dv'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_states.HGE(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: StateSequence

Groundwater level in the elevated region [mm].

Updated by the method:: Update_HGE_V1
Required by the method:: Calc_FGSE_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'hge'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_states.DG(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: StateSequence

Groundwater depth in the lowland region [mm].

Updated by the method:: Update_DG_V1
Required by the methods:: Calc_CDG_V1 Calc_CDG_V2 Calc_DVEq_V1 Calc_DVEq_V2 Calc_DVEq_V3 Calc_DVEq_V4 Calc_FGSE_V1 Calc_FGS_V1 Calc_GF_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'dg'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_states.HQ(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: StateSequence

Level of the quickflow reservoir [mm].

Updated by the method:: Update_HQ_V1
Required by the method:: Calc_FQS_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'hq'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_states.HS(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: StateSequence

Surface water level [mm].

Updated by the methods:: Pick_HS_V1 Update_HS_V1
Required by the methods:: Calc_ES_V1 Calc_FGS_V1 Calc_RH_V1

NDIM: int = 0¶

NUMERIC: bool = True¶

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

name: str = 'hs'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

Outlet sequences¶

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

Bases: OutletSequences

Outlet sequences of model wland.

The following classes are selected:

Q() Discharge [m³/s].

class hydpy.models.wland.wland_outlets.Q(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: OutletSequence

Discharge [m³/s].

Calculated by the method:: Pass_R_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.wland.AideSequences(master: Sequences, cls_fastaccess: type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: AideSequences

Aide sequences of model wland.

The following classes are selected:

FR() Fraction rainfall / total precipitation [-].
WE() Wetness index in the elevated region [-].
W() Wetness index in the lowland region [-].
BetaE() Evapotranspiration reduction factor in the elevated region [-].
Beta() Evapotranspiration reduction factor in the lowland region [-].
DVEq() Equilibrium storage deficit of the vadose zone for the actual groundwater depth [mm].
DGEq() Equilibrium groundwater depth for the actual storage deficit of the vadose zone [mm].
GF() Gain factor for changes in groundwater depth [-].

class hydpy.models.wland.wland_aides.FR(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: AideSequence

Fraction rainfall / total precipitation [-].

Calculated by the method:: Calc_FR_V1
Required by the methods:: Calc_RF_V1 Calc_SF_V1

NDIM: int = 0¶

NUMERIC: bool = False¶

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

name: str = 'fr'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_aides.WE(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: AideSequence

Wetness index in the elevated region [-].

Calculated by the method:: Calc_WE_W_V1
Required by the methods:: Calc_PQ_V1 Calc_PVE_PV_V1

NDIM: int = 0¶

NUMERIC: bool = False¶

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

name: str = 'we'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_aides.W(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: AideSequence

Wetness index in the lowland region [-].

Calculated by the method:: Calc_WE_W_V1
Required by the methods:: Calc_PQ_V1 Calc_PVE_PV_V1

NDIM: int = 0¶

NUMERIC: bool = False¶

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

name: str = 'w'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_aides.BetaE(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: AideSequence

Evapotranspiration reduction factor in the elevated region [-].

Calculated by the method:: Calc_BetaE_Beta_V1
Required by the method:: Calc_ETVE_ETV_V1

NDIM: int = 0¶

NUMERIC: bool = False¶

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

name: str = 'betae'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_aides.Beta(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: AideSequence

Evapotranspiration reduction factor in the lowland region [-].

Calculated by the method:: Calc_BetaE_Beta_V1
Required by the method:: Calc_ETVE_ETV_V1

NDIM: int = 0¶

NUMERIC: bool = False¶

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

name: str = 'beta'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

class hydpy.models.wland.wland_aides.DVEq(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: AideSequence

Equilibrium storage deficit of the vadose zone for the actual groundwater depth [mm].

Calculated by the methods:: Calc_DVEq_V1 Calc_DVEq_V2 Calc_DVEq_V3 Calc_DVEq_V4
Required by the methods:: Calc_CDG_V1 Calc_CDG_V2

NDIM: int = 0¶

NUMERIC: bool = False¶

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

name: str = 'dveq'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_aides.DGEq(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: AideSequence

Equilibrium groundwater depth for the actual storage deficit of the vadose zone [mm].

Calculated by the method:: Calc_DGEq_V1
Required by the method:: Calc_GF_V1

NDIM: int = 0¶

NUMERIC: bool = False¶

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

name: str = 'dgeq'¶: Name of the variable in lowercase letters.

unit: str = 'mm'¶: Unit of the variable.

class hydpy.models.wland.wland_aides.GF(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶

Bases: AideSequence

Gain factor for changes in groundwater depth [-].

Calculated by the method:: Calc_GF_V1
Required by the method:: Calc_CDG_V2

NDIM: int = 0¶

NUMERIC: bool = False¶

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

name: str = 'gf'¶: Name of the variable in lowercase letters.

unit: str = '-'¶: Unit of the variable.

Auxiliary Features¶

Masks¶

class hydpy.models.wland.Masks[source]

Bases: Masks

Masks of base model wland.

The following classes are selected:

Complete() Mask including all land use types.
Land() Mask excluding the land type WATER.
Soil() Mask excluding the land types WATER and SEALED.
Sealed() Mask for the land type SEALED.
Water() Mask for the land type WATER.

class hydpy.models.wland.wland_masks.Complete(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)[source]¶

Bases: IndexMask

Mask including all land use types.

relevant: tuple[int, ...] = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23)¶: The integer values that are relevant to the referenced index parameter.

static get_refindices(variable)[source]¶: Reference to the associated instance of LT.

name: str = 'complete'¶

class hydpy.models.wland.wland_masks.Land(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)[source]¶

Bases: Complete

Mask excluding the land type WATER.

relevant: tuple[int, ...] = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)¶: The integer values that are relevant to the referenced index parameter.

name: str = 'land'¶

class hydpy.models.wland.wland_masks.Soil(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)[source]¶

Bases: Complete

Mask excluding the land types WATER and SEALED.

relevant: tuple[int, ...] = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)¶: The integer values that are relevant to the referenced index parameter.

name: str = 'soil'¶

class hydpy.models.wland.wland_masks.Sealed(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)[source]¶

Bases: Complete

Mask for the land type SEALED.

relevant: tuple[int, ...] = (12,)¶: The integer values that are relevant to the referenced index parameter.

name: str = 'sealed'¶

class hydpy.models.wland.wland_masks.Water(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)[source]¶

Bases: Complete

Mask for the land type WATER.

relevant: tuple[int, ...] = (23,)¶: The integer values that are relevant to the referenced index parameter.

name: str = 'water'¶

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

Bases: AideSequences

Aide sequences of model wland.

The following classes are selected:

FR() Fraction rainfall / total precipitation [-].
WE() Wetness index in the elevated region [-].
W() Wetness index in the lowland region [-].
BetaE() Evapotranspiration reduction factor in the elevated region [-].
Beta() Evapotranspiration reduction factor in the lowland region [-].
DVEq() Equilibrium storage deficit of the vadose zone for the actual groundwater depth [mm].
DGEq() Equilibrium groundwater depth for the actual storage deficit of the vadose zone [mm].
GF() Gain factor for changes in groundwater depth [-].

class hydpy.models.wland.ControlParameters(master: Parameters, cls_fastaccess: type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)¶

Bases: SubParameters

Control parameters of model wland.

The following classes are selected:

AT() Total area [km²].
NU() Number of hydrological response units [-].
LT() Landuse type [-].
ER() Elevated region [-].
AUR() Relative area of each hydrological response unit [-].
GL() The lowland region’s average ground level [m].
BL() Channel bottom level [m].
CP() Factor for correcting precipitation [-].
LAI() Leaf area index [-].
IH() Interception capacity with respect to the leaf surface area [mm].
TT() Threshold temperature for snow/rain [°C].
TI() Temperature interval with a mixture of snow and rain [°C].
DDF() Day degree factor [mm/°C/T].
DDT() Day degree threshold temperature [°C].
CWE() Wetness index parameter for the elevated region [mm].
CW() Wetness index parameter for the lowland region [mm].
CV() Vadose zone relaxation time constant for the lowland region [T].
CGE() Groundwater reservoir constant for the elevated region [mm T].
CG() Groundwater reservoir constant for the lowland region [mm T].
RG() Groundwater reservoir restriction [-].
CGF() Groundwater reservoir flood factor [1/mm].
DGC() Direct groundwater connect [-].
CQ() Quickflow reservoir relaxation time [T].
B() Pore size distribution parameter [-].
PsiAE() Air entry pressure [mm].
ThetaS() Soil moisture content at saturation [-].
ThetaR() Residual soil moisture deficit at tension saturation [-].
AC() Air capacity for the elevated region [mm].
Zeta1() Curvature parameter of the evapotranspiration reduction function [-].
Zeta2() Inflection point of the evapotranspiration reduction function [mm].
SH() General smoothing parameter related to the height of water columns [mm].
ST() General smoothing parameter related to temperature [°C].

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

Bases: SubParameters

Derived parameters of model wland.

The following classes are selected:

MOY() References the “global” month of the year index array [-].
NUL() Number of land-related hydrological response units [-].
NUGE() Number of groundwater-affected hydrological response units in the elevated region [-].
NUG() Number of groundwater-affected hydrological response units in the lowland region [-].
ALR() Relative land area [-].
ASR() Relative surface water area fraction [-].
AGRE() Relative groundwater area in the elevated region [-].
AGR() Relative groundwater area in the lowland region [-].
QF() Factor for converting mm/T to m³/s [T m³ / mm s].
CD() Channel depth [mm].
RH1() Regularisation parameter related to the height of water columns used when applying regularisation function smooth_logistic1() [mm].
RH2() Regularisation parameter related to the height of water columns used when applying regularisation function smooth_logistic2() [mm].
RT2() Regularisation parameter related to temperature for applying regularisation function smooth_logistic2()) [°C].

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

Bases: FactorSequences

Factor sequences of model wland.

The following classes are selected:

DHS() External change of the surface water depth [mm/T].

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

Bases: SubParameters

Fixed parameters of model wland.

The following classes are selected:

Pi() π [-].

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

Bases: FluxSequences

Flux sequences of model wland.

The following classes are selected:

PC() Corrected precipitation [mm/T].
PE() Potential evaporation from the interception and the surface water storage [mm/T].
PET() Potential evapotranspiration from the vadose zone [mm/T].
TF() Total amount of throughfall [mm/T].
EI() Interception evaporation [mm/T].
RF() Rainfall (or, more concrete, the liquid amount of throughfall) [mm/T].
SF() Snowfall (or, more concrete, the frozen amount of throughfall) [mm/T].
PM() Potential snowmelt [mm/T].
AM() Actual snowmelt [mm/T].
PS() Precipitation that enters the surface water reservoir [mm/T].
PVE() Rainfall (and snowmelt) entering the vadose zone in the elevated region [mm/T].
PV() Rainfall (and snowmelt) entering the vadose zone in the lowland region [mm/T].
PQ() Rainfall (and snowmelt) entering the quickflow reservoir [mm/T].
ETVE() Actual evapotranspiration from the vadose zone in the elevated region [mm/T].
ETV() Actual evapotranspiration from the vadose zone in the lowland region [mm/T].
ES() Actual evaporation from the surface water [mm/T].
ET() Total actual evapotranspiration [mm/T].
GR() Groundwater recharge in the elevated region [mm/T].
FXS() Surface water supply/extraction (normalised to ASR) [mm/T].
FXG() Seepage/extraction (normalised to ALR) [mm/T].
CDG() Change in the groundwater depth due to percolation and capillary rise [mm/T].
FGSE() Groundwater flow between the elevated and the lowland region [mm/T].
FGS() Groundwater drainage/surface water infiltration [mm/T].
FQS() Quickflow [mm/T].
RH() Runoff height [mm/T].
R() Runoff [m³/s].

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

Bases: InputSequences

Input sequences of model wland.

The following classes are selected:

T() Air temperature [°C].
P() Precipitation [mm/T].
FXG() Seepage/extraction (normalised to AT) [mm/T].
FXS() Surface water supply/extraction (normalised to AT) [mm/T].

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

Bases: OutletSequences

Outlet sequences of model wland.

The following classes are selected:

Q() Discharge [m³/s].

class hydpy.models.wland.SolverParameters(master: Parameters, cls_fastaccess: type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)¶

Bases: SubParameters

Solver parameters of model wland.

The following classes are selected:

AbsErrorMax() Absolute numerical error tolerance [mm/T].
RelErrorMax() Relative numerical error tolerance [-].
RelDTMin() Smallest relative integration time step size allowed [-].
RelDTMax() Largest relative integration time step size allowed [-].

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

Bases: StateSequences

State sequences of model wland.

The following classes are selected:

IC() Interception storage [mm].
SP() Snow pack [mm].
DVE() Storage deficit of the vadose zone in the elevated region [mm].
DV() Storage deficit of the vadose zone in the lowland region [mm].
HGE() Groundwater level in the elevated region [mm].
DG() Groundwater depth in the lowland region [mm].
HQ() Level of the quickflow reservoir [mm].
HS() Surface water level [mm].

Table of Contents

Previous topic

Next topic

This Page

Versions

HydPy-W (base model)¶

Method Features¶

Parameter Features¶

Parameter tools¶

Constants¶

Control parameters¶

Derived parameters¶

Fixed parameters¶

Solver parameters¶

Sequence Features¶

Sequence tools¶

Input sequences¶

Factor sequences¶

Flux sequences¶

State sequences¶

Outlet sequences¶

Aide sequences¶

Auxiliary Features¶

Masks¶