HydPy-H-HBV96-COSERO (fusion of SMHI-IHMS-HBV96 and COSERO)

hland_96c combines HBV96’s (Lindström et al., 1997) and COSERO’s (Kling, 2006, Kling et al., 2005) process equations. We implemented it on behalf of the German Federal Institute of Hydrology (BfG) as an alternative to hland_96 for modelling large river basins in central Europe. All processes “above the soil” (input data correction, interception, snowmelt) and “inside the soil” (evaporation, generation of effective precipitation), as well as the handling of water areas, are identical with hland_96 (and so with HBV96). Most processes “below the soil” agree with COSERO (runoff generation and runoff concentration).

The following figure shows the general structure of hland_96c:

_images/HydPy-H-HBV96-COSERO.png

Comparing the above figure with the analogue figure of hland_96 reveals that hland_96c models three instead of two runoff components, requiring a larger number of vertically arranged storages. The two upper storages (BW1 and BW2) are zone-specific. In comparison, the upper zone layer (UZ) of hland_96 is subbasin-specific. For the subbasin-wide lower zone storage (LZ), there is no difference to hland_96. Like all hland application models, hland_96c allows an optional submodel for runoff concentration. Using rconc_nash and setting the number of storages to one agrees with COSERO’s approach to model runoff concentration with a single bucket. In agreement with COSERO but in contrast to hland_96p, hland_96c does not take base flow into account when calculating runoff concentration.

Integration tests

Note

When new to HydPy, consider reading section Integration Tests first.

We define the settings of the following test calculations as similar to the ones of application model hland_96 as possible. Hence, comparing the test results gives a good impression of the functional differences of both models.

>>> from hydpy import pub
>>> pub.timegrids = "01.01.2000", "05.01.2000", "1h"

>>> from hydpy.models.hland_96c import *
>>> parameterstep("1h")
>>> from hydpy import Node, Element
>>> outlet = Node("outlet")
>>> land = Element("land", outlets=outlet)
>>> land.model = model

>>> nmbzones(1)
>>> sclass(1)
>>> area(1.0)
>>> zonearea(1.0)
>>> zonez(1.0)
>>> psi(1.0)

We assign identical values to all parameters, besides those that are specific to hland_96c (H1, TAb1, TVs1, H1, TAb1, TVs1):

>>> zonetype(FIELD)

>>> pcorr(1.1)
>>> pcalt(0.1)
>>> rfcf(1.1)
>>> sfcf(1.3)
>>> tcorr(0.6)
>>> tcalt(0.6)
>>> icmax(2.0)
>>> sfdist(1.0)
>>> smax(inf)
>>> sred(0.0)
>>> tt(0.0)
>>> ttint(2.0)
>>> dttm(1.0)
>>> cfmax(0.5)
>>> cfvar(0.1)
>>> gmelt(1.0)
>>> gvar(0.2)
>>> cfr(0.1)
>>> whc(0.4)
>>> fc(200.0)
>>> beta(2.0)
>>> h1(10.0)
>>> tab1(2.0)
>>> tvs1(2.0)
>>> h2(10.0)
>>> tab2(10.0)
>>> tvs2(10.0)
>>> k4(0.005)
>>> gamma(0.0)

>>> with model.add_aetmodel_v1("evap_aet_hbv96"):
...     temperaturethresholdice(0.0)
...     soilmoisturelimit(0.8)
...     excessreduction(0.5)
...     with model.add_petmodel_v1("evap_pet_hbv96"):
...         evapotranspirationfactor(0.7)
...         airtemperaturefactor(0.1)
...         altitudefactor(-0.1)
...         precipitationfactor(0.1)

>>> with model.add_rconcmodel_v1("rconc_nash"):
...     retentiontime(3.0)
...     nmbstorages(5)
...     nmbsteps(100)

>>> from hydpy import IntegrationTest
>>> IntegrationTest.plotting_options.axis1 = (
...     inputs.p, fluxes.qab1, fluxes.qab2, fluxes.q1, fluxes.rt)
>>> IntegrationTest.plotting_options.axis2 = inputs.t
>>> test = IntegrationTest(land)
>>> test.dateformat = "%d/%m %H:00"

>>> test.inits = ((states.ic, 0.0),
...               (states.sp, 0.0),
...               (states.wc, 0.0),
...               (states.sm, 100.0),
...               (states.bw1, 0.0),
...               (states.bw2, 0.0),
...               (states.lz, 10.0),
...               (model.rconcmodel.sequences.states.sc, 0.05))

>>> inputs.p.series = (
...     0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
...     0.2, 0.0, 0.0, 1.3, 5.6, 2.9, 4.9, 10.6, 0.1, 0.7, 3.0, 2.1, 10.4, 3.5, 3.4,
...     1.2, 0.1, 0.0, 0.0, 0.4, 0.1, 3.6, 5.9, 1.1, 20.7, 37.9, 8.2, 3.6, 7.5, 18.5,
...     15.4, 6.3, 1.9, 4.9, 2.7, 0.5, 0.2, 0.5, 2.4, 0.4, 0.2, 0.0, 0.0, 0.3, 2.6,
...     0.7, 0.3, 0.3, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
...     1.3, 0.0, 0.0, 0.0, 0.7, 0.4, 0.1, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
...     0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
>>> inputs.t.series = (
...     21.2, 19.4, 18.9, 18.3, 18.9, 22.5, 25.1, 28.3, 27.8, 31.4, 32.2, 35.2, 37.1,
...     31.2, 24.3, 25.4, 25.9, 23.7, 21.6, 21.2, 20.4, 19.8, 19.6, 19.2, 19.2, 19.2,
...     18.9, 18.7, 18.5, 18.3, 18.5, 18.8, 18.8, 19.0, 19.2, 19.3, 19.0, 18.8, 18.7,
...     17.8, 17.4, 17.3, 16.8, 16.5, 16.3, 16.2, 15.5, 14.6, 14.7, 14.6, 14.1, 14.3,
...     14.9, 15.7, 16.0, 16.7, 17.1, 16.2, 15.9, 16.3, 16.3, 16.4, 16.5, 18.4, 18.3,
...     18.1, 16.7, 15.2, 13.4, 12.4, 11.6, 11.0, 10.5, 11.7, 11.9, 11.2, 11.1, 11.9,
...     12.2, 11.8, 11.4, 11.6, 13.0, 17.1, 18.2, 22.4, 21.4, 21.8, 22.2, 20.1, 17.8,
...     15.2, 14.5, 12.4, 11.7, 11.9)
>>> petinputs = model.aetmodel.petmodel.sequences.inputs
>>> petinputs.normalairtemperature.series = inputs.t.series - 1.0
>>> petinputs.normalevapotranspiration.series = (
...     0.100707, 0.097801, 0.096981, 0.09599, 0.096981, 0.102761, 0.291908, 1.932875,
...     4.369536, 7.317556, 8.264362, 9.369867, 5.126178, 6.62503, 7.397619, 2.39151,
...     1.829834, 1.136569, 0.750986, 0.223895, 0.099425, 0.098454, 0.098128, 0.097474,
...     0.097474, 0.097474, 0.096981, 0.096652, 0.096321, 0.09599, 0.187298, 1.264612,
...     3.045538, 1.930758, 2.461001, 6.215945, 3.374783, 8.821555, 4.046025, 2.110757,
...     2.239257, 2.877848, 1.591452, 0.291604, 0.092622, 0.092451, 0.091248, 0.089683,
...     0.089858, 0.089683, 0.088805, 0.089157, 0.090207, 0.091593, 0.154861, 0.470369,
...     1.173726, 4.202296, 4.359715, 5.305753, 5.376027, 4.658915, 7.789594, 4.851567,
...     5.30692, 3.286036, 1.506216, 0.274762, 0.087565, 0.085771, 0.084317, 0.083215,
...     0.082289, 0.0845, 0.084864, 0.083584, 0.0834, 0.084864, 0.310229, 1.391958,
...     3.195876, 5.191651, 7.155036, 8.391432, 8.391286, 10.715238, 9.383394, 7.861915,
...     6.298329, 2.948416, 1.309232, 0.32955, 0.089508, 0.085771, 0.0845, 0.084864)

>>> test.reset_inits()
>>> conditions = model.conditions

field

hland_96c neither implements an approach analogue to HBV96’s contributing area concept nor a substep mechanism controlling the numerical accuracy of the runoff generation module. Hence, we provide only a single “field” example, that is comparable both with the first and the second example of hland_96:

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

There is no indication of an error in the water balance:

>>> from hydpy import round_
>>> round_(model.check_waterbalance(conditions))
0.0

internal lake

Regarding the simulation of internal lakes, the functionalities of hland_96c are identical to hland_96. Hence, the simulated baseflow shown in the following table agrees with the internal lake example of hland_96. Nevertheless, the resulting subbasin’s outflow appears less smoothed due to hland_96c not sending its baseflow through the linear storage cascade:

>>> zonetype(ILAKE)
>>> model.aetmodel.parameters.control.temperaturethresholdice(13.0)
>>> test.inits.sc = 0.0
>>> test.reset_inits()
>>> conditions = model.conditions
>>> test("hland_96c_ilake")
Click to see the table
Click to see the graph

There is no indication of an error in the water balance:

>>> round_(model.check_waterbalance(conditions))
0.0

snow classes

Regarding snow simulation, all functionalities of hland_96c are identical with the ones of hland_96. Hence, all snow data in the following table agrees with the snow classes example of hland_96:

>>> sclass(2)
>>> sfdist(linear=0.2)
>>> zonetype(FIELD)
>>> t_series = inputs.t.series.copy()
>>> tn_series = petinputs.normalairtemperature.series.copy()
>>> inputs.t.series[:48] = -20.0
>>> inputs.t.series[48:] = 20.0
>>> petinputs.normalairtemperature.series = inputs.t.series
>>> test("hland_96c_snow_classes")
Click to see the table
Click to see the graph

There is no indication of an error in the water balance:

>>> round_(model.check_waterbalance(conditions))
0.0

glacier

Regarding glacier simulation, all functionalities of hland_96c are identical with the ones of hland_96. Hence, all snow data in the following table agrees with the glacier example of hland_96:

>>> zonetype(GLACIER)
>>> test.inits.sc = 0.05
>>> test.reset_inits()
>>> conditions = model.conditions
>>> test("hland_96c_glacier")
Click to see the table
Click to see the graph

There is no indication of an error in the water balance:

>>> round_(model.check_waterbalance(conditions))
0.0

multiple zones

This example focuses on the spatial configuration of hland_96c. The most marked difference to hland_96 is the separate modelling of the faster runoff components (QAb1, QAb2) for each zone. Hence, there are five distinct values for each runoff component in the following table. In contrast, the table of the corresponding multiple zones example of hland_96 contains only a single value for the only fast runoff component Q0 of hland_96:

>>> name2value = {par.name: par.value for par in control}
>>> nmbzones(5)
>>> sclass(1)
>>> area(15.0)
>>> zonearea(5.0, 4.0, 3.0, 2.0, 1.0)
>>> zonetype(FIELD, FOREST, GLACIER, ILAKE, SEALED)
>>> sfdist(1.0)
>>> for name, value in name2value.items():
...     if name not in ("nmbzones", "sclass", "area", "zonearea", "zonetype", "sfdist"):
...         control[name].value = value
>>> model.add_aetmodel_v1.update(model, model.aetmodel, refresh=True)
>>> model.aetmodel.add_petmodel_v1.update(model.aetmodel, model.aetmodel.petmodel, refresh=True)
>>> aetcontrol = model.aetmodel.parameters.control
>>> aetcontrol.temperaturethresholdice(0.0)
>>> aetcontrol.soilmoisturelimit(0.8)
>>> aetcontrol.excessreduction(0.5)
>>> petcontrol = model.aetmodel.petmodel.parameters.control
>>> petcontrol.evapotranspirationfactor(0.7)
>>> petcontrol.airtemperaturefactor(0.1)
>>> petcontrol.altitudefactor(-0.1)
>>> petcontrol.precipitationfactor(0.1)
>>> inputs.t.series = t_series
>>> petinputs.normalairtemperature.series = tn_series
>>> test("hland_96c_multiple_zones",
...      axis1=(inputs.p, fluxes.rt, fluxes.qt),
...      axis2=inputs.t)
Click to see the table
Click to see the graph

There is no indication of an error in the water balance:

>>> round_(model.check_waterbalance(conditions))
0.0

snow redistribution

Regarding snow redistribution, all functionalities of hland_96c are identical with the ones of hland_96. Hence, all snow data in the following table agrees with the snow redistribution 1 example of hland_96:

>>> zonez(0.0, 10.0, 30.0, 0.0, 20.0)
>>> smax(200.0)
>>> sred(n_zones=1)
>>> inputs.t.series = -0.4
>>> pcorr *= 2.0
>>> pcalt(0.05)
>>> test("hland_96c_snow_redistribution",
...      axis1=(states.sp, states.wc), axis2=(factors.tc, fluxes.pc))
Click to see the table
Click to see the graph

There is no indication of an error in the water balance:

>>> round_(model.check_waterbalance(conditions))
0.0

The submodel rconcmodel is optional. We repeat the last integration test, but without a submodel for runoff concentration.

>>> model.rconcmodel = None

>>> test("hland_96c_snow_redistribution",
...      axis1=(states.sp, states.wc), axis2=(factors.tc, fluxes.pc))
Click to see the table
Click to see the graph

There is no indication of an error in the water balance:

>>> round_(model.check_waterbalance(conditions))
0.0
class hydpy.models.hland_96c.Model[source]

Bases: Main_AETModel_V1, Main_RConcModel_V1, Sub_TempModel_V1, Sub_PrecipModel_V1, Sub_IntercModel_V1, Sub_SoilWaterModel_V1, Sub_SnowCoverModel_V1

HydPy-H-HBV96-COSERO (fusion of SMHI-IHMS-HBV96 and COSERO).

The following “run methods” are called in the given sequence during each simulation step:

  • Calc_TC_V1 Adjust the measured air temperature to the altitude of the individual zones.

  • Calc_FracRain_V1 Determine the temperature-dependent fraction of (liquid) rainfall and (total) precipitation.

  • Calc_PC_V1 Apply the precipitation correction factors and adjust precipitation to the altitude of the individual zones.

  • Calc_TF_Ic_V1 Calculate throughfall and update the interception storage accordingly.

  • Calc_SP_WC_V1 Add throughfall to the snow layer.

  • Calc_SPL_WCL_SP_WC_V1 Calculate the subbasin-internal redistribution losses of the snow layer.

  • Calc_SPG_WCG_SP_WC_V1 Calculate the subbasin-internal redistribution gains of the snow layer.

  • Calc_CFAct_V1 Adjust the day degree factor for snow to the current day of the year.

  • Calc_Melt_SP_WC_V1 Calculate the melting of the ice content within the snow layer and update both the snow layers’ ice and the water content.

  • Calc_Refr_SP_WC_V1 Calculate refreezing of the water content within the snow layer and update both the snow layers’ ice and the water content.

  • Calc_In_WC_V1 Calculate the actual water release from the snow layer due to the exceedance of the snow layers’ capacity for (liquid) water.

  • Calc_SWE_V1 Calculate the total snow water equivalent.

  • Calc_SR_V1 Calculate the sealed surface runoff.

  • Calc_GAct_V1 Adjust the day degree factor for glacier ice to the current day of the year.

  • Calc_GlMelt_In_V1 Calculate the melting of non-snow-covered glaciers and add it to the water release of the snow module.

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

  • Calc_R_SM_V1 Calculate effective precipitation and update the soil moisture.

  • Calc_EA_SM_V1 Let a submodel that follows the AETModel_V1 submodel interface calculate soil evapotranspiration and adjust the soil water content.

  • Calc_QAb1_QVs1_BW1_V1 Calculate the flow and the percolation from the surface flow reservoir and update it.

  • Calc_QAb2_QVs2_BW2_V1 Calculate the flow and the percolation from the interflow reservoir and update it.

  • Calc_InRC_V3 Calculate the input of the runoff concentration submodel.

  • Calc_OutRC_V1 If the model has a submodel that follows the RConcModel_V1 submodel interface, calculate runoff concentration. If not, set the output equal to the input.

  • Calc_LZ_V2 Add percolation from the interflow reservoir and lake precipitation to the lower zone storage.

  • Calc_EL_LZ_V1 Let a submodel that follows the AETModel_V1 submodel interface calculate lake evaporation and adjust the lower zone’s water content.

  • Calc_Q1_LZ_V1 Calculate the slow response of the lower zone layer.

  • Calc_RT_V2 Calculate the total discharge in mm.

  • Calc_QT_V1 Calculate the total discharge in m³/s.

The following “outlet update methods” are called in the given sequence at the end of each simulation step:
The following interface methods are available to main models using the defined model as a submodel:
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:
Users can hook submodels into the defined main model if they satisfy one of the following interfaces:

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

  • RConcModel_V1 Simple interface for calculating runoff concentration processes.

DOCNAME = ('H-HBV96-COSERO', 'fusion of SMHI-IHMS-HBV96 and COSERO')
aetmodel

Required submodel that complies with the following interface: AETModel_V1.

rconcmodel

Optional submodel that complies with the following interface: RConcModel_V1.

check_waterbalance(initial_conditions: dict[str, dict[str, dict[str, float | NDArray[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}\Sigma In_{hru} - \Sigma Out_{hru} - \Sigma Out_{basin} + \Delta Vol_{hru} + \Delta Vol_{snow} + \Delta Vol_{basin} - \Delta Vol_{rconc} \\ \\ \Sigma In_{hru} = \sum_{k=1}^{N_{hru}} A_Z^k \cdot \sum_{t=t0}^{t1} PC_t^k + GLMelt_t^k \\ \Sigma Out_{hru} = \sum_{k=1}^{N_{hru}} A_Z^k \cdot \sum_{t=t0}^{t1} EI_t^k + EA_t^k + EL_t^k \\ \Sigma Out_{basin} = \sum_{t=t0}^{t1} RT_t \\ \Delta Vol_{snow} = \sum_{k=1}^{N_{hru}} A_Z^k \cdot \frac{1}{N_{snow}} \cdot \sum_{c=1}^{N_{snow}} \left(SP_{t0}^{k,s} - SP_{t1}^{k,s}\right) + \left(WC_{t0}^{k,s} - WC_{t1}^{k,s}\right) \\ \Delta Vol_{hru} = \sum_{k=1}^{N_{hru}} A_Z^k \cdot \Big( \big(IC_{t0}^k - IC_{t1}^k\big) + \big(SM_{t0}^k - SM_{t1}^k\big) + \big( BW1_{t0}^k - BW2_{t1}^k \big) + \big( BW2_{t0}^k - BW2_{t1}^k \big) \Big) \\ \Delta Vol_{basin} = A_L \cdot \big( LZ_{t0} - LZ_{t1} \big) \\ \Delta Vol_{rconc} = \begin{cases} rconcmodel.get\_waterbalance &|\ rconcmodel \\ 0 &|\ \overline{rconcmodel} \end{cases} \\ \\ N_{hru} = NmbZones \\ N_{snow} = SClass \\ A_Z = RelZoneAreas \\ A_L = RelLowerZoneArea\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 run via property conditions. See the integration tests of the application model hland_96c for some examples.

REUSABLE_METHODS = ()
class hydpy.models.hland_96c.Masks[source]

Bases: Masks

Masks applicable to hland_96c.

The following classes are selected:
class hydpy.models.hland_96c.AideSequences(master: Sequences[TM_co], cls_fastaccess: type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: AideSequences

Aide sequences of model hland_96c.

The following classes are selected:

  • SPE() Subbasin-internal redistribution excess of the snow’s ice content [mm/T].

  • WCE() Subbasin-internal redistribution excess of the snow’s water content [mm/T].

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

Bases: ControlParameters

Control parameters of model hland_96c.

The following classes are selected:

  • Area() Subbasin area [km²].

  • NmbZones() Number of zones (hydrological response units) in a subbasin [-].

  • SClass() Number of snow classes in each zone [-].

  • ZoneType() Type of each zone [-].

  • ZoneArea() Zone area [km²].

  • Psi() Fraction of the actual sealing of zones classified as SEALED [-].

  • ZoneZ() Zone elevation [100m].

  • PCorr() General precipitation correction factor [-].

  • PCAlt() Elevation correction factor for precipitation [1/100m].

  • RfCF() Rainfall correction factor [-].

  • SfCF() Snowfall correction factor [-].

  • TCorr() General temperature correction addend [-].

  • TCAlt() Elevation correction factor for temperature [-1°C/100m].

  • IcMax() Maximum interception storage [mm].

  • SFDist() Distribution of snowfall [-].

  • SMax() Maximum snow water equivalent [mm].

  • SRed() Snow redistribution paths [-].

  • TT() Temperature threshold for snow/rain [°C].

  • TTInt() Temperature interval with a mixture of snow and rain [°C].

  • DTTM() Difference between TTM and TT [°C].

  • CFMax() Average degree day factor for snow (on glaciers or not) [mm/°C/T].

  • CFVar() Annual variability of CFMax [mm/°C/T].

  • GMelt() Degree day factor for glacial ice [mm/°C/T].

  • GVar() Annual variability of GMelt [mm/°C/T].

  • CFR() Refreezing factor for water stored within the snow layer [-].

  • WHC() Relative water holding capacity of the snow layer [-].

  • FC() Maximum soil moisture content (field capacity) [mm].

  • Beta() Nonlinearity parameter of the soil routine [-].

  • H1() Outlet level of the reservoir for simulating surface flow [mm].

  • TAb1() Recession coefficient for simulating surface flow [T].

  • TVs1() Recession coefficient for simulating percolation from the surface flow module [T].

  • H2() Outlet level of the reservoir for simulating interflow [mm].

  • TAb2() Recession coefficient for simulating interflow [T].

  • TVs2() Recession coefficient for simulating percolation from the interflow module [T].

  • K4() Recession coefficient of the lower zone layer [1/T].

  • Gamma() Nonlinearity parameter of the lower zone layer [-].

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

Bases: DerivedParameters

Derived parameters of model hland_96c.

The following classes are selected:
class hydpy.models.hland_96c.FactorSequences(master: Sequences[TM_co], cls_fastaccess: type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: FactorSequences

Factor sequences of model hland_96c.

The following classes are selected:

  • TC() Corrected temperature [°C].

  • FracRain() Fraction rainfall / total precipitation [-].

  • CFAct() Actual degree day factor for snow (on glaciers or not) [mm/°C/T].

  • SWE() Snow water equivalent [mm].

  • GAct() Actual degree day factor for glacier ice [mm/°C/T].

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

Bases: FixedParameters

Fixed parameters of model hland_96c.

The following classes are selected:
class hydpy.models.hland_96c.FluxSequences(master: Sequences[TM_co], cls_fastaccess: type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)

Bases: FluxSequences

Flux sequences of model hland_96c.

The following classes are selected:

  • PC() Corrected precipitation [mm/T].

  • EI() Interception evaporation [mm/T].

  • TF() Throughfall [mm/T].

  • SPL() Subbasin-internal redistribution loss of the snow’s ice content [mm/T].

  • WCL() Subbasin-internal redistribution loss of the snow’s water content [mm/T].

  • SPG() Subbasin-internal redistribution gain of the snow’s ice content [mm/T].

  • WCG() Subbasin-internal redistribution gain of the snow’s water content [mm/T].

  • GlMelt() Glacier melt [mm/T].

  • Melt() Actual melting of frozen water stored in the snow layer [mm/T].

  • Refr() Actual (re)freezing of liquid water stored in the snow layer [mm/T].

  • In_() Snow module release/soil module inflow [mm/T].

  • R() Effective soil response [mm/T].

  • SR() Sealed surface runoff [mm/T].

  • EA() Actual soil evaporation [mm/T].

  • QVs1() Percolation from the surface flow reservoir [mm/T].

  • QAb1() Surface flow [mm/T].

  • QVs2() Percolation from the interflow reservoir [mm/T].

  • QAb2() Interflow [mm/T].

  • EL() Actual lake evaporation [mm/T].

  • Q1() Outflow from the lower zone layer [mm/T].

  • InRC() Input of the runoff concentration submodel [mm/T].

  • OutRC() Output of the runoff concentration submodel [mm/T].

  • RT() Total model outflow [mm/T].

  • QT() Total model outflow [m³/s].

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

Bases: InputSequences

Input sequences of model hland_96c.

The following classes are selected:

  • P() Precipitation [mm].

  • T() Temperature [°C].

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

Bases: OutletSequences

Outlet sequences of model hland_96c.

The following classes are selected:

  • Q() Runoff [m³/s].

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

Bases: StateSequences

State sequences of model hland_96c.

The following classes are selected:

  • Ic() Interception storage [mm].

  • SP() Frozen water stored in the snow layer [mm].

  • WC() Liquid water content of the snow layer [mm].

  • SM() Soil moisture [mm].

  • BW1() Water stored in the surface flow reservoir [mm].

  • BW2() Water stored in the interflow reservoir [mm].

  • LZ() Storage in the lower zone layer [mm].