HydPy-Evap (base model)

The HydPy-Evap (base model) model family supplies methods for calculating potential evapotranspiration.

Method Features

class hydpy.models.evap.evap_model.Model[source]

Bases: AdHocModel

HydPy-Evap (base model).

The following “run methods” are called in the given sequence during 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:

  • PETModel_V1 Simple interface for calculating all potential evapotranspiration values in one step.

  • TempModel_V1 Pure getter interface for using main models as sub-submodels.

  • TempModel_V2 Simple interface for determining the temperature in one step.

  • PrecipModel_V1 Pure getter interface for using main models as sub-submodels.

  • PrecipModel_V2 Simple interface for determining precipitation in one step.

DOCNAME: DocName = ('Evap', 'base model')
retmodel

Required submodel that complies with the following interface: PETModel_V1.

retmodel_is_mainmodel
retmodel_typeid
petmodel

Required submodel that complies with the following interface: PETModel_V1.

petmodel_is_mainmodel
petmodel_typeid
tempmodel

Required submodel that complies with one of the following interfaces: TempModel_V1 or TempModel_V2.

tempmodel_is_mainmodel
tempmodel_typeid
precipmodel

Required submodel that complies with one of the following interfaces: PrecipModel_V1 or PrecipModel_V2.

precipmodel_is_mainmodel
precipmodel_typeid
radiationmodel

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

radiationmodel_is_mainmodel
radiationmodel_typeid
intercmodel

Required submodel that complies with the following interface: IntercModel_V1.

intercmodel_is_mainmodel
intercmodel_typeid
soilwatermodel

Required submodel that complies with the following interface: SoilWaterModel_V1.

soilwatermodel_is_mainmodel
soilwatermodel_typeid
snowcovermodel

Required submodel that complies with the following interface: SnowCoverModel_V1.

snowcovermodel_is_mainmodel
snowcovermodel_typeid
snowycanopymodel

Optional submodel that complies with the following interface: SnowyCanopyModel_V1.

snowycanopymodel_is_mainmodel
snowycanopymodel_typeid
snowalbedomodel

Optional submodel that complies with the following interface: SnowAlbedoModel_V1.

snowalbedomodel_is_mainmodel
snowalbedomodel_typeid
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Calc_AirTemperature_TempModel_V1[source]

Bases: Method

Query hydrological response units’ air temperature from a main model referenced as a sub-submodel and follows the TempModel_V1 interface.

Required by the method:

Calc_AirTemperature_V1

Requires the control parameter:

NmbHRU

Calculates the factor sequence:

AirTemperature

Example:

We use the combination of hland_96 and evap_ret_tw2002 as an example:

>>> from hydpy.models.hland_96 import *
>>> parameterstep()
>>> area(10.0)
>>> nmbzones(3)
>>> zonearea(5.0, 3.0, 2.0)
>>> zonetype(FIELD)
>>> zonez(2.0)
>>> fc(100.0)
>>> with model.add_aetmodel_v1("evap_aet_hbv96"):
...     pass
>>> factors.tc = 2.0, 0.0, 5.0
>>> model.aetmodel.calc_airtemperature_v1()
>>> model.aetmodel.sequences.factors.airtemperature
airtemperature(2.0, 0.0, 5.0)
class hydpy.models.evap.evap_model.Calc_AirTemperature_TempModel_V2[source]

Bases: Method

Let a submodel that complies with the TempModel_V2 interface determine the air temperature of the hydrological response units.

Required by the method:

Calc_AirTemperature_V1

Requires the control parameter:

NmbHRU

Calculates the factor sequence:

AirTemperature

Example:

We use the combination of evap_ret_tw2002 and meteo_temp_io as an example:

>>> from hydpy.models.evap_ret_tw2002 import *
>>> parameterstep()
>>> nmbhru(3)
>>> hruarea(0.5, 0.3, 0.2)
>>> with model.add_tempmodel_v2("meteo_temp_io"):
...     temperatureaddend(1.0, 2.0, 4.0)
...     inputs.temperature = 2.0
>>> model.calc_airtemperature_v1()
>>> factors.airtemperature
airtemperature(3.0, 4.0, 6.0)
class hydpy.models.evap.evap_model.Calc_AirTemperature_V1[source]

Bases: Method

Let a submodel that complies with the TempModel_V1 or TempModel_V2 interface determine the air temperature of the individual hydrological response units.

Required by the methods:

Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_WaterEvaporation_V1

Required submethods:

Calc_AirTemperature_TempModel_V1 Calc_AirTemperature_TempModel_V2

Requires the control parameter:

NmbHRU

Calculates the factor sequence:

AirTemperature

class hydpy.models.evap.evap_model.Update_LoggedAirTemperature_V1[source]

Bases: Method

Log the air temperature values of the last 24 hours.

Required by the method:

Determine_InterceptionEvaporation_V2

Requires the control parameter:

NmbHRU

Requires the derived parameter:

NmbLogEntries

Requires the factor sequence:

AirTemperature

Updates the log sequence:

LoggedAirTemperature

Example:

The following example shows that each new method call successively moves the six memorised values to the right and stores the two respective new values on the leftmost position:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> derived.nmblogentries(3)
>>> logs.loggedairtemperature.shape = 3, 2
>>> logs.loggedairtemperature = 0.0, 0.0
>>> from hydpy import UnitTest
>>> test = UnitTest(model,
...                 model.update_loggedairtemperature_v1,
...                 last_example=4,
...                 parseqs=(factors.airtemperature,
...                          logs.loggedairtemperature))
>>> test.nexts.airtemperature = [1.0, 2.0], [3.0, 6.0], [2.0, 4.0], [4.0, 8.0]
>>> del test.inits.loggedairtemperature
>>> test()
| ex. |      airtemperature |                          loggedairtemperature |
-----------------------------------------------------------------------------
|   1 | 1.0             2.0 | 1.0  2.0  0.0  0.0  0.0                   0.0 |
|   2 | 3.0             6.0 | 3.0  6.0  1.0  2.0  0.0                   0.0 |
|   3 | 2.0             4.0 | 2.0  4.0  3.0  6.0  1.0                   2.0 |
|   4 | 4.0             8.0 | 4.0  8.0  2.0  4.0  3.0                   6.0 |
class hydpy.models.evap.evap_model.Calc_DailyAirTemperature_V1[source]

Bases: Method

Calculate the average air temperature of the last 24 hours.

Required by the method:

Determine_InterceptionEvaporation_V2

Requires the control parameter:

NmbHRU

Requires the derived parameter:

NmbLogEntries

Requires the log sequence:

LoggedAirTemperature

Calculates the factor sequence:

DailyAirTemperature

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> derived.nmblogentries(3)
>>> logs.loggedairtemperature.shape = 3, 2
>>> logs.loggedairtemperature = [[1.0, 2.0], [5.0, 6.0], [3.0, 4.0]]
>>> model.calc_dailyairtemperature_v1()
>>> factors.dailyairtemperature
dailyairtemperature(3.0, 4.0)
class hydpy.models.evap.evap_model.Calc_MeanAirTemperature_TempModel_V1[source]

Bases: Method

Query mean air temperature from a main model referenced as a sub-submodel and follows the TempModel_V1 interface.

Example:

We use the combination of hland_96 and evap_pet_hbv96 as an example:

>>> from hydpy.models.hland_96 import *
>>> parameterstep()
>>> area(10.0)
>>> nmbzones(3)
>>> zonearea(5.0, 3.0, 2.0)
>>> zonetype(FIELD)
>>> zonez(2.0)
>>> fc(200.0)
>>> with model.add_aetmodel_v1("evap_aet_hbv96"):
...     with model.add_petmodel_v1("evap_pet_hbv96"):
...         pass
>>> inputs.t = 2.0
>>> model.aetmodel.petmodel.calc_meanairtemperature_v1()
>>> model.aetmodel.petmodel.sequences.factors.meanairtemperature
meanairtemperature(2.0)
class hydpy.models.evap.evap_model.Calc_MeanAirTemperature_TempModel_V2[source]

Bases: Method

Let a submodel that complies with the TempModel_V2 interface determine the mean air temperature.

Example:

We use the combination of evap_pet_hbv96 and meteo_temp_io as an example:

>>> from hydpy.models.evap_pet_hbv96 import *
>>> parameterstep()
>>> nmbhru(3)
>>> hruarea(0.5, 0.3, 0.2)
>>> with model.add_tempmodel_v2("meteo_temp_io"):
...     temperatureaddend(1.0, 2.0, 4.0)
...     inputs.temperature = 2.0
>>> model.calc_meanairtemperature_v1()
>>> factors.meanairtemperature
meanairtemperature(3.9)
class hydpy.models.evap.evap_model.Calc_MeanAirTemperature_V1[source]

Bases: Method

Let a submodel that complies with the TempModel_V1 or TempModel_V2 interface determine the air temperature.

class hydpy.models.evap.evap_model.Calc_WindSpeed2m_V1[source]

Bases: Method

Adjust the measured wind speed to a height of two meters above the ground following Allen et al. (1998).

Requires the control parameter:

MeasuringHeightWindSpeed

Requires the input sequence:

WindSpeed

Calculates the factor sequence:

WindSpeed2m

Basic equation (Allen et al. (1998), equation 47, modified for higher precision):

\[\begin{split}WindSpeed2m = WindSpeed \cdot \frac{ln((2 - d) / z_0)}{ln((MeasuringHeightWindSpeed - d) / z_0)} \\ \\ d = 2 / 3 \cdot 0.12 \\ z_0 = 0.123 \cdot 0.12\end{split}\]

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> measuringheightwindspeed(10.0)
>>> inputs.windspeed = 5.0
>>> model.calc_windspeed2m_v1()
>>> factors.windspeed2m
windspeed2m(3.738763)
class hydpy.models.evap.evap_model.Return_AdjustedWindSpeed_V1[source]

Bases: Method

Adjust and return the measured wind speed to the defined height above the ground using the logarithmic wind profile.

Required by the methods:

Calc_WindSpeed10m_V1 Calc_WindSpeed2m_V2

Requires the control parameter:

MeasuringHeightWindSpeed

Requires the fixed parameter:

RoughnessLengthGrass

Requires the input sequence:

WindSpeed

Basic equation:
\[\begin{split}v_1 = v_0 \cdot \frac{ln(h_1 / z_0)}{ln(h_0 / z_0)} \\ \\ v_1 = wind \ speed \ at \ h_1 \\ h_1 = given \ height \\ z_0 = RoughnessLengthGrass \\ v_0 = WindSpeed \ (at \ h_0) \\ h_0 = MeasuringHeightWindSpeed\end{split}\]

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> measuringheightwindspeed(10.0)
>>> inputs.windspeed = 5.0
>>> from hydpy import round_
>>> round_(model.return_adjustedwindspeed_v1(2.0))
4.007956
>>> round_(model.return_adjustedwindspeed_v1(0.5))
3.153456
class hydpy.models.evap.evap_model.Calc_WindSpeed2m_V2[source]

Bases: Method

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

Required by the method:

Determine_WaterEvaporation_V3

Required submethod:

Return_AdjustedWindSpeed_V1

Requires the control parameter:

MeasuringHeightWindSpeed

Requires the fixed parameter:

RoughnessLengthGrass

Requires the input sequence:

WindSpeed

Calculates the factor sequence:

WindSpeed2m

Method Calc_WindSpeed2m_V2 relies on method Return_AdjustedWindSpeed_V1.

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> measuringheightwindspeed(10.0)
>>> inputs.windspeed = 5.0
>>> model.calc_windspeed2m_v2()
>>> factors.windspeed2m
windspeed2m(4.007956)
class hydpy.models.evap.evap_model.Update_LoggedWindSpeed2m_V1[source]

Bases: Method

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

Required by the method:

Determine_WaterEvaporation_V3

Requires the derived parameter:

NmbLogEntries

Requires the factor sequence:

WindSpeed2m

Updates the log sequence:

LoggedWindSpeed2m

Example:

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

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

Bases: Method

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

Required by the method:

Determine_WaterEvaporation_V3

Requires the derived parameter:

NmbLogEntries

Requires the log sequence:

LoggedWindSpeed2m

Calculates the factor sequence:

DailyWindSpeed2m

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedwindspeed2m.shape = 3
>>> logs.loggedwindspeed2m = 1.0, 5.0, 3.0
>>> model.calc_dailywindspeed2m_v1()
>>> factors.dailywindspeed2m
dailywindspeed2m(3.0)
class hydpy.models.evap.evap_model.Calc_WindSpeed10m_V1[source]

Bases: Method

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

Required by the methods:

Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required submethod:

Return_AdjustedWindSpeed_V1

Requires the control parameter:

MeasuringHeightWindSpeed

Requires the fixed parameter:

RoughnessLengthGrass

Requires the input sequence:

WindSpeed

Calculates the factor sequence:

WindSpeed10m

Method Calc_WindSpeed2m_V2 relies on method Return_AdjustedWindSpeed_V1.

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> measuringheightwindspeed(3.0)
>>> inputs.windspeed = 5.0
>>> model.calc_windspeed10m_v1()
>>> factors.windspeed10m
windspeed10m(5.871465)
class hydpy.models.evap.evap_model.Update_LoggedRelativeHumidity_V1[source]

Bases: Method

Log the relative humidity values of the last 24 hours.

Required by the method:

Determine_InterceptionEvaporation_V2

Requires the derived parameter:

NmbLogEntries

Requires the input sequence:

RelativeHumidity

Updates the log sequence:

LoggedRelativeHumidity

Example:

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

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

Bases: Method

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

Required by the method:

Determine_InterceptionEvaporation_V2

Requires the derived parameter:

NmbLogEntries

Requires the log sequence:

LoggedRelativeHumidity

Calculates the factor sequence:

DailyRelativeHumidity

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedrelativehumidity.shape = 3
>>> logs.loggedrelativehumidity = 1.0, 5.0, 3.0
>>> model.calc_dailyrelativehumidity_v1()
>>> factors.dailyrelativehumidity
dailyrelativehumidity(3.0)
class hydpy.models.evap.evap_model.Calc_SaturationVapourPressure_V1[source]

Bases: Method

Calculate the saturation vapour pressure according to Allen et al. (1998).

Required by the method:

Determine_PotentialInterceptionEvaporation_V1

Requires the control parameter:

NmbHRU

Requires the factor sequence:

AirTemperature

Calculates the factor sequence:

SaturationVapourPressure

Basic equation (Allen et al. (1998), equation 11):

\(SaturationVapourPressure = 6.108 \cdot \exp \left( \frac{17.27 \cdot AirTemperature}{AirTemperature + 237.3} \right)\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> factors.airtemperature = 10.0
>>> model.calc_saturationvapourpressure_v1()
>>> factors.saturationvapourpressure
saturationvapourpressure(12.279626)
class hydpy.models.evap.evap_model.Return_SaturationVapourPressure_V1[source]

Bases: Method

Calculate and return the saturation vapour pressure according to Weischet and Endlicher (1983).

Required by the methods:

Calc_DailySaturationVapourPressure_V1 Calc_SaturationVapourPressure_V2

Basic equation:

\(f(T) = 6.1078 \cdot 2.71828^{\frac{17.08085 \cdot T}{T + 234.175}}\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> from hydpy import round_
>>> round_(model.return_saturationvapourpressure_v1(10.0))
12.293852
class hydpy.models.evap.evap_model.Calc_SaturationVapourPressure_V2[source]

Bases: Method

Calculate the saturation vapour pressure according to Weischet and Endlicher (1983).

Required by the method:

Determine_InterceptionEvaporation_V2

Required submethod:

Return_SaturationVapourPressure_V1

Requires the control parameter:

NmbHRU

Requires the factor sequence:

AirTemperature

Calculates the factor sequence:

SaturationVapourPressure

Basic equation:

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

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> factors.airtemperature = 10.0
>>> model.calc_saturationvapourpressure_v2()
>>> factors.saturationvapourpressure
saturationvapourpressure(12.293852)
class hydpy.models.evap.evap_model.Calc_DailySaturationVapourPressure_V1[source]

Bases: Method

Calculate the average of the saturation vapour pressure of the last 24 hours according to Weischet and Endlicher (1983).

Required by the method:

Determine_InterceptionEvaporation_V2

Required submethod:

Return_SaturationVapourPressure_V1

Requires the control parameter:

NmbHRU

Requires the factor sequence:

DailyAirTemperature

Calculates the factor sequence:

DailySaturationVapourPressure

Basic equation:

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

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> factors.dailyairtemperature = 10.0
>>> model.calc_dailysaturationvapourpressure_v1()
>>> factors.dailysaturationvapourpressure
dailysaturationvapourpressure(12.293852)
class hydpy.models.evap.evap_model.Calc_SaturationVapourPressureSlope_V1[source]

Bases: Method

Calculate the slope of the saturation vapour pressure curve according to Allen et al. (1998).

Required by the method:

Determine_PotentialInterceptionEvaporation_V1

Requires the control parameter:

NmbHRU

Requires the factor sequences:

AirTemperature SaturationVapourPressure

Calculates the factor sequence:

SaturationVapourPressureSlope

Basic equation (Allen et al. (1998), equation 13):

\(SaturationVapourPressureSlope = 4098 \cdot \frac{SaturationVapourPressure}{(AirTemperature + 237.3)^2}\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> factors.airtemperature = 10.0
>>> factors.saturationvapourpressure = 12.279626
>>> model.calc_saturationvapourpressureslope_v1()
>>> factors.saturationvapourpressureslope
saturationvapourpressureslope(0.822828)
class hydpy.models.evap.evap_model.Return_SaturationVapourPressureSlope_V1[source]

Bases: Method

Calculate and return the saturation vapour pressure slope according to Weischet and Endlicher (1983).

Required by the methods:

Calc_DailySaturationVapourPressureSlope_V1 Calc_SaturationVapourPressureSlope_V2

Basic equation (derivative of Return_SaturationVapourPressure_V1:

\(f(T) = \frac{24430.6 \cdot exp((17.08085 \cdot T) / (T + 234.175)}{(T + 234.175)^2}\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> from hydpy import round_
>>> round_(model.return_saturationvapourpressureslope_v1(10.0))
0.824774

>>> dx = 1e-6
>>> round_((model.return_saturationvapourpressure_v1(10.0 + dx) -
...         model.return_saturationvapourpressure_v1(10.0 - dx)) / 2 / dx)
0.824775
class hydpy.models.evap.evap_model.Calc_SaturationVapourPressureSlope_V2[source]

Bases: Method

Calculate the slope of the saturation vapour pressure curve according to Weischet and Endlicher (1983).

Required by the method:

Determine_InterceptionEvaporation_V2

Required submethod:

Return_SaturationVapourPressureSlope_V1

Requires the control parameter:

NmbHRU

Requires the factor sequence:

AirTemperature

Calculates the factor sequence:

SaturationVapourPressureSlope

Basic equation:

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

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(3)
>>> factors.airtemperature = 10.0, 0.0, -10.0
>>> model.calc_saturationvapourpressureslope_v2()
>>> factors.saturationvapourpressureslope
saturationvapourpressureslope(0.824774, 0.445506, 0.226909)
class hydpy.models.evap.evap_model.Calc_DailySaturationVapourPressureSlope_V1[source]

Bases: Method

Average the slope of the saturation vapour pressure curve according to Weischet and Endlicher (1983) of the last 24 hours.

Required by the method:

Determine_InterceptionEvaporation_V2

Required submethod:

Return_SaturationVapourPressureSlope_V1

Requires the control parameter:

NmbHRU

Requires the factor sequence:

DailyAirTemperature

Calculates the factor sequence:

DailySaturationVapourPressureSlope

Basic equation:

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

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(3)
>>> factors.dailyairtemperature = 10.0, 0.0, -10.0
>>> model.calc_dailysaturationvapourpressureslope_v1()
>>> factors.dailysaturationvapourpressureslope
dailysaturationvapourpressureslope(0.824774, 0.445506, 0.226909)
class hydpy.models.evap.evap_model.Calc_ActualVapourPressure_V1[source]

Bases: Method

Calculate the actual vapour pressure according to Allen et al. (1998).

Required by the methods:

Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Requires the control parameter:

NmbHRU

Requires the input sequence:

RelativeHumidity

Requires the factor sequence:

SaturationVapourPressure

Calculates the factor sequence:

ActualVapourPressure

Basic equation (Allen et al. (1998), equation 19, modified):

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

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> inputs.relativehumidity = 60.0
>>> factors.saturationvapourpressure = 30.0
>>> model.calc_actualvapourpressure_v1()
>>> factors.actualvapourpressure
actualvapourpressure(18.0)
class hydpy.models.evap.evap_model.Calc_DailyActualVapourPressure_V1[source]

Bases: Method

Calculate the average of the actual vapour pressure of the last 24 hours.

Required by the method:

Determine_InterceptionEvaporation_V2

Requires the control parameter:

NmbHRU

Requires the factor sequences:

DailyRelativeHumidity DailySaturationVapourPressure

Calculates the factor sequence:

DailyActualVapourPressure

Basic equation:

\(DailyActualVapourPressure = DailySaturationVapourPressure \cdot DailyRelativeHumidity / 100\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> factors.dailyrelativehumidity = 60.0
>>> factors.dailysaturationvapourpressure = 30.0
>>> model.calc_dailyactualvapourpressure_v1()
>>> factors.dailyactualvapourpressure
dailyactualvapourpressure(18.0)
class hydpy.models.evap.evap_model.Calc_DryAirPressure_V1[source]

Bases: Method

Calculate the dry air pressure (DWD, 1987).

Required by the methods:

Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Requires the control parameter:

NmbHRU

Requires the input sequence:

AtmosphericPressure

Requires the factor sequence:

ActualVapourPressure

Calculates the factor sequence:

DryAirPressure

Basic equation:

\(DryAirPressure = AirPressure - ActualVapourPressure\)

Example:
>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(3)
>>> factors.actualvapourpressure = 9.0, 11.0, 25.0
>>> inputs.atmosphericpressure = 1200.0
>>> model.calc_dryairpressure_v1()
>>> factors.dryairpressure
dryairpressure(1191.0, 1189.0, 1175.0)
class hydpy.models.evap.evap_model.Calc_AirDensity_V1[source]

Bases: Method

Calculate the air density (DWD, 1987).

Required by the methods:

Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Requires the control parameter:

NmbHRU

Requires the fixed parameters:

GasConstantDryAir GasConstantWaterVapour

Requires the factor sequences:

ActualVapourPressure DryAirPressure AirTemperature

Calculates the factor sequence:

AirDensity

Basic equation:

\(AirDensity = \frac{100}{AirTemperature + 273.15} \cdot \left( \frac{DryAirPressure}{GasConstantDryAir} + \frac{ActualVapourPressure}{GasConstantWaterVapour} \right)\)

Example:
>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(3)
>>> factors.dryairpressure = 1191.0, 1000.0, 1150.0
>>> factors.actualvapourpressure = 8.0, 7.0, 10.0
>>> factors.airtemperature = 10.0, 12.0, 14.0
>>> model.calc_airdensity_v1()
>>> factors.airdensity
airdensity(1.471419, 1.226998, 1.402691)
class hydpy.models.evap.evap_model.Process_RadiationModel_V1[source]

Bases: Method

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

Required by the methods:

Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Example:

We use the combination of evap_ret_fao56 and meteo_glob_fao56 as an example:

>>> from hydpy import pub
>>> pub.timegrids = "2000-07-06", "2000-07-07", "1d"
>>> from hydpy.models.evap_ret_fao56 import *
>>> parameterstep()
>>> with model.add_radiationmodel_v1("meteo_glob_fao56"):
...     latitude(50.8)
...     angstromconstant(0.25)
...     angstromfactor(0.5)
...     inputs.sunshineduration = 9.25
>>> model.process_radiationmodel_v1()
>>> model.radiationmodel.sequences.fluxes.globalradiation
globalradiation(255.367464)
class hydpy.models.evap.evap_model.Calc_PossibleSunshineDuration_V1[source]

Bases: Method

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

Required by the methods:

Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Calculates the factor sequence:

PossibleSunshineDuration

Examples:

We combine evap_pet_ambav1 with submodels that comply with different interfaces. First, with meteo_glob_fao56, which complies with RadiationModel_V1:

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

Second, with meteo_psun_sun_glob_io, which complies with RadiationModel_V4:

>>> with model.add_radiationmodel_v4("meteo_psun_sun_glob_io", update=False):
...     inputs.possiblesunshineduration = 14.0
>>> model.calc_possiblesunshineduration()
>>> factors.possiblesunshineduration
possiblesunshineduration(14.0)
class hydpy.models.evap.evap_model.Calc_SunshineDuration_V1[source]

Bases: Method

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

Required by the methods:

Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Calculates the factor sequence:

SunshineDuration

Examples:

We combine evap_pet_ambav1 with submodels that comply with different interfaces. First, with meteo_glob_fao56, which complies with RadiationModel_V1:

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

Second, with meteo_psun_sun_glob_io, which complies with RadiationModel_V4:

>>> with model.add_radiationmodel_v4("meteo_psun_sun_glob_io", update=False):
...     inputs.sunshineduration = 14.0
>>> model.calc_sunshineduration()
>>> factors.sunshineduration
sunshineduration(14.0)
class hydpy.models.evap.evap_model.Calc_ClearSkySolarRadiation_V1[source]

Bases: Method

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

Calculates the flux sequence:

ClearSkySolarRadiation

Examples:

We combine evap_ret_fao56 with submodels that comply with different interfaces. First, with meteo_glob_fao56, which complies with RadiationModel_V1:

>>> from hydpy.models.evap_ret_fao56 import *
>>> parameterstep()
>>> with model.add_radiationmodel_v1("meteo_glob_fao56", update=False):
...     fluxes.clearskysolarradiation = 100.0
>>> model.calc_clearskysolarradiation()
>>> fluxes.clearskysolarradiation
clearskysolarradiation(100.0)

Second, with meteo_clear_glob_io, which complies with RadiationModel_V3:

>>> with model.add_radiationmodel_v3("meteo_clear_glob_io", update=False):
...     inputs.clearskysolarradiation = 300.0
>>> model.calc_clearskysolarradiation()
>>> fluxes.clearskysolarradiation
clearskysolarradiation(300.0)
class hydpy.models.evap.evap_model.Calc_GlobalRadiation_V1[source]

Bases: Method

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

Required by the methods:

Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Calculates the flux sequence:

GlobalRadiation

Examples:

We combine three main models with submodels that comply with the four radiation-related interfaces. First, evap_ret_fao56 with meteo_glob_fao56, which complies with RadiationModel_V1:

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

Second, evap_ret_tw2002 with meteo_glob_io, which complies with RadiationModel_V2:

>>> from hydpy.core.importtools import reverse_model_wildcard_import
>>> reverse_model_wildcard_import()
>>> from hydpy.models.evap_ret_tw2002 import *
>>> parameterstep()
>>> with model.add_radiationmodel_v2("meteo_glob_io", update=False):
...     inputs.globalradiation = 200.0
>>> model.calc_globalradiation()
>>> fluxes.globalradiation
globalradiation(200.0)

Third, evap_ret_fao56 with meteo_clear_glob_io, which complies with RadiationModel_V3:

>>> reverse_model_wildcard_import()
>>> from hydpy.models.evap_ret_fao56 import *
>>> parameterstep()
>>> with model.add_radiationmodel_v3("meteo_clear_glob_io", update=False):
...     inputs.globalradiation = 300.0
>>> model.calc_globalradiation()
>>> fluxes.globalradiation
globalradiation(300.0)

Fourth, evap_pet_ambav1 with meteo_psun_sun_glob_io, which complies with RadiationModel_V4:

>>> reverse_model_wildcard_import()
>>> from hydpy.models.evap_pet_ambav1 import *
>>> parameterstep()
>>> with model.add_radiationmodel_v4("meteo_psun_sun_glob_io", update=False):
...     inputs.globalradiation = 400.0
>>> model.calc_globalradiation()
>>> fluxes.globalradiation
globalradiation(400.0)
class hydpy.models.evap.evap_model.Update_LoggedSunshineDuration_V1[source]

Bases: Method

Log the sunshine duration values of the last 24 hours.

Required by the method:

Determine_InterceptionEvaporation_V2

Requires the derived parameter:

NmbLogEntries

Requires the factor sequence:

SunshineDuration

Updates the log sequence:

LoggedSunshineDuration

Example:

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

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

Bases: Method

Calculate the sunshine duration sum of the last 24 hours.

Required by the method:

Determine_InterceptionEvaporation_V2

Requires the derived parameter:

NmbLogEntries

Requires the log sequence:

LoggedSunshineDuration

Calculates the factor sequence:

DailySunshineDuration

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedsunshineduration.shape = 3
>>> logs.loggedsunshineduration = 1.0, 5.0, 3.0
>>> model.calc_dailysunshineduration_v1()
>>> factors.dailysunshineduration
dailysunshineduration(9.0)
class hydpy.models.evap.evap_model.Update_LoggedPossibleSunshineDuration_V1[source]

Bases: Method

Log the astronomically possible sunshine duration values of the last 24 hours.

Required by the method:

Determine_InterceptionEvaporation_V2

Requires the derived parameter:

NmbLogEntries

Requires the factor sequence:

PossibleSunshineDuration

Updates the log sequence:

LoggedPossibleSunshineDuration

Example:

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

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedpossiblesunshineduration.shape = 3
>>> logs.loggedpossiblesunshineduration = 0.0
>>> from hydpy import UnitTest
>>> test = UnitTest(model,
...                 model.update_loggedpossiblesunshineduration_v1,
...                 last_example=4,
...                 parseqs=(factors.possiblesunshineduration,
...                          logs.loggedpossiblesunshineduration))
>>> test.nexts.possiblesunshineduration = 1.0, 3.0, 2.0, 4.0
>>> del test.inits.loggedpossiblesunshineduration
>>> test()
| ex. | possiblesunshineduration |           loggedpossiblesunshineduration |
-----------------------------------------------------------------------------
|   1 |                      1.0 | 1.0  0.0                             0.0 |
|   2 |                      3.0 | 3.0  1.0                             0.0 |
|   3 |                      2.0 | 2.0  3.0                             1.0 |
|   4 |                      4.0 | 4.0  2.0                             3.0 |
class hydpy.models.evap.evap_model.Calc_DailyPossibleSunshineDuration_V1[source]

Bases: Method

Calculate the sunshine duration sum of the last 24 hours.

Required by the method:

Determine_InterceptionEvaporation_V2

Requires the derived parameter:

NmbLogEntries

Requires the log sequence:

LoggedPossibleSunshineDuration

Calculates the factor sequence:

DailyPossibleSunshineDuration

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedpossiblesunshineduration.shape = 3
>>> logs.loggedpossiblesunshineduration = 1.0, 5.0, 3.0
>>> model.calc_dailypossiblesunshineduration_v1()
>>> factors.dailypossiblesunshineduration
dailypossiblesunshineduration(9.0)
class hydpy.models.evap.evap_model.Update_LoggedClearSkySolarRadiation_V1[source]

Bases: Method

Log the clear sky solar radiation values of the last 24 hours.

Requires the derived parameter:

NmbLogEntries

Requires the flux sequence:

ClearSkySolarRadiation

Updates the log sequence:

LoggedClearSkySolarRadiation

Example:

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

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedclearskysolarradiation.shape = 3
>>> logs.loggedclearskysolarradiation = 0.0
>>> from hydpy import UnitTest
>>> test = UnitTest(model,
...                 model.update_loggedclearskysolarradiation_v1,
...                 last_example=4,
...                 parseqs=(fluxes.clearskysolarradiation,
...                          logs.loggedclearskysolarradiation))
>>> test.nexts.clearskysolarradiation = 1.0, 3.0, 2.0, 4.0
>>> del test.inits.loggedclearskysolarradiation
>>> test()
| ex. | clearskysolarradiation |           loggedclearskysolarradiation |
-------------------------------------------------------------------------
|   1 |                    1.0 | 1.0  0.0                           0.0 |
|   2 |                    3.0 | 3.0  1.0                           0.0 |
|   3 |                    2.0 | 2.0  3.0                           1.0 |
|   4 |                    4.0 | 4.0  2.0                           3.0 |
class hydpy.models.evap.evap_model.Update_LoggedGlobalRadiation_V1[source]

Bases: Method

Log the global radiation values of the last 24 hours.

Required by the method:

Determine_WaterEvaporation_V3

Requires the derived parameter:

NmbLogEntries

Requires the flux sequence:

GlobalRadiation

Updates the log sequence:

LoggedGlobalRadiation

Example:

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

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

Bases: Method

Average the global radiation of the last 24 hours.

Required by the method:

Determine_WaterEvaporation_V3

Requires the derived parameter:

NmbLogEntries

Requires the log sequence:

LoggedGlobalRadiation

Calculates the flux sequence:

DailyGlobalRadiation

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> derived.nmblogentries(3)
>>> logs.loggedglobalradiation.shape = 3
>>> logs.loggedglobalradiation = 100.0, 800.0, 600.0
>>> model.calc_dailyglobalradiation_v1()
>>> fluxes.dailyglobalradiation
dailyglobalradiation(500.0)
class hydpy.models.evap.evap_model.Calc_CurrentAlbedo_SnowAlbedoModel_V1[source]

Bases: Method

Query the current Earth surface albedo from a main model referenced as a sub-submodel and follows the SnowAlbedoModel_V1 interface.

Required by the method:

Calc_CurrentAlbedo_V1

Requires the control parameter:

NmbHRU

Calculates the factor sequence:

CurrentAlbedo

class hydpy.models.evap.evap_model.Calc_CurrentAlbedo_V1[source]

Bases: Method

Take the land type- and month-specific albedo from parameter Albedo or a submodel that complies with the SnowAlbedoModel_V1 interface.

Required by the method:

Determine_InterceptionEvaporation_V2

Required submethod:

Calc_CurrentAlbedo_SnowAlbedoModel_V1

Requires the control parameters:

NmbHRU HRUType Albedo

Requires the derived parameter:

MOY

Calculates the factor sequence:

CurrentAlbedo

Examples:

We use the combination of lland_knauf and evap_aet_morsim as an example and set different albedo values for the land types ACKER and VERS for January and February:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-30", "2000-02-03", "1d"
>>> from hydpy.models.lland_knauf import *
>>> parameterstep()
>>> ft(10.0)
>>> nhru(3)
>>> fhru(5.0, 3.0, 2.0)
>>> lnk(ACKER, VERS, VERS)
>>> measuringheightwindspeed(10.0)
>>> lai(3.0)
>>> wmax(100.0)
>>> with model.add_aetmodel_v1("evap_aet_morsim"):
...     albedo.acker_jan = 0.2
...     albedo.vers_jan = 0.3
...     albedo.acker_feb = 0.4
...     albedo.vers_feb = 0.5

SnowAlbedoModel_V1 submodels return nan values for snow-free conditions. In such cases (see the first and second hydrological response unit), Calc_CurrentAlbedo_V1 takes the relevant value from parameter Albedo. If there is a snow cover (see the third response unit), the SnowAlbedoModel_V1 submodel provides an albedo value and Calc_CurrentAlbedo_V1 takes it without modification:

>>> model.aetmodel.idx_sim = 1
>>> fluxes.actualalbedo = nan, nan, 1.0
>>> model.aetmodel.calc_currentalbedo_v1()
>>> model.aetmodel.sequences.factors.currentalbedo
currentalbedo(0.2, 0.3, 1.0)

Calc_CurrentAlbedo_V1 always falls back on using the land type- and month-specific values of parameter Albedo if no SnowAlbedoModel_V1 submodel is available:

>>> del model.aetmodel.snowalbedomodel
>>> model.aetmodel.idx_sim = 2
>>> model.aetmodel.calc_currentalbedo_v1()
>>> model.aetmodel.sequences.factors.currentalbedo
currentalbedo(0.4, 0.5, 0.5)
class hydpy.models.evap.evap_model.Calc_CurrentAlbedo_V2[source]

Bases: Method

Calculate the earth’s surface albedo based on the current leaf area index and snow conditions following Löpmeier (2014).

Required by the method:

Determine_PotentialInterceptionEvaporation_V1

Requires the control parameters:

NmbHRU HRUType Soil Plant GroundAlbedo GroundAlbedoSnow LeafAlbedo LeafAlbedoSnow LeafAreaIndex WetnessThreshold

Requires the derived parameter:

MOY

Requires the factor sequence:

SnowCover

Requires the flux sequences:

DailyPrecipitation DailyPotentialSoilEvapotranspiration

Calculates the factor sequence:

CurrentAlbedo

Basic equations:
\[\begin{split}CurrentAlbedo = \alpha_g + (\alpha_l - \alpha_g) \cdot min(lai/4, \ 1) \\ \\ \alpha_g = \omega \cdot GroundAlbedoSnow + (1 - \omega) \cdot \alpha_g^* \\ \alpha_g^* = GroundAlbedo \cdot \begin{cases} 1 &|\ \overline{Soil} \ \lor \ p / e < \tau \\ 0.5 &|\ Soil \ \land \ p / e \geq \tau \end{cases} \\ \tau = WetnessThreshold \\ p = DailyPrecipitation \\ e = DailyPotentialSoilEvapotranspiration \\ \alpha_l = \omega \cdot LeafAlbedoSnow + (1 - \omega) \cdot LeafAlbedo \\ \omega = SnowCover \\ lai = LeafAreaIndex\end{split}\]

Examples:

We use lland_knauf and evap_aet_minhas as main models to prepare an applicable evap instance (more precisely, an evap_pet_ambav1 instance):

>>> from hydpy.models.lland_knauf import *
>>> parameterstep()
>>> nhru(5)
>>> lnk(WASSER, BODEN, ACKER, BAUMB, LAUBW)
>>> ft(10.0)
>>> fhru(0.2)
>>> wmax(200.0)
>>> measuringheightwindspeed(10.0)
>>> lai.acker = 2.0
>>> lai.baumb = 3.0
>>> lai.may_laubw = 4.0
>>> lai.jun_laubw = 5.0
>>> from hydpy import pub
>>> pub.timegrids = "2000-05-30", "2000-06-03", "1d"
>>> with model.add_aetmodel_v1("evap_aet_minhas"):
...     with model.add_petmodel_v2("evap_pet_ambav1") as ambav:
...         groundalbedo(wasser=0.1, boden=0.2, acker=0.2, baumb=0.2, laubw=0.2)
...         groundalbedosnow(0.8)
...         leafalbedo(acker=0.3, baumb=0.3, laubw=0.3)
...         leafalbedosnow(0.6)
...         wetnessthreshold(0.5)
...         factors.snowcover = 0.0
...         fluxes.dailyprecipitation = 1.0
...         fluxes.dailypotentialsoilevapotranspiration = 4.0
>>> factors = ambav.sequences.factors
>>> fluxes = ambav.sequences.fluxes

The first example focuses on the general weighting of the ground’s and the leaves’ albedo based on the current leaf area index. For vegetation-free hydrological response units, Calc_CurrentAlbedo_V2 only considers the ground’s albedo:

>>> ambav.idx_sim = pub.timegrids.init["2000-05-31"]
>>> ambav.calc_currentalbedo_v2()
>>> factors.currentalbedo
currentalbedo(0.1, 0.2, 0.25, 0.275, 0.3)

For a leaf area index of four, Calc_CurrentAlbedo_V2 only considers the leaves’ albedo. Hence, setting higher indexes than four does not change the results:

>>> ambav.idx_sim = pub.timegrids.init["2000-06-01"]
>>> ambav.calc_currentalbedo_v2()
>>> factors.currentalbedo
currentalbedo(0.1, 0.2, 0.25, 0.275, 0.3)

For wet conditions, where the ratio of precipitation and potential soil evapotranspiration exceeds the defined wetness threshold, Calc_CurrentAlbedo_V2 halves the ground’s albedo of all response units with non-sealed soils:

>>> fluxes.dailyprecipitation = 2.0
>>> ambav.calc_currentalbedo_v2()
>>> factors.currentalbedo
currentalbedo(0.1, 0.1, 0.2, 0.25, 0.3)

For complete snow covers, Calc_CurrentAlbedo_V2 relies on GroundAlbedoSnow and LeafAlbedoSnow instead of GroundAlbedo and LeafAlbedo:

>>> fluxes.dailyprecipitation = 1.0
>>> factors.snowcover = 1.0
>>> ambav.calc_currentalbedo_v2()
>>> factors.currentalbedo
currentalbedo(0.8, 0.8, 0.7, 0.65, 0.6)

For incomplete snow covers, Calc_CurrentAlbedo_V2 weights the respective parameter pairs accordingly:

>>> factors.snowcover = 0.5
>>> ambav.calc_currentalbedo_v2()
>>> factors.currentalbedo
currentalbedo(0.45, 0.5, 0.475, 0.4625, 0.45)
class hydpy.models.evap.evap_model.Calc_NetShortwaveRadiation_V1[source]

Bases: Method

Calculate the net shortwave radiation for the hypothetical grass reference crop according to Allen et al. (1998).

Requires the control parameter:

NmbHRU

Requires the flux sequence:

GlobalRadiation

Calculates the flux sequence:

NetShortwaveRadiation

Basic equation (Allen et al. (1998), equation 38):

\(NetShortwaveRadiation = (1.0 - 0.23) \cdot GlobalRadiation\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> fluxes.globalradiation = 200.0
>>> model.calc_netshortwaveradiation_v1()
>>> fluxes.netshortwaveradiation
netshortwaveradiation(154.0)
class hydpy.models.evap.evap_model.Calc_NetShortwaveRadiation_V2[source]

Bases: Method

Calculate the net shortwave radiation for a time-variable albedo.

Required by the methods:

Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Requires the control parameter:

NmbHRU

Requires the factor sequence:

CurrentAlbedo

Requires the flux sequence:

GlobalRadiation

Calculates the flux sequence:

NetShortwaveRadiation

Basic equation:

\(NetShortwaveRadiation = (1.0 - CurrentAlbedo) \cdot GlobalRadiation\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> fluxes.globalradiation = 100.0
>>> factors.currentalbedo = 0.25
>>> model.calc_netshortwaveradiation_v2()
>>> fluxes.netshortwaveradiation
netshortwaveradiation(75.0)
class hydpy.models.evap.evap_model.Calc_DailyNetShortwaveRadiation_V1[source]

Bases: Method

Calculate the net shortwave radiation average for the last 24 hours.

Required by the method:

Determine_WaterEvaporation_V3

Requires the control parameter:

NmbHRU

Requires the factor sequence:

CurrentAlbedo

Requires the flux sequence:

DailyGlobalRadiation

Calculates the flux sequence:

DailyNetShortwaveRadiation

Basic equation:

\(DailyNetShortwaveRadiation = (1-CurrentAlbedo) \cdot DailyGlobalRadiation\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> factors.currentalbedo(0.25)
>>> fluxes.dailyglobalradiation = 100.0
>>> model.calc_dailynetshortwaveradiation_v1()
>>> fluxes.dailynetshortwaveradiation
dailynetshortwaveradiation(75.0)
class hydpy.models.evap.evap_model.Update_CloudCoverage_V1[source]

Bases: Method

Update the degree of cloud coverage.

Required by the method:

Determine_PotentialInterceptionEvaporation_V1

Requires the derived parameters:

Hours Days

Requires the factor sequences:

SunshineDuration PossibleSunshineDuration

Updates the state sequence:

CloudCoverage

Basic equation:
\[\begin{split}c_{new} = \begin{cases} s / s_0 &|\ s_0 = h \\ c_{old} &|\ s_0 < h \\ \end{cases} \\ \\ c = CloudCoverage \\ s = SunshineDuration \\ s_0 = PossibleSunshineDuration \\ h = Hours\end{split}\]

Examples:

For a daily simulation step size, Update_CloudCoverage_V1 always uses the ratio of the actual and the astronomically possible sunshine duration to estimate the cloud coverage degree:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> derived.days(1.0)
>>> factors.sunshineduration = 8.0
>>> factors.possiblesunshineduration = 10.0
>>> model.update_cloudcoverage_v1()
>>> states.cloudcoverage
cloudcoverage(0.8)

The finally calculated cloud coverage degree never exceeds one:

>>> factors.sunshineduration = 11.0
>>> model.update_cloudcoverage_v1()
>>> states.cloudcoverage
cloudcoverage(1.0)

Now, we switch to an hourly simulation step size:

>>> derived.days(1.0 / 24.0)
>>> derived.hours(1.0)

During the daytime, Update_CloudCoverage_V1 always updates the cloud coverage degree as described above:

>>> factors.sunshineduration = 0.4
>>> factors.possiblesunshineduration = 1.0
>>> model.update_cloudcoverage_v1()
>>> states.cloudcoverage
cloudcoverage(0.4)

From dusk until dawn, when the astronomically possible sunshine duration is shorter than the simulation step size, Update_CloudCoverage_V1 leaves the previously calculated value untouched:

>>> factors.possiblesunshineduration = 0.8
>>> model.update_cloudcoverage_v1()
>>> states.cloudcoverage
cloudcoverage(0.4)
class hydpy.models.evap.evap_model.Calc_AdjustedCloudCoverage_V1[source]

Bases: Method

Calculate the adjusted cloud coverage degree.

Required by the method:

Determine_PotentialInterceptionEvaporation_V1

Requires the control parameter:

NightCloudFactor

Requires the derived parameter:

Hours

Requires the factor sequence:

PossibleSunshineDuration

Requires the state sequence:

CloudCoverage

Calculates the factor sequence:

AdjustedCloudCoverage

Basic equation:
\[\begin{split}AdjustedCloudCoverage = \omega \cdot c + (1 - \omega) \cdot n \cdot c \\ \\ \omega = PossibleSunshineDuration / Hours \\ c = CloudCoverage\\ n = NightCloudFactor\end{split}\]

Examples:

The above equation generally holds for night cloud factors not exceeding one:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nightcloudfactor(0.5)
>>> derived.hours(24.0)
>>> factors.possiblesunshineduration = 18.0
>>> states.cloudcoverage = 0.8
>>> model.calc_adjustedcloudcoverage_v1()
>>> factors.adjustedcloudcoverage
adjustedcloudcoverage(0.7)

For night cloud factors above one, Calc_AdjustedCloudCoverage_V1 ensures the estimated nighttime cloud cover degree never exceeds one:

>>> nightcloudfactor(2.0)
>>> model.calc_adjustedcloudcoverage_v1()
>>> factors.adjustedcloudcoverage
adjustedcloudcoverage(0.85)
class hydpy.models.evap.evap_model.Calc_NetLongwaveRadiation_V1[source]

Bases: Method

Calculate the net longwave radiation according to Allen et al. (1998).

Requires the control parameter:

NmbHRU

Requires the derived parameter:

NmbLogEntries

Requires the factor sequences:

AirTemperature ActualVapourPressure

Requires the flux sequences:

ClearSkySolarRadiation GlobalRadiation

Requires the log sequences:

LoggedGlobalRadiation LoggedClearSkySolarRadiation

Calculates the flux sequence:

NetLongwaveRadiation

Basic equations (Allen et al. (1998), equation 39, modified):

\(NetLongwaveRadiation = \sigma \cdot (AirTemperature + 273.16)^4 \cdot \left( 0.34 - 0.14 \sqrt{ActualVapourPressure / 10} \right) \cdot (1.35 \cdot GR / CSSR - 0.35)\)

\[\begin{split}GR = \begin{cases} GlobalRadiation &|\ ClearSkySolarRadiation > 0 \\ \sum{LoggedGlobalRadiation} &|\ ClearSkySolarRadiation = 0 \end{cases}\end{split}\]
\[\begin{split}CSSR = \begin{cases} ClearSkySolarRadiation &|\ ClearSkySolarRadiation > 0 \\ \sum{LoggedClearSkySolarRadiation} &|\ ClearSkySolarRadiation = 0 \end{cases}\end{split}\]

\(\sigma = 5.6747685185185184 \cdot 10^{-8}\)

Note that when clear sky radiation is zero at night, we use the global radiation and clear sky radiation sums of the last 24 hours. Averaging over three hours before sunset, as Allen et al. (1998) suggests, could be more precise but is a more complicated and error-prone approach.

Example:

The following calculation agrees with example 11 of Allen et al. (1998):

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> derived.nmblogentries(1)
>>> fluxes.globalradiation = 167.824074
>>> fluxes.clearskysolarradiation = 217.592593
>>> factors.airtemperature = 22.1
>>> factors.actualvapourpressure = 21.0
>>> model.calc_netlongwaveradiation_v1()
>>> fluxes.netlongwaveradiation
netlongwaveradiation(40.87786)

>>> fluxes.clearskysolarradiation = 0.0
>>> logs.loggedclearskysolarradiation.shape = 1
>>> logs.loggedclearskysolarradiation = 138.888889
>>> logs.loggedglobalradiation.shape = 1
>>> logs.loggedglobalradiation = 115.740741
>>> model.calc_netlongwaveradiation_v1()
>>> fluxes.netlongwaveradiation
netlongwaveradiation(45.832275)

When necessary, Calc_NetLongwaveRadiation_V1 trims the fraction of global radiation and clear sky solar radiation to one to prevent calculating unrealistically high net longwave radiations:

>>> logs.loggedclearskysolarradiation = 1.0
>>> model.calc_netlongwaveradiation_v1()
>>> fluxes.netlongwaveradiation
netlongwaveradiation(59.13842)
class hydpy.models.evap.evap_model.Calc_NetLongwaveRadiation_V2[source]

Bases: Method

Calculate the net longwave radiation according to Löpmeier (2014), based on Holtslag et al. (1981), Idso and Jackson (1969), and Sellers (1960).

Required by the method:

Determine_PotentialInterceptionEvaporation_V1

Requires the control parameters:

NmbHRU CloudTypeFactor

Requires the fixed parameter:

StefanBoltzmannConstant

Requires the factor sequences:

CurrentAlbedo AdjustedCloudCoverage AirTemperature

Requires the flux sequence:

GlobalRadiation

Calculates the flux sequence:

NetLongwaveRadiation

Basic equations:
\[\begin{split}NetLongwaveRadiation = RL_s - RL_a \\ \\ RL_{s} = 0.97 \cdot \sigma \cdot (T + 273.1)^4 + 0.07 \cdot (1 - \alpha) \cdot G \\ \\ RL_{a} = \left( 1 + C \cdot N^2 \right) \cdot \left( 1 - 0.261 \cdot e^{-0.000777 \cdot T^2} \right) \cdot \sigma \cdot (T + 273.1)^4 \\ \\ \sigma = StefanBoltzmannConstant \\ T = AirTemperature \\ \alpha = CurrentAlbedo \\ G = GlobalRadiation \\ C = CloudTypeFactor \\ N = AdjustedCloudCoverage\end{split}\]

Example:

The following example is roughly comparable to the first example of Calc_NetLongwaveRadiation_V1 taken from Allen et al. (1998) but results in a more than thrice as large net longwave radiation estimate:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> cloudtypefactor(0.2)
>>> derived.nmblogentries(1)
>>> fluxes.globalradiation = 167.824074
>>> factors.adjustedcloudcoverage = 167.824074 / 217.592593
>>> factors.airtemperature = 22.1
>>> factors.currentalbedo = 0.23
>>> model.calc_netlongwaveradiation_v2()
>>> fluxes.netlongwaveradiation
netlongwaveradiation(30.940701)
class hydpy.models.evap.evap_model.Calc_DailyNetLongwaveRadiation_V1[source]

Bases: Method

Calculate the average net longwave radiation of the last 24 hours according to LEG (2020).

Required by the method:

Determine_InterceptionEvaporation_V2

Requires the control parameters:

NmbHRU Emissivity

Requires the fixed parameters:

StefanBoltzmannConstant FactorCounterRadiation

Requires the factor sequences:

DailyAirTemperature DailyActualVapourPressure DailySunshineDuration DailyPossibleSunshineDuration

Calculates the flux sequence:

DailyNetLongwaveRadiation

Basic equation:
\[\begin{split}DailyNetLongwaveRadiation = \sigma\cdot T^4 \cdot \left( \epsilon - c \cdot \left(\frac{P} {T}\right)^{1/7} \right) \cdot \left (0.2 + 0.8 \cdot\frac{S}{S_p} \right)\\ \\ \sigma = StefanBoltzmannConstant \\ T = DailyAirTemperature + 273.15 \\ \epsilon = Emissivity \\ c = FactorCounterRadiation \\ P = DailyActualVapourPressure \\ S = DailySunshineDuration\\ S_p = DailyPossibleSunshineDuration\end{split}\]

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> emissivity(0.95)
>>> factors.dailyairtemperature = 22.1, 0.0
>>> factors.dailyactualvapourpressure = 16.0, 6.0
>>> factors.dailysunshineduration = 12.0
>>> factors.dailypossiblesunshineduration = 14.0
>>> model.calc_dailynetlongwaveradiation_v1()
>>> fluxes.dailynetlongwaveradiation
dailynetlongwaveradiation(40.451915, 58.190798)

When necessary, Calc_DailyNetLongwaveRadiation_V1 trims the fraction of actual and possible sunshine duration to one to prevent calculating unrealistically high net longwave radiations:

>>> factors.dailysunshineduration = 24.0
>>> model.calc_dailynetlongwaveradiation_v1()
>>> fluxes.dailynetlongwaveradiation
dailynetlongwaveradiation(45.671517, 65.699288)
class hydpy.models.evap.evap_model.Calc_NetRadiation_V1[source]

Bases: Method

Calculate the total net radiation according to Allen et al. (1998) and according to Löpmeier (2014).

Required by the method:

Determine_PotentialInterceptionEvaporation_V1

Requires the control parameter:

NmbHRU

Requires the flux sequences:

NetShortwaveRadiation NetLongwaveRadiation

Calculates the flux sequence:

NetRadiation

Basic equation:

\(NetRadiation = NetShortwaveRadiation - NetLongwaveRadiation\)

Example:

The following calculation agrees with example 12 of Allen et al. (1998):

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> fluxes.netshortwaveradiation  = 111.0
>>> fluxes.netlongwaveradiation  = 35.0
>>> model.calc_netradiation_v1()
>>> fluxes.netradiation
netradiation(76.0)
class hydpy.models.evap.evap_model.Calc_NetRadiation_V2[source]

Bases: Method

Calculate the total net radiation according to LEG (2020).

Required by the method:

Determine_InterceptionEvaporation_V2

Requires the control parameter:

NmbHRU

Requires the flux sequences:

NetShortwaveRadiation DailyNetLongwaveRadiation

Calculates the flux sequence:

NetRadiation

Basic equation:

\(NetRadiation = NetShortwaveRadiation - DailyNetLongwaveRadiation\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> fluxes.netshortwaveradiation = 300.0
>>> fluxes.dailynetlongwaveradiation = 200.0
>>> model.calc_netradiation_v2()
>>> fluxes.netradiation
netradiation(100.0)
class hydpy.models.evap.evap_model.Calc_DailyNetRadiation_V1[source]

Bases: Method

Calculate the average of the net radiation of the last 24 hours.

Required by the method:

Determine_WaterEvaporation_V3

Requires the control parameter:

NmbHRU

Requires the flux sequences:

DailyNetLongwaveRadiation DailyNetShortwaveRadiation

Calculates the flux sequence:

DailyNetRadiation

Basic equation:

\(DailyNetRadiation = DailyNetShortwaveRadiation - DailyNetLongwaveRadiation\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> fluxes.dailynetshortwaveradiation = 300.0
>>> fluxes.dailynetlongwaveradiation = 200.0
>>> model.calc_dailynetradiation_v1()
>>> fluxes.dailynetradiation
dailynetradiation(100.0)
class hydpy.models.evap.evap_model.Calc_SoilHeatFlux_V1[source]

Bases: Method

Calculate the soil heat flux according to Allen et al. (1998).

Requires the control parameter:

NmbHRU

Requires the derived parameter:

Days

Requires the flux sequence:

NetRadiation

Calculates the flux sequence:

SoilHeatFlux

Basic equation for daily timesteps (Allen et al. (1998), equation 42):

\(SoilHeatFlux = 0\)

Basic equation for (sub)hourly timesteps (Allen et al. (1998), eq. 45 and 46 ):

\(SoilHeatFlux = \Bigl \lbrace { {0.1 \cdot SoilHeatFlux \ | \ NetRadiation \geq 0} \atop {0.5 \cdot SoilHeatFlux \ | \ NetRadiation < 0} }\)

Examples:

For simulation time steps shorter than one day, we define all steps with positive NetRadiation as part of the daylight period and all with negative NetRadiation as part of the nighttime period. The total SoilHeatFlux is zero if the summed NetRadiation during daytime is five times as high as the absolute summed NetRadiation during nighttime:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> derived.days(1/24)
>>> fluxes.netradiation = 100.0
>>> model.calc_soilheatflux_v1()
>>> fluxes.soilheatflux
soilheatflux(10.0)
>>> fluxes.netradiation = -20.0
>>> model.calc_soilheatflux_v1()
>>> fluxes.soilheatflux
soilheatflux(-10.0)

For any simulation step size of at least one day, method Calc_SoilHeatFlux_V1 sets the SoilHeatFlux to zero, which Allen et al. (1998) suggests for daily simulation steps only:

>>> derived.days(1)
>>> fluxes.netradiation = 100.0
>>> model.calc_soilheatflux_v1()
>>> fluxes.soilheatflux
soilheatflux(0.0)
>>> fluxes.netradiation = -20.0
>>> model.calc_soilheatflux_v1()
>>> fluxes.soilheatflux
soilheatflux(0.0)

Hence, be aware that function Calc_SoilHeatFlux_V1 does not give the best results for intermediate (e.g. 12 hours) or larger step sizes (e.g. one month).

class hydpy.models.evap.evap_model.Calc_SoilHeatFlux_V2[source]

Bases: Method

Calculate the MORECS-like soil heat flux roughly based on LEG (2020) and Thompson et al. (1981).

Requires the control parameters:

NmbHRU Water LeafAreaIndex AverageSoilHeatFlux

Requires the derived parameters:

MOY Hours

Requires the factor sequences:

PossibleSunshineDuration DailyPossibleSunshineDuration

Requires the flux sequence:

DailyNetRadiation

Calculates the flux sequence:

SoilHeatFlux

Basic equations:

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

\(G_N = AverageSoilHeatFlux - SoilHeatFlux_D\)

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

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

Note

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

Warning

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

Examples:

Base model evap does not define any land cover types by itself but takes the ones of the respective main model. Here, we manually introduce the land cover types wood, trees, soil, acre, and water to apply evap as a stand-alone model:

>>> from hydpy import pub
>>> pub.timegrids = "2019-05-30", "2019-06-03", "1d"
>>> from hydpy.core.parametertools import Constants
>>> WOOD, TREES, BUSH, SOIL, WATER = 1, 2, 3, 4, 5
>>> constants = Constants(
...     WOOD=WOOD, TREES=TREES, BUSH=BUSH, SOIL=SOIL, WATER=WATER)
>>> from hydpy.models.evap.evap_control import HRUType, LeafAreaIndex
>>> with HRUType.modify_constants(constants), \
...         LeafAreaIndex.modify_rows(constants):
...     from hydpy.models.evap import *
...     parameterstep()
>>> nmbhru(4)

We perform the first test calculation for a daily simulation step size to start as simple as possible:

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

We define six hydrological response units, of which only the first five need further parameterisation, as method Calc_SoilHeatFlux_V2 generally sets SoilHeatFlux to zero for water areas:

>>> nmbhru(6)
>>> hrutype(SOIL, BUSH, BUSH, TREES, WOOD, WATER)
>>> water(False, False, False, False, False, True)

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

>>> leafareaindex.soil = 0.0
>>> leafareaindex.bush = 5.0
>>> leafareaindex.trees = 10.0
>>> leafareaindex.wood = 15.0

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

>>> averagesoilheatflux.may = -10.0
>>> averagesoilheatflux.jun = 20.0

The following derived parameters need to be updated:

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

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

>>> factors.possiblesunshineduration = 14.0
>>> factors.dailypossiblesunshineduration = 14.0

We set DailyNetRadiation to 100 W/m² for most response units, except for the second bush unit:

>>> fluxes.dailynetradiation = 100.0, 100.0, -100.0, 100.0, 100.0, 100.0

For the given daily simulation step size, method Calc_SoilHeatFlux_V2 calculates soil surface fluxes identical to the AverageSoilHeatFlux value of the respective month:

>>> model.idx_sim = pub.timegrids.init["2000-05-31"]
>>> model.calc_soilheatflux_v2()
>>> fluxes.soilheatflux
soilheatflux(-10.0, -10.0, -10.0, -10.0, -10.0, 0.0)
>>> model.idx_sim = pub.timegrids.init["2000-06-01"]
>>> model.calc_soilheatflux_v2()
>>> fluxes.soilheatflux
soilheatflux(20.0, 20.0, 20.0, 20.0, 20.0, 0.0)

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

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

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

>>> factors.possiblesunshineduration = 1.0
>>> model.calc_soilheatflux_v2()
>>> fluxes.soilheatflux
soilheatflux(-2.142857, -1.071429, 1.071429, 0.0, 1.071429, 0.0)
>>> day = fluxes.soilheatflux.values.copy()

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

>>> factors.possiblesunshineduration = 0.0
>>> model.calc_soilheatflux_v2()
>>> fluxes.soilheatflux
soilheatflux(2.0, 0.5, -2.5, -1.0, -2.5, 0.0)
>>> night = fluxes.soilheatflux.values.copy()

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

>>> from hydpy import print_vector
>>> print_vector(day * factors.dailypossiblesunshineduration +
...              night * (24.0 - factors.dailypossiblesunshineduration))
-10.0, -10.0, -10.0, -10.0, -10.0, 0.0
class hydpy.models.evap.evap_model.Calc_SoilHeatFlux_V3[source]

Bases: Method

Take the monthly average soil heat flux as the current soil heat flux.

Required by the method:

Determine_InterceptionEvaporation_V2

Requires the control parameters:

NmbHRU Water AverageSoilHeatFlux

Requires the derived parameter:

MOY

Calculates the flux sequence:

SoilHeatFlux

Basic equations:

\(SoilHeatFlux = AverageSoilHeatFlux\)

Note

Method Calc_SoilHeatFlux_V3 is a workaround. We might remove it as soon as the shortcomings of method Calc_SoilHeatFlux_V2 are fixed.

Examples:

>>> from hydpy import pub
>>> pub.timegrids = "2000-05-30 00:00", "2000-06-02 00:00", "1h"
>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> water(False, True)
>>> averagesoilheatflux.may = 12.0
>>> averagesoilheatflux.jun = -24.0
>>> derived.moy.update()
>>> derived.days.update()
>>> model.idx_sim = pub.timegrids.init["2000-05-31 23:00"]
>>> model.calc_soilheatflux_v3()
>>> fluxes.soilheatflux
soilheatflux(12.0, 0.0)
>>> model.idx_sim = pub.timegrids.init["2000-06-01 00:00"]
>>> model.calc_soilheatflux_v3()
>>> fluxes.soilheatflux
soilheatflux(-24.0, 0.0)
class hydpy.models.evap.evap_model.Calc_SoilHeatFlux_V4[source]

Bases: Method

Calculate the AMBAV-like soil heat flux based on Löpmeier (2014).

Required by the method:

Determine_PotentialInterceptionEvaporation_V1

Requires the control parameters:

NmbHRU HRUType Water LeafAreaIndex

Requires the derived parameters:

Hours MOY

Requires the factor sequence:

PossibleSunshineDuration

Requires the flux sequence:

NetRadiation

Calculates the flux sequence:

SoilHeatFlux

Basic equations:
\[\begin{split}G = max(a - b \cdot LAI, \ 0) \cdot R_n \\ a = \omega \cdot 0.2 + (1 - \omega) \cdot 0.5 \\ b = a \cdot 0.03 / 0.2 \\ \\ G = SoilHeatFlux \\ LAI = LeafAreaIndex \\ R_n = NetRadiation \\ \omega = PossibleSunshineDuration / Hours\end{split}\]

Examples:

Base model evap does not define any land cover types by itself but takes the ones of the respective main model. Here, we manually introduce the land cover types wood, trees, bush, and acre to apply evap as a stand-alone model consisting of four hydrological response units:

>>> from hydpy import pub
>>> pub.timegrids = "2000-05-30", "2000-06-03", "1d"
>>> from hydpy.core.parametertools import Constants
>>> WOOD, TREES, BUSH, ACRE, WATER = 1, 2, 3, 4, 5
>>> constants = Constants(WOOD=WOOD, TREES=TREES, BUSH=BUSH, ACRE=ACRE)
>>> from hydpy.models.evap.evap_control import HRUType, LeafAreaIndex
>>> with HRUType.modify_constants(constants), \
...         LeafAreaIndex.modify_rows(constants):
...     from hydpy.models.evap import *
...     parameterstep()
>>> nmbhru(4)

For water areas, the soil heat flux is generally zero:

>>> water(True)
>>> model.calc_soilheatflux_v4()
>>> fluxes.soilheatflux
soilheatflux(0.0, 0.0, 0.0, 0.0)

We focus on non-water areas using all the different defined land cover types in the following examples:

>>> hrutype(ACRE, BUSH, TREES, WOOD)
>>> water(False)

The next calculation addressed the complete 31st of May, for which we set land cover-specific leaf area indices:

>>> model.idx_sim = pub.timegrids.init["2000-05-31"]
>>> derived.hours.update()
>>> derived.moy.update()
>>> leafareaindex.acre_may = 0.0
>>> leafareaindex.bush_may = 2.0
>>> leafareaindex.trees_may = 5.0
>>> leafareaindex.wood_may = 10.0

We say the astronomically possible sunshine duration and the net radiation of that day to be 18 h and 200 W/m²:

>>> factors.possiblesunshineduration = 18.0
>>> fluxes.netradiation = 200.0

The larger the leaf area index, the smaller the soil heat flux. The dense canopies of trees can suppress them entirely:

>>> model.calc_soilheatflux_v4()
>>> fluxes.soilheatflux
soilheatflux(55.0, 38.5, 13.75, 0.0)

Now, we switch to an hourly step size and to the time of sunrise on the 1st of June:

>>> pub.timegrids = "2000-06-01 04:00", "2000-06-01 08:00", "1h"
>>> model.idx_sim = pub.timegrids.init["2000-06-01 05:00"]
>>> derived.hours.update()
>>> derived.moy.update()

We set slightly larger leaf area indices:

>>> leafareaindex.acre_jun = 0.0
>>> leafareaindex.bush_jun = 3.0
>>> leafareaindex.trees_jun = 6.0
>>> leafareaindex.wood_jun = 12.0

We assume sunrise at 5:15 and a negative net radiation value:

>>> factors.possiblesunshineduration = 0.25
>>> fluxes.netradiation = -20.0

Again, dense vegetation reduces the soil heat flux without changing its sign, and very dense vegetation suppresses it completely:

>>> model.calc_soilheatflux_v4()
>>> model.calc_soilheatflux_v4()
>>> fluxes.soilheatflux
soilheatflux(-8.5, -4.675, -0.85, 0.0)
class hydpy.models.evap.evap_model.Calc_PsychrometricConstant_V1[source]

Bases: Method

Calculate the psychrometric constant according to Allen et al. (1998).

Requires the input sequence:

AtmosphericPressure

Calculates the factor sequence:

PsychrometricConstant

Basic equation (Allen et al. (1998), equation 8):

\(PsychrometricConstant = 6.65 \cdot 10^{-4} \cdot AtmosphericPressure\)

Example:

The following calculation agrees with example 2 of Allen et al. (1998):

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> inputs.atmosphericpressure = 818.0
>>> model.calc_psychrometricconstant_v1()
>>> factors.psychrometricconstant
psychrometricconstant(0.54397)
class hydpy.models.evap.evap_model.Calc_AerodynamicResistance_V1[source]

Bases: Method

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

Required by the method:

Determine_InterceptionEvaporation_V2

Requires the control parameters:

NmbHRU HRUType CropHeight

Requires the derived parameter:

MOY

Requires the factor sequence:

WindSpeed10m

Calculates the factor sequence:

AerodynamicResistance

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

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

Examples:

Base model evap does not define any land cover types by itself but takes the ones of the respective main model. Here, we manually introduce the land cover types of wood, trees, bush, acre, and water to apply evap as a stand-alone model:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-30", "2000-02-03", "1d"
>>> from hydpy.core.parametertools import Constants
>>> WOOD, TREES, BUSH, ACRE, WATER = 1, 2, 3, 4, 5
>>> constants = Constants(
...     WOOD=WOOD, TREES=TREES, BUSH=BUSH, ACRE=ACRE, WATER=WATER)
>>> from hydpy.models.evap.evap_control import HRUType, CropHeight
>>> with HRUType.modify_constants(constants), CropHeight.modify_rows(constants):
...     from hydpy.models.evap import *
...     parameterstep()
>>> nmbhru(5)
>>> hrutype(WATER, ACRE, BUSH, TREES, WOOD)
>>> derived.moy.update()

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

>>> cropheight.water_jan = 0.0
>>> cropheight.acre_jan = 1.0
>>> cropheight.bush_jan = 5.0
>>> cropheight.trees_jan = 10.0
>>> cropheight.wood_jan = 30.0
>>> factors.windspeed10m = 3.0
>>> model.idx_sim = 1
>>> model.calc_aerodynamicresistance_v1()
>>> factors.aerodynamicresistance
aerodynamicresistance(79.202731, 33.256788, 12.831028, 31.333333,
                      31.333333)

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

>>> cropheight.water_feb = 8.0
>>> cropheight.acre_feb = 9.0
>>> cropheight.bush_feb = 10.0
>>> cropheight.trees_feb = 11.0
>>> cropheight.wood_feb = 12.0
>>> model.idx_sim = 2
>>> model.calc_aerodynamicresistance_v1()
>>> factors.aerodynamicresistance
aerodynamicresistance(8.510706, 7.561677, 31.333333, 31.333333,
                      31.333333)

One could use a threshold crop height of 1.14 m instead of 10 m to remove this discontinuity:

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

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

>>> from hydpy import print_vector
>>> cropheight(2.0)
>>> for ws in (0.0, 0.1, 1.0, 10.0):
...     factors.windspeed10m = ws
...     model.calc_aerodynamicresistance_v1()
...     print_vector([ws, factors.aerodynamicresistance[0]])
0.0, inf
0.1, 706.026613
1.0, 70.602661
10.0, 7.060266
class hydpy.models.evap.evap_model.Calc_AerodynamicResistance_V2[source]

Bases: Method

Calculate the aerodynamic resistance according to Löpmeier (2014).

Required by the method:

Determine_PotentialInterceptionEvaporation_V1

Requires the control parameters:

NmbHRU HRUType

Requires the derived parameters:

MOY AerodynamicResistanceFactor

Requires the factor sequence:

WindSpeed10m

Calculates the factor sequence:

AerodynamicResistance

Basic equation:
\[AerodynamicResistance = AerodynamicResistanceFactor / WindSpeed10m\]

Examples:

We reuse the same example setting of method Calc_AerodynamicResistance_V1 to allow for comparisons:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-30", "2000-02-03", "1d"
>>> from hydpy.core.parametertools import Constants
>>> WOOD, TREES, BUSH, ACRE, WATER = 1, 2, 3, 4, 5
>>> constants = Constants(
...     WOOD=WOOD, TREES=TREES, BUSH=BUSH, ACRE=ACRE, WATER=WATER)
>>> from hydpy.models.evap.evap_control import HRUType, CropHeight
>>> from hydpy.models.evap.evap_derived import AerodynamicResistanceFactor, RoughnessLength  # pylint: disable=line-too-long
>>> with HRUType.modify_constants(constants), CropHeight.modify_rows(constants), AerodynamicResistanceFactor.modify_rows(constants), RoughnessLength.modify_rows(constants) :  # pylint: disable=line-too-long
...     from hydpy.models.evap import *
...     parameterstep()
>>> nmbhru(5)
>>> hrutype(WATER, ACRE, BUSH, TREES, WOOD)
>>> derived.moy.update()

Calc_AerodynamicResistance_V2 calculates larger resistances for crops smaller than 10 meters and equal resistances for crops larger than 10 meters:

>>> cropheight.water_jan = 0.0
>>> cropheight.acre_jan = 1.0
>>> cropheight.bush_jan = 5.0
>>> cropheight.trees_jan = 10.0
>>> cropheight.wood_jan = 30.0
>>> derived.roughnesslength.update()
>>> derived.aerodynamicresistancefactor.update()
>>> factors.windspeed10m = 3.0
>>> model.idx_sim = 1
>>> model.calc_aerodynamicresistance_v2()
>>> factors.aerodynamicresistance
aerodynamicresistance(250.991726, 37.398301, 31.333333, 31.333333,
                      31.333333)

For zero wind speed, resistance becomes infinite:

>>> from hydpy import print_vector
>>> factors.windspeed10m = 0.0
>>> model.calc_aerodynamicresistance_v2()
>>> factors.aerodynamicresistance
aerodynamicresistance(inf, inf, inf, inf, inf)
class hydpy.models.evap.evap_model.Calc_SoilSurfaceResistance_V1[source]

Bases: Method

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

Required by the method:

Determine_SoilEvapotranspiration_V3

Requires the control parameters:

NmbHRU Soil MaxSoilWater

Requires the factor sequence:

SoilWater

Calculates the factor sequence:

SoilSurfaceResistance

Basic equations:
\[\begin{split}SoilSurfaceResistance = \begin{cases} 100 &|\ W_m> 20 \\ \frac{100 \cdot W_m}{W_a + W_m/100} &|\ W_m\leq 20 \end{cases} \\ \\ W_a = SoilWater \\ W_m = MaxSoilWater\end{split}\]

Examples:

For areas without relevant soils (for example, water areas and sealed surfaces), Calc_SoilSurfaceResistance_V1 sets the soil surface resistance to nan.

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(5)
>>> soil(False)
>>> maxsoilwater(0.0)
>>> soilmoisturelimit(0.0)
>>> factors.soilwater = 0.0
>>> model.calc_soilsurfaceresistance_v1()
>>> factors.soilsurfaceresistance
soilsurfaceresistance(nan, nan, nan, nan, nan)

For soils with a maximum water content larger than 20 mm, the soil surface resistance is generally 100.0 s/m:

>>> soil(True)
>>> maxsoilwater(20.1)
>>> factors.soilwater = 0.0, 5.0, 10.0, 15.0, 20.1
>>> model.calc_soilsurfaceresistance_v1()
>>> factors.soilsurfaceresistance
soilsurfaceresistance(100.0, 100.0, 100.0, 100.0, 100.0)

For “real” soils, resistance decreases with increasing soil water contents until it reaches a minimum of 99 s/m:

>>> maxsoilwater(20.0)
>>> factors.soilwater = 0.0, 5.0, 10.0, 15.0, 20.0
>>> model.calc_soilsurfaceresistance_v1()
>>> factors.soilsurfaceresistance
soilsurfaceresistance(10000.0, 384.615385, 196.078431, 131.578947,
                      99.009901)

For zero maximum water contents, soil surface resistance is zero:

>>> maxsoilwater(0.0)
>>> model.calc_soilsurfaceresistance_v1()
>>> factors.soilsurfaceresistance
soilsurfaceresistance(inf, inf, inf, inf, inf)
class hydpy.models.evap.evap_model.Update_LoggedPrecipitation_V1[source]

Bases: Method

Log the precipitation values of the last 24 hours.

Requires the control parameter:

NmbHRU

Requires the derived parameter:

NmbLogEntries

Requires the flux sequence:

Precipitation

Updates the log sequence:

LoggedPrecipitation

Example:

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

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> derived.nmblogentries(3)
>>> logs.loggedprecipitation.shape = 3, 2
>>> logs.loggedprecipitation = 0.0, 0.0
>>> from hydpy import UnitTest
>>> test = UnitTest(model,
...                 model.update_loggedprecipitation_v1,
...                 last_example=4,
...                 parseqs=(fluxes.precipitation,
...                          logs.loggedprecipitation))
>>> test.nexts.precipitation = [1.0, 2.0], [3.0, 6.0], [2.0, 4.0], [4.0, 8.0]
>>> del test.inits.loggedprecipitation
>>> test()
| ex. |      precipitation |                          loggedprecipitation |
---------------------------------------------------------------------------
|   1 | 1.0            2.0 | 1.0  2.0  0.0  0.0  0.0                  0.0 |
|   2 | 3.0            6.0 | 3.0  6.0  1.0  2.0  0.0                  0.0 |
|   3 | 2.0            4.0 | 2.0  4.0  3.0  6.0  1.0                  2.0 |
|   4 | 4.0            8.0 | 4.0  8.0  2.0  4.0  3.0                  6.0 |
class hydpy.models.evap.evap_model.Calc_DailyPrecipitation_V1[source]

Bases: Method

Calculate the precipitation sum of the last 24 hours.

Required by the method:

Determine_PotentialInterceptionEvaporation_V1

Requires the control parameter:

NmbHRU

Requires the derived parameter:

NmbLogEntries

Requires the log sequence:

LoggedPrecipitation

Calculates the flux sequence:

DailyPrecipitation

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> derived.nmblogentries(3)
>>> logs.loggedprecipitation.shape = 3, 2
>>> logs.loggedprecipitation = [1.0, 2.0], [5.0, 6.0], [3.0, 4.0]
>>> model.calc_dailyprecipitation_v1()
>>> fluxes.dailyprecipitation
dailyprecipitation(9.0, 12.0)
class hydpy.models.evap.evap_model.Update_LoggedPotentialSoilEvapotranspiration_V1[source]

Bases: Method

Log the potential soil evapotranspiration values of the last 24 hours.

Requires the control parameter:

NmbHRU

Requires the derived parameter:

NmbLogEntries

Requires the flux sequence:

PotentialSoilEvapotranspiration

Updates the log sequence:

LoggedPotentialSoilEvapotranspiration

Example:

The following example shows that each new method call successively moves the six memorised values to the right and stores the two new values on the leftmost position:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> derived.nmblogentries(3)
>>> logs.loggedpotentialsoilevapotranspiration.shape = 3, 2
>>> logs.loggedpotentialsoilevapotranspiration = 0.0, 0.0
>>> from hydpy import UnitTest
>>> test = UnitTest(model,
...                 model.update_loggedpotentialsoilevapotranspiration_v1,
...                 last_example=4,
...                 parseqs=(fluxes.potentialsoilevapotranspiration,
...                          logs.loggedpotentialsoilevapotranspiration))
>>> test.nexts.potentialsoilevapotranspiration = [1.0, 2.0], [3.0, 6.0], [2.0, 4.0], [4.0, 8.0]
>>> del test.inits.loggedpotentialsoilevapotranspiration
>>> test()
| ex. |      potentialsoilevapotranspiration |                          loggedpotentialsoilevapotranspiration |
---------------------------------------------------------------------------------------------------------------
|   1 | 1.0                              2.0 | 1.0  2.0  0.0  0.0  0.0                                    0.0 |
|   2 | 3.0                              6.0 | 3.0  6.0  1.0  2.0  0.0                                    0.0 |
|   3 | 2.0                              4.0 | 2.0  4.0  3.0  6.0  1.0                                    2.0 |
|   4 | 4.0                              8.0 | 4.0  8.0  2.0  4.0  3.0                                    6.0 |
class hydpy.models.evap.evap_model.Calc_DailyPotentialSoilEvapotranspiration_V1[source]

Bases: Method

Calculate the potential soil evapotranspiration sum of the last 24 hours.

Required by the method:

Determine_PotentialInterceptionEvaporation_V1

Requires the control parameter:

NmbHRU

Requires the derived parameter:

NmbLogEntries

Requires the log sequence:

LoggedPotentialSoilEvapotranspiration

Calculates the flux sequence:

DailyPotentialSoilEvapotranspiration

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> derived.nmblogentries(3)
>>> logs.loggedpotentialsoilevapotranspiration.shape = 3, 2
>>> logs.loggedpotentialsoilevapotranspiration = (
...     [1.0, 2.0], [5.0, 6.0], [3.0, 4.0])
>>> model.calc_dailypotentialsoilevapotranspiration_v1()
>>> fluxes.dailypotentialsoilevapotranspiration
dailypotentialsoilevapotranspiration(9.0, 12.0)
class hydpy.models.evap.evap_model.Update_SoilResistance_V1[source]

Bases: Method

Update the soil surface resistance following Löpmeier (2014).

Requires the control parameters:

NmbHRU Soil WetSoilResistance SoilResistanceIncrease WetnessThreshold

Requires the flux sequences:

DailyPrecipitation DailyPotentialSoilEvapotranspiration

Updates the state sequence:

SoilResistance

Basic equations:
\[\begin{split}r_{new} = \begin{cases} r_{old} + \Delta &|\ p / e < \tau \\ w &|\ p / e \geq \tau \end{cases} \\ \\ \\ r = SoilResistance \\ w = WetSoilResistance \\ \Delta = SoilResistanceIncrease \\ \tau = WetnessThreshold \\ p = DailyPrecipitation \\ e = DailyPotentialSoilEvapotranspiration\end{split}\]

Example:

Update_SoilResistance_V1 generally sets the soil surface resistance to nan for all areas without relevant soils (see the first hydrological response unit). For all other areas, it increases the resistance constantly as long as the precipitation sum over the last 24 hours is less than the potential evapotranspiration sum over the last 24 hours (second response unit) or otherwise sets it to the “initial value” for wet soil surfaces (third and fourth response unit):

>>> from hydpy.models.evap import *
>>> parameterstep("1d")
>>> simulationstep("1h")
>>> nmbhru(4)
>>> soil(False, True, True, True)
>>> wetsoilresistance(50.0)
>>> wetnessthreshold(0.5)
>>> soilresistanceincrease(24.0)
>>> states.soilresistance = 60.0
>>> fluxes.dailyprecipitation = 3.0, 4.0, 5.0, 6.0
>>> fluxes.dailypotentialsoilevapotranspiration = 10.0
>>> model.update_soilresistance_v1()
>>> states.soilresistance
soilresistance(nan, 61.0, 50.0, 50.0)
class hydpy.models.evap.evap_model.Calc_LanduseSurfaceResistance_V1[source]

Bases: Method

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

Required by the method:

Determine_SoilEvapotranspiration_V3

Requires the control parameters:

NmbHRU HRUType Soil Conifer SurfaceResistance MaxSoilWater SoilMoistureLimit

Requires the derived parameter:

MOY

Requires the factor sequences:

AirTemperature SaturationVapourPressure ActualVapourPressure SoilWater

Calculates the factor sequence:

LanduseSurfaceResistance

Basic equations:
\[\begin{split}LanduseSurfaceResistance = r^* \cdot \begin{cases} 3.5 \cdot (1 - W / \tau) + exp(0.2 \cdot \tau / W)&|\ W \leq \tau \\ exp(0.2) &|\ W > \tau \end{cases} \\ \\ \\ r^*= \begin{cases} r&|\ \overline{C} \\ 10\,000 &|\ C \;\; \land \;\; (T \leq -5 \;\; \lor \;\; \Delta \geq 20) \\ min\left(\frac{25 \cdot r}{(T + 5) \cdot (1 - \Delta / 20)}, \ 10\,000\right) &|\ C \;\; \land \;\; (-5 < T < 20 \;\; \land \;\; \Delta < 20) \\ min\left(\frac{r}{1 - \Delta / 20}, \ 10\,000\right) &|\ C \;\; \land \;\; (20 \leq T \;\; \land \;\; \Delta < 20) \end{cases} \\ \\ \\ W = SoilWater \\ C = Conifer \\ \tau = SoilMoistureLimit \cdot MaxSoilWater \\ r = SurfaceResistance \\ \Delta = SaturationVapourPressure - ActualVapourPressure \\ T = AirTemperature\end{split}\]

Examples:

Base model evap does not define any land cover types by itself but takes the ones of the respective main model. Here, we manually introduce the land cover types water, sealed, acre, and conifer to apply evap as a stand-alone model:

>>> from hydpy import pub
>>> pub.timegrids = "2000-05-30", "2000-06-03", "1d"
>>> from hydpy.core.parametertools import Constants
>>> WATER, SEALED, ACRE, CONIFER,  = 1, 2, 3, 4
>>> constants = Constants(
...     WATER=WATER, SEALED=SEALED, ACRE=ACRE, CONIFER=CONIFER)
>>> from hydpy.models.evap.evap_control import HRUType, SurfaceResistance
>>> with HRUType.modify_constants(constants), \
...         SurfaceResistance.modify_rows(constants):
...     from hydpy.models.evap import *
...     parameterstep()
>>> nmbhru(4)

Method Calc_LanduseSurfaceResistance_V1 relies on multiple discontinuous relationships, works differently for different land types, and uses monthly varying parameters. Hence, we start simple and introduce further complexities step by step.

For response units without relevant soils (like those with sealed surfaces or surface water bodies), the original parameter values are in effect without any modification:

>>> hrutype(SEALED, SEALED, WATER, WATER)
>>> soil(False)
>>> conifer(False)
>>> surfaceresistance.water_may = 0.0
>>> surfaceresistance.sealed_may = 500.0
>>> derived.moy.update()
>>> model.idx_sim = 1
>>> model.calc_landusesurfaceresistance_v1()
>>> factors.landusesurfaceresistance
landusesurfaceresistance(500.0, 500.0, 0.0, 0.0)

For all “soil areas”, Calc_LanduseSurfaceResistance_V1 slightly increases the original parameter value by a constant factor for wet soils (SoilWater > SoilMoistureLimit) and increases it even more for dry soils (SoilWater > SoilMoistureLimit). For a completely dried-up soils, surface resistance becomes infinite:

>>> hrutype(ACRE)
>>> soil(True)
>>> soilmoisturelimit(0.0)
>>> surfaceresistance.acre_jun = 40.0
>>> factors.soilwater = 0.0, 10.0, 20.0, 30.0
>>> model.idx_sim = 2
>>> model.calc_landusesurfaceresistance_v1()
>>> factors.landusesurfaceresistance
landusesurfaceresistance(inf, 48.85611, 48.85611, 48.85611)

>>> maxsoilwater(40.0)
>>> soilmoisturelimit(0.5)
>>> model.calc_landusesurfaceresistance_v1()
>>> factors.landusesurfaceresistance
landusesurfaceresistance(inf, 129.672988, 48.85611, 48.85611)

>>> factors.soilwater = 17.0, 18.0, 19.0, 20.0
>>> model.calc_landusesurfaceresistance_v1()
>>> factors.landusesurfaceresistance
landusesurfaceresistance(71.611234, 63.953955, 56.373101, 48.85611)

Calc_LanduseSurfaceResistance_V1 treats coniferous trees special by increasing surface resistance further for low temperatures and high water vapour pressure deficits. The highest resistance value occurs for air temperatures lower than -5 °C or vapour pressure deficits higher than 20 hPa:

>>> hrutype(CONIFER)
>>> conifer(True)
>>> surfaceresistance.conifer_jun = 80.0
>>> factors.soilwater = 20.0
>>> factors.airtemperature = 30.0
>>> factors.saturationvapourpressure = 30.0
>>> factors.actualvapourpressure = 0.0, 10.0, 20.0, 30.0
>>> model.calc_landusesurfaceresistance_v1()
>>> factors.landusesurfaceresistance
landusesurfaceresistance(12214.027582, 12214.027582, 195.424441,
                         97.712221)

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

>>> factors.actualvapourpressure = 20.0
>>> factors.airtemperature = -10.0, 5.0, 20.0, 35.0
>>> model.calc_landusesurfaceresistance_v1()
>>> factors.landusesurfaceresistance
landusesurfaceresistance(12214.027582, 488.561103, 195.424441,
                         195.424441)

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

>>> factors.airtemperature = 18.0, 19.0, 20.0, 21.0
>>> model.calc_landusesurfaceresistance_v1()
>>> factors.landusesurfaceresistance
landusesurfaceresistance(212.417871, 203.567126, 195.424441, 195.424441)
class hydpy.models.evap.evap_model.Calc_ActualSurfaceResistance_V1[source]

Bases: Method

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

Required by the method:

Determine_SoilEvapotranspiration_V3

Requires the control parameters:

NmbHRU HRUType Soil LeafAreaIndex

Requires the derived parameters:

MOY Hours

Requires the factor sequences:

PossibleSunshineDuration SoilSurfaceResistance LanduseSurfaceResistance

Calculates the factor sequence:

ActualSurfaceResistance

Basic equations:

\(ActualSurfaceResistance = \left(\frac{w}{SR_{day}} + \frac{1 - w}{SR_{night}}\right)^{-1}\)

\(SR_{day} = \left(\frac{1-0.7^{LeafAreaIndex}}{LanduseSurfaceResistance} + \frac{0.7^{LeafAreaIndex}}{SoilSurfaceResistance}\right)^{-1}\)

\(SR_{night} = \left(\frac{LeafAreaIndex}{2500} + \frac{1}{SoilSurfaceResistance}\right)^{-1}\)

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

Examples:

Base model evap does not define any land cover types by itself but takes the ones of the respective main model. Here, we manually introduce the land cover types wood, trees, bush, acre, and water to apply evap as a stand-alone model:

>>> from hydpy import pub
>>> pub.timegrids = "2019-05-30", "2019-06-03", "1d"
>>> from hydpy.core.parametertools import Constants
>>> WOOD, TREES, BUSH, ACRE, WATER = 1, 2, 3, 4, 5
>>> constants = Constants(
...     WOOD=WOOD, TREES=TREES, BUSH=BUSH, ACRE=ACRE, WATER=WATER)
>>> from hydpy.models.evap.evap_control import HRUType, LeafAreaIndex
>>> with HRUType.modify_constants(constants), \
...         LeafAreaIndex.modify_rows(constants):
...     from hydpy.models.evap import *
...     parameterstep()
>>> nmbhru(4)

For response units without relevant soils (like those with sealed surfaces or surface water bodies), method Calc_ActualSurfaceResistance_V1 just uses the values of sequence LanduseSurfaceResistance as the effective surface resistance values:

>>> hrutype(WATER)
>>> soil(False)
>>> derived.moy.update()
>>> derived.hours.update()
>>> factors.soilsurfaceresistance = nan
>>> factors.landusesurfaceresistance = 500.0, 0.0, 0.0, 0.0
>>> model.idx_sim = 1
>>> model.calc_actualsurfaceresistance_v1()
>>> factors.actualsurfaceresistance
actualsurfaceresistance(500.0, 0.0, 0.0, 0.0)

For all “soil areas”, the final soil resistance is a combination of LanduseSurfaceResistance and SoilSurfaceResistance that depends on the leaf area index:

>>> hrutype(ACRE, BUSH, TREES, WOOD)
>>> soil(True)
>>> leafareaindex.acre_may = 0.0
>>> leafareaindex.bush_may = 2.0
>>> leafareaindex.trees_may = 5.0
>>> leafareaindex.wood_may = 10.0

All four hydrological response units have identical soil- and land-use-related surface resistance values:

>>> factors.soilsurfaceresistance = 200.0
>>> factors.landusesurfaceresistance = 100.0

For a polar day, the actual resistance equals the soil surface resistance for zero leaf area indices (see the first response unit). With an increasing leaf area index, actual resistance tends towards land-use-related resistance:

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

For a polar night, Calc_ActualSurfaceResistance_V1 performs a leaf area index-dependent interpolation between soil surface resistance and a fixed resistance value:

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

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

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

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

>>> pub.timegrids = "2019-05-31 22:00", "2019-06-01 03:00", "1h"
>>> nmbhru(1)
>>> hrutype(WOOD)
>>> soil(True)
>>> factors.soilsurfaceresistance = 200.0
>>> factors.landusesurfaceresistance = 100.0
>>> derived.moy.update()
>>> derived.hours.update()
>>> leafareaindex.wood_jun = 5.0
>>> model.idx_sim = 2
>>> factors.possiblesunshineduration = 1.0
>>> model.calc_actualsurfaceresistance_v1()
>>> factors.actualsurfaceresistance
actualsurfaceresistance(109.174477)

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

>>> factors.possiblesunshineduration = 0.5
>>> model.calc_actualsurfaceresistance_v1()
>>> factors.actualsurfaceresistance
actualsurfaceresistance(123.765057)
class hydpy.models.evap.evap_model.Calc_ActualSurfaceResistance_V2[source]

Bases: Method

Calculate the actual surface resistance according to Löpmeier (2014) and based on Thompson et al. (1981).

Requires the control parameters:

NmbHRU HRUType Soil Plant LeafAreaIndex LeafResistance

Requires the derived parameters:

MOY Hours

Requires the factor sequence:

PossibleSunshineDuration

Requires the state sequence:

SoilResistance

Calculates the factor sequence:

ActualSurfaceResistance

Basic equations:
\[\begin{split}ActualSurfaceResistance = \left(\frac{\omega_{day}}{r_{day}} + \frac{1 - \omega_{day}}{r_{night}}\right)^{-1} \\ \\ \\ r_{day} = \left(\frac{1 - \omega_{soil}}{r_l} + \frac{\omega_{soil}}{r_s}\right)^{-1} \\ \\ r_{night} = \left(\frac{lai}{2800} + \frac{1}{r_s}\right)^{-1} \\ \\ \\ \omega_{day} = PossibleSunshineDuration / Hours \\ \omega_{soil} = \begin{cases} 0.8^{lai} &|\ lai < 1 \\ 0.7^{lai} &|\ lai \geq 1 \end{cases} \\ \\ \\ lai = LeafAreaIndex \\ r_s = SoilSurfaceResistance \\ r_l = LeafResistance\end{split}\]

Examples:

Calc_ActualSurfaceResistance_V2 works similarly to method Calc_ActualSurfaceResistance_V1. We build up a comparable setting but use lland_dd and evap_aet_minhas as main models to prepare an applicable evap instance (more precisely, an evap_pet_ambav1 instance) more easily:

>>> from hydpy.models.lland_dd import *
>>> parameterstep()
>>> nhru(5)
>>> lnk(WASSER, FLUSS, SEE, BODEN, BODEN)
>>> ft(10.0)
>>> fhru(0.2)
>>> wmax(200.0)
>>> from hydpy import pub
>>> pub.timegrids = "2000-05-30", "2000-06-03", "1d"
>>> with model.add_aetmodel_v1("evap_aet_minhas"):
...     with model.add_petmodel_v2("evap_pet_ambav1") as ambav:
...         pass
>>> control = ambav.parameters.control
>>> derived = ambav.parameters.derived
>>> inputs = ambav.sequences.inputs
>>> factors = ambav.sequences.factors
>>> states = ambav.sequences.states

For response units without relevant soils (like those with sealed surfaces) or with unvegetated soils, method Calc_ActualSurfaceResistance_V2 generally performs no calculation but sets the effective surface resistance to zero or takes the defined soil resistance value:

>>> control.hrutype
hrutype(WASSER, FLUSS, SEE, BODEN, BODEN)
>>> control.soil
soil(boden=True, fluss=False, see=False, wasser=False)
>>> states.soilresistance = 300.0
>>> ambav.calc_actualsurfaceresistance_v2()
>>> factors.actualsurfaceresistance
actualsurfaceresistance(0.0, 0.0, 0.0, 300.0, 300.0)

For all “soil areas”, the final soil resistance is a combination of LeafResistance and SoilResistance that depends on the leaf area index, which is generally zero for non-vegetated land cover types:

>>> lnk(BODEN, ACKER, GRUE_E, GRUE_I, NADELW)
>>> model.update_parameters(ignore_errors=True)
>>> control.hrutype
hrutype(BODEN, ACKER, GRUE_E, GRUE_I, NADELW)
>>> control.soil
soil(True)
>>> control.plant
plant(acker=True, boden=False, grue_e=True, grue_i=True, nadelw=True)
>>> control.leafareaindex.acker_may = 0.0
>>> control.leafareaindex.grue_e_may = 0.9999
>>> control.leafareaindex.grue_i_may = 1.0
>>> control.leafareaindex.baumb_may = 5.0
>>> control.leafareaindex.nadelw_may = 10.0
>>> model.idx_sim = 1
>>> derived.moy.update()
>>> derived.hours.update()

All five hydrological response units have identical soil and leaf resistance values:

>>> control.leafresistance(100.0)
>>> states.soilresistance = 200.0

For a polar day, the results are identical to those of method Calc_ActualSurfaceResistance_V1, except that Calc_ActualSurfaceResistance_V2 calculates larger values for leaf area indices smaller than one (which goes along with a sudden resistance decrease when reaching a leaf area index of one):

>>> factors.possiblesunshineduration = 24.0
>>> ambav.calc_actualsurfaceresistance_v2()
>>> factors.actualsurfaceresistance
actualsurfaceresistance(200.0, 200.0, 166.669146, 153.846154, 101.43261)

For a polar night, Calc_ActualSurfaceResistance_V2 calculates slightly higher values due to assuming a surface resistance of 2,800 s/m instead of 2,500 s/m for leaves with completely closed stomata:

>>> factors.possiblesunshineduration = 0.0
>>> ambav.calc_actualsurfaceresistance_v2()
>>> factors.actualsurfaceresistance
actualsurfaceresistance(200.0, 200.0, 186.667911, 186.666667, 116.666667)

Accordingly, Calc_ActualSurfaceResistance_V2 always determines slightly higher surface resistances in mixed cases:

>>> factors.possiblesunshineduration = 12.0
>>> ambav.calc_actualsurfaceresistance_v2()
>>> factors.actualsurfaceresistance
actualsurfaceresistance(200.0, 200.0, 176.102567, 168.674699, 108.517595)

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

>>> pub.timegrids = "2019-05-31 22:00", "2019-06-01 03:00", "1h"
>>> nhru(1)
>>> lnk(NADELW)
>>> fhru(1.0)
>>> wmax(200.0)
>>> model.update_parameters(ignore_errors=True)
>>> control.hrutype
hrutype(NADELW)
>>> control.soil
soil(True)
>>> control.plant
plant(True)
>>> control.leafresistance(100.0)
>>> states.soilresistance = 200.0
>>> control.leafareaindex.nadelw_jun = 5.0
>>> derived.moy.update()
>>> derived.hours.update()
>>> factors.possiblesunshineduration = 1.0
>>> ambav.idx_sim = 2
>>> ambav.calc_actualsurfaceresistance_v2()
>>> factors.actualsurfaceresistance
actualsurfaceresistance(109.174477)

>>> factors.possiblesunshineduration = 0.0
>>> ambav.calc_actualsurfaceresistance_v2()
>>> factors.actualsurfaceresistance
actualsurfaceresistance(147.368421)

>>> factors.possiblesunshineduration = 0.5
>>> ambav.calc_actualsurfaceresistance_v2()
>>> factors.actualsurfaceresistance
actualsurfaceresistance(125.428304)
class hydpy.models.evap.evap_model.Calc_Precipitation_PrecipModel_V1[source]

Bases: Method

Query precipitation from a main model that is referenced as a sub-submodel and follows the PrecipModel_V1 interface.

Requires the control parameter:

NmbHRU

Calculates the flux sequence:

Precipitation

Example:

We use the combination of hland_96 and evap_pet_hbv96 as an example:

>>> from hydpy.models.hland_96 import *
>>> parameterstep()
>>> area(10.0)
>>> nmbzones(3)
>>> zonearea(5.0, 3.0, 2.0)
>>> zonetype(FIELD)
>>> zonez(2.0)
>>> fc(200.0)
>>> with model.add_aetmodel_v1("evap_aet_hbv96"):
...     with model.add_petmodel_v1("evap_pet_hbv96"):
...         pass
>>> fluxes.pc(1.0, 3.0, 2.0)
>>> model.aetmodel.petmodel.calc_precipitation_v1()
>>> model.aetmodel.petmodel.sequences.fluxes.precipitation
precipitation(1.0, 3.0, 2.0)
class hydpy.models.evap.evap_model.Calc_Precipitation_PrecipModel_V2[source]

Bases: Method

Let a submodel that complies with the PrecipModel_V2 interface determine the precipitation.

Requires the control parameter:

NmbHRU

Calculates the flux sequence:

Precipitation

Example:

We use the combination of evap_pet_hbv96 and meteo_precip_io as an example:

>>> from hydpy.models.evap_pet_hbv96 import *
>>> parameterstep()
>>> nmbhru(3)
>>> hruarea(0.5, 0.3, 0.2)
>>> with model.add_precipmodel_v2("meteo_precip_io"):
...     precipitationfactor(0.5, 1.0, 2.0)
...     inputs.precipitation = 2.0
>>> model.calc_precipitation_v1()
>>> fluxes.precipitation
precipitation(1.0, 2.0, 4.0)
class hydpy.models.evap.evap_model.Calc_Precipitation_V1[source]

Bases: Method

Let a submodel that complies with the PrecipModel_V1 or PrecipModel_V2 interface determine precipitation.

class hydpy.models.evap.evap_model.Calc_InterceptedWater_IntercModel_V1[source]

Bases: Method

Query the current amount of intercepted water from a submodel that follows the IntercModel_V1 interface.

Required by the method:

Calc_InterceptedWater_V1

Requires the control parameter:

NmbHRU

Calculates the factor sequence:

InterceptedWater

Example:

We use the combination of hland_96 and evap_aet_hbv96 as an example:

>>> from hydpy.models.hland_96 import *
>>> parameterstep()
>>> area(10.0)
>>> nmbzones(3)
>>> zonearea(5.0, 3.0, 2.0)
>>> zonetype(FIELD)
>>> zonez(2.0)
>>> fc(100.0)
>>> with model.add_aetmodel_v1("evap_aet_hbv96"):
...     pass
>>> states.ic = 1.0, 3.0, 2.0
>>> model.aetmodel.calc_interceptedwater_v1()
>>> model.aetmodel.sequences.factors.interceptedwater
interceptedwater(1.0, 3.0, 2.0)
class hydpy.models.evap.evap_model.Calc_InterceptedWater_V1[source]

Bases: Method

Let a submodel that complies with the IntercModel_V1 interface determine the current amount of intercepted water.

Required by the methods:

Determine_InterceptionEvaporation_V1 Determine_InterceptionEvaporation_V2

Required submethod:

Calc_InterceptedWater_IntercModel_V1

Requires the control parameter:

NmbHRU

Calculates the factor sequence:

InterceptedWater

class hydpy.models.evap.evap_model.Calc_SnowyCanopy_SnowyCanopyModel_V1[source]

Bases: Method

Query the current snow cover degree in the canopies of tree-like vegetation from a submodel that follows the SnowyCanopyModel_V1 interface.

Required by the method:

Calc_SnowyCanopy_V1

Requires the control parameter:

NmbHRU

Calculates the factor sequence:

SnowyCanopy

class hydpy.models.evap.evap_model.Calc_SnowyCanopy_V1[source]

Bases: Method

Query the current snow cover degree in the canopies of tree-like vegetation from a submodel that follows the SnowyCanopyModel_V1 interface, if available.

Required by the method:

Determine_InterceptionEvaporation_V2

Required submethod:

Calc_SnowyCanopy_SnowyCanopyModel_V1

Requires the control parameter:

NmbHRU

Calculates the factor sequence:

SnowyCanopy

Examples:

We use the combination of lland_knauf_ic and evap_aet_morsim as an example:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2001-01-01", "1d"
>>> from hydpy.models.lland_knauf_ic import *
>>> parameterstep()
>>> ft(10.0)
>>> nhru(3)
>>> fhru(5.0, 3.0, 2.0)
>>> lnk(LAUBW, LAUBW, ACKER)
>>> measuringheightwindspeed(10.0)
>>> lai(3.0)
>>> wmax(100.0)
>>> states.stinz = 0.0, 0.1, 0.1
>>> with model.add_aetmodel_v1("evap_aet_morsim"):
...     pass
>>> model.aetmodel.calc_snowycanopy_v1()
>>> model.aetmodel.sequences.factors.snowycanopy
snowycanopy(0.0, 1.0, nan)

Without a suitable submodel, Calc_SnowyCanopy_V1 generally sets SnowyCanopy to nan:

>>> del model.aetmodel.snowycanopymodel
>>> model.aetmodel.calc_snowycanopy_v1()
>>> model.aetmodel.sequences.factors.snowycanopy
snowycanopy(nan, nan, nan)
class hydpy.models.evap.evap_model.Calc_SoilWater_SoilWaterModel_V1[source]

Bases: Method

Query the current soil water amount from as submodel that follows the SoilWaterModel_V1 interface.

Required by the method:

Calc_SoilWater_V1

Requires the control parameter:

NmbHRU

Calculates the factor sequence:

SoilWater

Example:

We use the combination of hland_96 and evap_aet_hbv96 as an example:

>>> from hydpy.models.hland_96 import *
>>> parameterstep()
>>> area(10.0)
>>> nmbzones(3)
>>> zonearea(5.0, 3.0, 2.0)
>>> zonetype(FIELD)
>>> zonez(2.0)
>>> fc(100.0)
>>> with model.add_aetmodel_v1("evap_aet_hbv96"):
...     pass
>>> states.sm = 10.0, 30.0, 20.0
>>> model.aetmodel.calc_soilwater_v1()
>>> model.aetmodel.sequences.factors.soilwater
soilwater(10.0, 30.0, 20.0)
class hydpy.models.evap.evap_model.Calc_SoilWater_V1[source]

Bases: Method

Let a submodel that complies with the SoilWaterModel_V1 interface determine the current soil water amount.

Required by the methods:

Determine_SoilEvapotranspiration_V1 Determine_SoilEvapotranspiration_V2 Determine_SoilEvapotranspiration_V3

Required submethod:

Calc_SoilWater_SoilWaterModel_V1

Requires the control parameter:

NmbHRU

Calculates the factor sequence:

SoilWater

class hydpy.models.evap.evap_model.Calc_SnowCover_SnowCoverModel_V1[source]

Bases: Method

Query the current snow cover degree from a submodel that follows the SnowCoverModel_V1 interface.

Required by the method:

Calc_SnowCover_V1

Requires the control parameter:

NmbHRU

Calculates the factor sequence:

SnowCover

Example:

We use the combination of hland_96 and evap_aet_hbv96 as an example:

>>> from hydpy.models.hland_96 import *
>>> parameterstep()
>>> area(10.0)
>>> nmbzones(3)
>>> sclass(2)
>>> zonearea(5.0, 3.0, 2.0)
>>> zonetype(FIELD)
>>> zonez(2.0)
>>> fc(100.0)
>>> with model.add_aetmodel_v1("evap_aet_hbv96"):
...     pass
>>> states.sp = [[0.0, 0.0, 1.0], [0.0, 1.0, 1.0]]
>>> model.aetmodel.calc_snowcover_v1()
>>> model.aetmodel.sequences.factors.snowcover
snowcover(0.0, 0.5, 1.0)
class hydpy.models.evap.evap_model.Calc_SnowCover_V1[source]

Bases: Method

Let a submodel that complies with the SnowCoverModel_V1 interface determine the current snow cover degree.

Required by the methods:

Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_SoilEvapotranspiration_V1 Determine_SoilEvapotranspiration_V3

Required submethod:

Calc_SnowCover_SnowCoverModel_V1

Requires the control parameter:

NmbHRU

Calculates the factor sequence:

SnowCover

class hydpy.models.evap.evap_model.Return_Evaporation_PenmanMonteith_V1[source]

Bases: Method

Calculate the actual evapotranspiration with the Penman-Monteith equation according to LEG (2020), based on Thompson et al. (1981).

Required by the methods:

Calc_PotentialInterceptionEvaporation_V1 Calc_SoilEvapotranspiration_V3

Requires the control parameter:

Emissivity

Requires the fixed parameters:

StefanBoltzmannConstant HeatOfCondensation HeatCapacityAir PsychrometricConstant

Requires the factor sequences:

AirTemperature SaturationVapourPressureSlope SaturationVapourPressure ActualVapourPressure AirDensity AerodynamicResistance

Requires the flux sequences:

NetRadiation SoilHeatFlux

Basic equations:

\[\begin{split}f_{PM}(r_s) = \frac{P'_s \cdot (R_n - G) + C \cdot \rho \cdot c_p \cdot (P_s - P_a) / r_a} {H \cdot (P'_s + \gamma \cdot C \cdot (1 + r_s / r_a))} \\ \\ C = 1 + \frac{b' \cdot r_a}{\rho \cdot c_p} \\ \\ b' = 4 \cdot \varepsilon \cdot \sigma \cdot (273.15 + T)^3 \\ \\ r_s = actualsurfaceresistance \\ P'_s = SaturationVapourPressureSlope \\ R_n = NetRadiation \\ G = SoilHeatFlux \\ \rho = AirDensitiy \\ c_p = HeatCapacityAir \\ P_s = SaturationVapourPressure \\ P_a = ActualVapourPressure \\ r_a = AerodynamicResistance \\ H = HeatOfCondensation \\ \gamma = PsychrometricConstant \\ \varepsilon = Emissivity \\ T = AirTemperature \\ \sigma = StefanBoltzmannConstant\end{split}\]

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

Example:

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

>>> from hydpy.models.evap import *
>>> simulationstep("1d")
>>> parameterstep()
>>> nmbhru(7)
>>> emissivity(0.96)
>>> fluxes.netradiation = 10.0, 50.0, 100.0, 10.0, 10.0, 10.0, 100.0
>>> fluxes.soilheatflux = 10.0
>>> factors.saturationvapourpressure = 12.0
>>> factors.saturationvapourpressureslope = 0.8
>>> factors.actualvapourpressure = 12.0, 12.0, 12.0, 12.0, 6.0, 0.0, 0.0
>>> factors.airdensity = 1.24
>>> factors.actualsurfaceresistance = 0.0
>>> factors.aerodynamicresistance = 106.0
>>> factors.airtemperature = 10.0

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

>>> from hydpy import print_vector
>>> for hru in range(7):
...     deficit = (factors.saturationvapourpressure[hru] -
...                factors.actualvapourpressure[hru])
...     evap = model.return_evaporation_penmanmonteith_v1(
...         hru, factors.actualsurfaceresistance[hru])
...     energygain = fluxes.netradiation[hru] - fluxes.soilheatflux[hru]
...     print_vector([energygain, deficit, evap])
0.0, 0.0, 0.0
40.0, 0.0, 0.648881
90.0, 0.0, 1.459982
0.0, 0.0, 0.0
0.0, 6.0, 2.031724
0.0, 12.0, 4.063447
90.0, 12.0, 5.523429

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

>>> factors.actualsurfaceresistance = 80.0
>>> factors.aerodynamicresistance = 40.0
>>> for hru in range(7):
...     deficit = (factors.saturationvapourpressure[hru] -
...                factors.actualvapourpressure[hru])
...     evap = model.return_evaporation_penmanmonteith_v1(
...         hru, factors.actualsurfaceresistance[hru])
...     energygain = fluxes.netradiation[hru] - fluxes.soilheatflux[hru]
...     print_vector([energygain, deficit, evap])
0.0, 0.0, 0.0
40.0, 0.0, 0.364933
90.0, 0.0, 0.8211
0.0, 0.0, 0.0
0.0, 6.0, 2.469986
0.0, 12.0, 4.939972
90.0, 12.0, 5.761072

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

>>> fluxes.netradiation = 100.0
>>> factors.actualvapourpressure = 0.0
>>> factors.actualsurfaceresistance = (
...     0.0, 20.0, 50.0, 100.0, 200.0, 500.0, 1000.0)
>>> for hru in range(7):
...     print_vector([factors.actualsurfaceresistance[hru],
...                   model.return_evaporation_penmanmonteith_v1(
...                       hru, factors.actualsurfaceresistance[hru])])
0.0, 11.370311
20.0, 9.144449
50.0, 7.068767
100.0, 5.128562
200.0, 3.31099
500.0, 1.604779
1000.0, 0.863312

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

>>> factors.actualvapourpressure = 6.0
>>> factors.actualsurfaceresistance = 80.0
>>> factors.aerodynamicresistance = (0.0, 1e-6, 1e-3, 1.0, 1e3, 1e6, inf)
>>> for hru in range(7):
...     print_vector([factors.aerodynamicresistance[hru],
...                   model.return_evaporation_penmanmonteith_v1(
...                       hru, factors.actualsurfaceresistance[hru])])
0.0, 5.00683
0.000001, 5.00683
0.001, 5.006739
1.0, 4.918573
1000.0, 0.887816
1000000.0, 0.001372
inf, 0.001372

Now, we change the simulation time step from one day to one hour to demonstrate that we can reproduce the first example’s results:

>>> simulationstep("1h")
>>> fixed.heatofcondensation.restore()
>>> fluxes.netradiation = 10.0, 50.0, 100.0, 10.0, 10.0, 10.0, 100.0
>>> factors.actualvapourpressure = 12.0, 12.0, 12.0, 12.0, 6.0, 0.0, 0.0
>>> factors.actualsurfaceresistance = 0.0
>>> factors.aerodynamicresistance = 106.0
>>> for hru in range(7):
...     deficit = (factors.saturationvapourpressure[hru] -
...                factors.actualvapourpressure[hru])
...     evap = 24.0 * model.return_evaporation_penmanmonteith_v1(
...         hru, factors.actualsurfaceresistance[hru])
...     energygain = fluxes.netradiation[hru] - fluxes.soilheatflux[hru]
...     print_vector([energygain, deficit, evap])
0.0, 0.0, 0.0
40.0, 0.0, 0.648881
90.0, 0.0, 1.459982
0.0, 0.0, 0.0
0.0, 6.0, 2.031724
0.0, 12.0, 4.063447
90.0, 12.0, 5.523429
class hydpy.models.evap.evap_model.Return_Evaporation_PenmanMonteith_V2[source]

Bases: Method

Calculate the actual evapotranspiration with the Penman-Monteith equation according to Löpmeier (2014).

Required by the methods:

Calc_PotentialInterceptionEvaporation_V2 Calc_PotentialSoilEvapotranspiration_V1 Calc_WaterEvaporation_V4

Requires the fixed parameters:

HeatOfCondensation HeatCapacityAir PsychrometricConstant

Requires the factor sequences:

SaturationVapourPressureSlope SaturationVapourPressure ActualVapourPressure AirDensity AerodynamicResistance

Requires the flux sequences:

NetRadiation SoilHeatFlux

Basic equation:

\[\begin{split}f_{PM}(r_s) = \frac{P'_s \cdot (R_n - G) + \rho \cdot c_p \cdot (P_s - P_a) / r_a} {H \cdot (P'_s + \gamma \cdot (1 + r_s / r_a))} \\ \\ r_s = actualsurfaceresistance \\ P'_s = SaturationVapourPressureSlope \\ R_n = NetRadiation \\ G = SoilHeatFlux \\ \rho = AirDensitiy \\ c_p = HeatCapacityAir \\ P_s = SaturationVapourPressure \\ P_a = ActualVapourPressure \\ r_a = AerodynamicResistance \\ H = HeatOfCondensation \\ \gamma = PsychrometricConstant\end{split}\]

Example:

Method Return_Evaporation_PenmanMonteith_V2 equals method Return_Evaporation_PenmanMonteith_V1 except in neglecting the correction term C. We repeat the examples of Return_Evaporation_PenmanMonteith_V1 to demonstrate the effects of this difference:

>>> from hydpy.models.evap import *
>>> simulationstep("1d")
>>> parameterstep()
>>> nmbhru(7)
>>> fluxes.netradiation = 10.0, 50.0, 100.0, 10.0, 10.0, 10.0, 100.0
>>> fluxes.soilheatflux = 10.0
>>> factors.saturationvapourpressure = 12.0
>>> factors.saturationvapourpressureslope = 0.8
>>> factors.actualvapourpressure = 12.0, 12.0, 12.0, 12.0, 6.0, 0.0, 0.0
>>> factors.airdensity = 1.24
>>> factors.actualsurfaceresistance = 0.0
>>> factors.aerodynamicresistance = 106.0

The estimated evapotranspiration values of method Return_Evaporation_PenmanMonteith_V2 are slightly larger for the first three hydrological response units with pure energy forcing and smaller for response units four to six with pure dynamic forcing:

>>> from hydpy import print_vector
>>> for hru in range(7):
...     energygain = fluxes.netradiation[hru] - fluxes.soilheatflux[hru]
...     vapourdeficit = (factors.saturationvapourpressure[hru] -
...                      factors.actualvapourpressure[hru])
...     evap = model.return_evaporation_penmanmonteith_v2(
...         hru, factors.actualsurfaceresistance[hru])
...     print_vector([energygain, vapourdeficit, evap])
0.0, 0.0, 0.0
40.0, 0.0, 0.771689
90.0, 0.0, 1.7363
0.0, 0.0, 0.0
0.0, 6.0, 1.701082
0.0, 12.0, 3.402164
90.0, 12.0, 5.138464

This pattern stays the same using resistances suitable for vegetated surfaces:

>>> factors.actualsurfaceresistance = 80.0
>>> factors.aerodynamicresistance = 40.0
>>> for hru in range(7):
...     energygain = fluxes.netradiation[hru] - fluxes.soilheatflux[hru]
...     vapourdeficit = (factors.saturationvapourpressure[hru] -
...                      factors.actualvapourpressure[hru])
...     evap = model.return_evaporation_penmanmonteith_v2(
...         hru, factors.actualsurfaceresistance[hru])
...     print_vector([energygain, vapourdeficit, evap])
0.0, 0.0, 0.0
40.0, 0.0, 0.406078
90.0, 0.0, 0.913677
0.0, 0.0, 0.0
0.0, 6.0, 2.372133
0.0, 12.0, 4.744266
90.0, 12.0, 5.657942

The following example shows that Return_Evaporation_PenmanMonteith_V2 also restricts the aerodynamic resistance to the interval \([10^{-6}, 10^6]\) and that the missing C term prevents the estimated evapotranspiration from converging to zero with rising aerodynamic resistance:

>>> fluxes.netradiation = 100.0
>>> factors.actualvapourpressure = 6.0
>>> factors.actualsurfaceresistance = 80.0
>>> factors.aerodynamicresistance = (0.0, 1e-6, 1e-3, 1.0, 1e3, 1e6, inf)
>>> for hru in range(7):
...     print_vector([factors.aerodynamicresistance[hru],
...                   model.return_evaporation_penmanmonteith_v2(
...                       hru, factors.actualsurfaceresistance[hru])])
0.0, 5.00683
0.000001, 5.00683
0.001, 5.006739
1.0, 4.91847
1000.0, 1.849989
1000000.0, 1.736417
inf, 1.736417

Now, we change the simulation time step from one day to one hour to demonstrate that we can reproduce the first example’s results:

>>> simulationstep("1h")
>>> fixed.heatofcondensation.restore()
>>> fluxes.netradiation = 10.0, 50.0, 100.0, 10.0, 10.0, 10.0, 100.0
>>> factors.actualvapourpressure = 12.0, 12.0, 12.0, 12.0, 6.0, 0.0, 0.0
>>> factors.actualsurfaceresistance = 0.0
>>> factors.aerodynamicresistance = 106.0
>>> for hru in range(7):
...     energygain = fluxes.netradiation[hru] - fluxes.soilheatflux[hru]
...     vapourdeficit = (factors.saturationvapourpressure[hru] -
...                      factors.actualvapourpressure[hru])
...     evap = 24.0 * model.return_evaporation_penmanmonteith_v2(
...         hru, factors.actualsurfaceresistance[hru])
...     print_vector([energygain, vapourdeficit, evap])
0.0, 0.0, 0.0
40.0, 0.0, 0.771689
90.0, 0.0, 1.7363
0.0, 0.0, 0.0
0.0, 6.0, 1.701082
0.0, 12.0, 3.402164
90.0, 12.0, 5.138464
class hydpy.models.evap.evap_model.Calc_ReferenceEvapotranspiration_V1[source]

Bases: Method

Calculate the reference evapotranspiration constant according to Allen et al. (1998).

Requires the control parameter:

NmbHRU

Requires the derived parameters:

Days Hours

Requires the factor sequences:

SaturationVapourPressureSlope PsychrometricConstant AirTemperature WindSpeed2m SaturationVapourPressure ActualVapourPressure

Requires the flux sequences:

NetRadiation SoilHeatFlux

Calculates the flux sequence:

ReferenceEvapotranspiration

Basic equation (Allen et al. (1998), equation 6):

\(ReferenceEvapotranspiration = \frac{ 0.408 \cdot SaturationVapourPressureSlope \cdot (NetRadiation - SoilHeatFlux) + PsychrometricConstant \cdot \frac{37.5 \cdot Hours}{AirTemperature + 273} \cdot WindSpeed2m \cdot (SaturationVapourPressure - ActualVapourPressure) } { SaturationVapourPressureSlope + PsychrometricConstant \cdot (1 + 0.34 \cdot WindSpeed2m) }\)

Note that Allen et al. (1998) recommends the coefficient 37 for hourly simulations and 900 for daily simulations. Calc_ReferenceEvapotranspiration_V1 generally uses 37.5, which gives 900 when multiplied by 24.

Example:

The following calculation agrees with example 18 of Allen et al. (1998), dealing with a daily simulation step:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(1)
>>> derived.days(1)
>>> derived.hours(24)
>>> factors.psychrometricconstant = 0.666
>>> factors.airtemperature = 16.9
>>> factors.windspeed2m = 2.078
>>> factors.actualvapourpressure = 14.09
>>> factors.saturationvapourpressure = 19.97
>>> factors.saturationvapourpressureslope = 1.22
>>> fluxes.netradiation = 153.7037
>>> fluxes.soilheatflux = 0.0
>>> model.calc_referenceevapotranspiration_v1()
>>> fluxes.referenceevapotranspiration
referenceevapotranspiration(3.877117)

The following calculation agrees with example 19 of Allen et al. (1998), dealing with an hourly simulation step (note that there is a difference due to using 37.5 instead of 37, which is smaller than the precision of the results tabulated by Allen et al. (1998):

>>> derived.days(1/24)
>>> derived.hours(1)
>>> factors.psychrometricconstant = 0.673
>>> factors.airtemperature = 38.0
>>> factors.windspeed2m = 3.3
>>> factors.actualvapourpressure = 34.45
>>> factors.saturationvapourpressure = 66.25
>>> factors.saturationvapourpressureslope = 3.58
>>> fluxes.netradiation = 485.8333
>>> fluxes.soilheatflux = 48.6111
>>> model.calc_referenceevapotranspiration_v1()
>>> fluxes.referenceevapotranspiration
referenceevapotranspiration(0.629106)
class hydpy.models.evap.evap_model.Calc_ReferenceEvapotranspiration_V2[source]

Bases: Method

Calculate reference evapotranspiration after Turc-Wendling.

Requires the control parameters:

NmbHRU HRUAltitude CoastFactor

Requires the factor sequence:

AirTemperature

Requires the flux sequence:

GlobalRadiation

Calculates the flux sequence:

ReferenceEvapotranspiration

Basic equation:

\(ReferenceEvapotranspiration = \frac{(8.64 \cdot GlobalRadiation + 93 \cdot CoastFactor) \cdot (AirTemperature + 22)} {165 \cdot (AirTemperature + 123) \cdot (1 + 0.00019 \cdot min(Altitude, 600))}\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(3)
>>> coastfactor(0.6)
>>> hrualtitude(200.0, 600.0, 1000.0)
>>> factors.airtemperature = 15.0
>>> fluxes.globalradiation = 200.0
>>> model.calc_referenceevapotranspiration_v2()
>>> fluxes.referenceevapotranspiration
referenceevapotranspiration(2.792463, 2.601954, 2.601954)
class hydpy.models.evap.evap_model.Calc_ReferenceEvapotranspiration_V3[source]

Bases: Method

Take the input reference evapotranspiration for each hydrological response unit.

Requires the control parameter:

NmbHRU

Requires the input sequence:

ReferenceEvapotranspiration

Calculates the flux sequence:

ReferenceEvapotranspiration

Basic equation:

\(ReferenceEvapotranspiration_{fluxes} = ReferenceEvapotranspiration_{inputs}\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> inputs.referenceevapotranspiration = 2.0
>>> model.calc_referenceevapotranspiration_v3()
>>> fluxes.referenceevapotranspiration
referenceevapotranspiration(2.0, 2.0)
class hydpy.models.evap.evap_model.Calc_ReferenceEvapotranspiration_PETModel_V1[source]

Bases: Method

Let a submodel that complies with the PETModel_V1 interface calculate the reference evapotranspiration.

Required by the method:

Calc_ReferenceEvapotranspiration_V4

Requires the control parameter:

NmbHRU

Calculates the flux sequence:

ReferenceEvapotranspiration

Example:

We use evap_ret_tw2002 as an example:

>>> from hydpy.models.evap_pet_mlc import *
>>> parameterstep()
>>> nmbhru(3)
>>> hruarea(0.5, 0.3, 0.2)
>>> with model.add_retmodel_v1("evap_ret_tw2002"):
...     hrualtitude(200.0, 600.0, 1000.0)
...     coastfactor(0.6)
...     evapotranspirationfactor(1.1)
...     fluxes.globalradiation = 200.0
...     with model.add_tempmodel_v2("meteo_temp_io"):
...         temperatureaddend(1.0)
...         inputs.temperature = 14.0
>>> model.calc_referenceevapotranspiration_v4()
>>> fluxes.referenceevapotranspiration
referenceevapotranspiration(3.07171, 2.86215, 2.86215)
class hydpy.models.evap.evap_model.Calc_ReferenceEvapotranspiration_V4[source]

Bases: Method

Let a submodel that complies with the PETModel_V1 interface calculate the reference evapotranspiration.

Required submethod:

Calc_ReferenceEvapotranspiration_PETModel_V1

Requires the control parameter:

NmbHRU

Calculates the flux sequence:

ReferenceEvapotranspiration

class hydpy.models.evap.evap_model.Calc_ReferenceEvapotranspiration_V5[source]

Bases: Method

Adjust the normal evapotranspiration to the difference between actual air temperature and normal air temperature (Lindström et al., 1997).

Requires the control parameters:

NmbHRU AirTemperatureFactor

Requires the input sequences:

NormalEvapotranspiration NormalAirTemperature

Requires the factor sequence:

MeanAirTemperature

Calculates the flux sequence:

ReferenceEvapotranspiration

Basic equation:

\(ReferenceEvapotranspiration = NormalEvapotranspiration \cdot (1 + AirTemperatureFactor \cdot (MeanAirTemperature - NormalAirTemperature))\)

Restriction:

\(0 \leq ReferenceEvapotranspiration \leq 2 \cdot NormalEvapotranspiration\)

Examples:

We prepare four hydrological response units with different values for the AirTemperatureFactor (the negative value of the first unit is not meaningful but applied for illustration):

>>> from hydpy.models.evap import *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nmbhru(4)
>>> airtemperaturefactor(-0.5, 0.0, 0.1, 0.5)
>>> inputs.normalairtemperature = 20.0
>>> inputs.normalevapotranspiration = 2.0

With actual temperature equal to normal temperature, actual (uncorrected) evapotranspiration equals normal evapotranspiration:

>>> factors.meanairtemperature = 20.0
>>> model.calc_referenceevapotranspiration_v5()
>>> fluxes.referenceevapotranspiration
referenceevapotranspiration(2.0, 2.0, 2.0, 2.0)

For an actual temperature of 5 °C higher than normal, reference evapotranspiration is increased by 1 mm for the third unit. For the first unit, reference evapotranspiration is 0 mm (the smallest value allowed), and for the fourth unit, it is the doubled normal value (the largest value allowed):

>>> factors.meanairtemperature  = 25.0
>>> model.calc_referenceevapotranspiration_v5()
>>> fluxes.referenceevapotranspiration
referenceevapotranspiration(0.0, 2.0, 3.0, 4.0)
class hydpy.models.evap.evap_model.Calc_PotentialEvapotranspiration_V1[source]

Bases: Method

Calculate month-specific potential evaporation based on reference evapotranspiration.

Requires the control parameters:

NmbHRU MonthFactor

Requires the derived parameter:

MOY

Requires the flux sequence:

ReferenceEvapotranspiration

Calculates the flux sequence:

PotentialEvapotranspiration

Basic equation:

\(PotentialEvapotranspiration = MonthFactor \cdot ReferenceEvapotranspiration\)

Examples:

>>> from hydpy import pub, UnitTest
>>> pub.timegrids = '2000-03-30', '2000-04-03', '1d'
>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> monthfactor.mar = 0.5
>>> monthfactor.apr = 2.0
>>> derived.moy.update()
>>> fluxes.referenceevapotranspiration = 1.0, 2.0
>>> model.idx_sim = pub.timegrids.init['2000-03-31']
>>> model.calc_potentialevapotranspiration_v1()
>>> fluxes.potentialevapotranspiration
potentialevapotranspiration(0.5, 1.0)
>>> model.idx_sim = pub.timegrids.init['2000-04-01']
>>> model.calc_potentialevapotranspiration_v1()
>>> fluxes.potentialevapotranspiration
potentialevapotranspiration(2.0, 4.0)
class hydpy.models.evap.evap_model.Calc_PotentialEvapotranspiration_V2[source]

Bases: Method

Calculate month- and land cover-specific potential evaporation based on reference evapotranspiration.

Requires the control parameters:

NmbHRU HRUType LandMonthFactor

Requires the derived parameter:

MOY

Requires the flux sequence:

ReferenceEvapotranspiration

Calculates the flux sequence:

PotentialEvapotranspiration

Basic equation:

\(PotentialEvapotranspiration = LandMonthFactor \cdot ReferenceEvapotranspiration\)

Examples:

Base model evap does not define any land cover types by itself but takes the ones of the respective main model. Here, we manually introduce the land cover types of grass, trees, and water to apply evap as a stand-alone model:

>>> from hydpy import pub
>>> pub.timegrids = '2000-03-30', '2000-04-03', '1d'
>>> from hydpy.core.parametertools import Constants
>>> GRASS, TREES, WATER = 1, 2, 3
>>> constants = Constants(GRASS=GRASS, TREES=TREES, WATER=WATER)
>>> from hydpy.models.evap.evap_control import HRUType, LandMonthFactor
>>> with HRUType.modify_constants(constants), \
...         LandMonthFactor.modify_rows(constants):
...     from hydpy.models.evap import *
...     parameterstep()
>>> nmbhru(2)
>>> hrutype(TREES, WATER)
>>> landmonthfactor.trees_mar = 1.0
>>> landmonthfactor.trees_apr = 2.0
>>> landmonthfactor.water_mar = 0.5
>>> landmonthfactor.water_apr = 2.0
>>> derived.moy.update()
>>> fluxes.referenceevapotranspiration = 1.0, 2.0
>>> model.idx_sim = pub.timegrids.init['2000-03-31']
>>> model.calc_potentialevapotranspiration_v2()
>>> fluxes.potentialevapotranspiration
potentialevapotranspiration(1.0, 1.0)
>>> model.idx_sim = pub.timegrids.init['2000-04-01']
>>> model.calc_potentialevapotranspiration_v2()
>>> fluxes.potentialevapotranspiration
potentialevapotranspiration(2.0, 4.0)
class hydpy.models.evap.evap_model.Calc_PotentialEvapotranspiration_V3[source]

Bases: Method

Apply the altitude- and precipitation-related adjustment factors on reference evapotranspiration to determine potential evapotranspiration (Lindström et al., 1997).

Requires the control parameters:

NmbHRU AltitudeFactor HRUAltitude PrecipitationFactor

Requires the derived parameter:

Altitude

Requires the flux sequences:

ReferenceEvapotranspiration Precipitation

Calculates the flux sequence:

PotentialEvapotranspiration

Basic equation:
\[PotentialEvapotranspiration = ReferenceEvapotranspiration \cdot \left(1 + AltitudeFactor \cdot \frac{HRUAltitude - Altitude}{100} \right) \cdot exp(-PrecipitationFactor \cdot Precipitation)\]

Examples:

Three hydrological response units are at an altitude of 300 m (but the entire basin’s mean altitude is 200 m, for illustration purposes). A reference evapotranspiration value of 2 mm and a precipitation value of 5 mm are available at each unit:

>>> from hydpy.models.evap import *
>>> simulationstep("12h")
>>> parameterstep("1d")
>>> nmbhru(3)
>>> hrualtitude(300.0)
>>> fluxes.referenceevapotranspiration = 2.0
>>> fluxes.precipitation = 5.0
>>> derived.altitude(200.0)

The first two units illustrate the individual altitude-related (AltitudeFactor, first unit) and the precipitation-related adjustments (PrecipitationFactor, second unit). The third zone illustrates the interaction between both adjustments:

>>> import math
>>> altitudefactor(0.1, 0.0, 0.1)
>>> precipitationfactor(0.0, -math.log(0.7)/10.0, -math.log(0.7)/10.0)
>>> model.calc_potentialevapotranspiration_v3()
>>> fluxes.potentialevapotranspiration
potentialevapotranspiration(1.8, 1.4, 1.26)

Method Calc_PotentialEvapotranspiration_V3 performs truncations required to prevent negative potential evapotranspiration:

>>> altitudefactor(2.0)
>>> model.calc_potentialevapotranspiration_v3()
>>> fluxes.potentialevapotranspiration
potentialevapotranspiration(0.0, 0.0, 0.0)
class hydpy.models.evap.evap_model.Update_PotentialEvapotranspiration_V1[source]

Bases: Method

Damp the given potential evapotranspiration and update the corresponding log sequence.

Requires the control parameters:

NmbHRU DampingFactor

Updates the flux sequence:

PotentialEvapotranspiration

Updates the log sequence:

LoggedPotentialEvapotranspiration

Basic equation:
\[\begin{split}E_{mod, new} = \omega \cdot E_{orig, new} + (1 - \omega) \cdot E_{mod, old} \\ \\ \omega = DampingFactor \\ E = PotentialEvapotranspiration\end{split}\]

Example:

We prepare four hydrological response units with different combinations of damping factors and “old” potential evapotranspiration values:

>>> from hydpy.models.evap import *
>>> parameterstep("1d")
>>> simulationstep("12h")
>>> nmbhru(4)
>>> dampingfactor(2.0, 2.0, 0.2, 0.2)
>>> fluxes.potentialevapotranspiration = 1.6, 2.4, 1.6, 2.4

Note that the time-dependent parameter value is reduced due to the difference between the given parameter and the simulation step:

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

The evaporation value of the last simulation step is 2.0 mm:

>>> logs.loggedpotentialevapotranspiration = 2.0

For the first two hydrological response units, the “old” potential evapotranspiration is modified by -0.4 mm and +0.4 mm, respectively. For the other two response units, which weigh the “new” value with 10 %, the new value deviates from its logged counterpart only by -0.04 mm and +0.04 mm:

>>> model.update_potentialevapotranspiration_v1()
>>> fluxes.potentialevapotranspiration
potentialevapotranspiration(1.6, 2.4, 1.96, 2.04)
>>> logs.loggedpotentialevapotranspiration
loggedpotentialevapotranspiration(1.6, 2.4, 1.96, 2.04)
class hydpy.models.evap.evap_model.Adjust_ReferenceEvapotranspiration_V1[source]

Bases: Method

Adjust the previously calculated reference evapotranspiration.

Requires the control parameters:

NmbHRU EvapotranspirationFactor

Updates the flux sequence:

ReferenceEvapotranspiration

Basic equation:

\(ReferenceEvapotranspiration_{new} = EvapotranspirationFactor \cdot ReferenceEvapotranspiration_{old}\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> evapotranspirationfactor(0.5, 2.0)
>>> fluxes.referenceevapotranspiration = 2.0
>>> model.adjust_referenceevapotranspiration_v1()
>>> fluxes.referenceevapotranspiration
referenceevapotranspiration(1.0, 4.0)
class hydpy.models.evap.evap_model.Calc_MeanReferenceEvapotranspiration_V1[source]

Bases: Method

Calculate the average reference evapotranspiration.

Requires the control parameter:

NmbHRU

Requires the derived parameter:

HRUAreaFraction

Requires the flux sequence:

ReferenceEvapotranspiration

Calculates the flux sequence:

MeanReferenceEvapotranspiration

Basic equation:

\(MeanReferenceEvapotranspiration = \sum_{i=1}^{NmbHRU} HRUAreaFraction_i \cdot ReferenceEvapotranspiration_i\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> derived.hruareafraction(0.8, 0.2)
>>> fluxes.referenceevapotranspiration = 1.0, 2.0
>>> model.calc_meanreferenceevapotranspiration_v1()
>>> fluxes.meanreferenceevapotranspiration
meanreferenceevapotranspiration(1.2)
class hydpy.models.evap.evap_model.Calc_MeanPotentialEvapotranspiration_V1[source]

Bases: Method

Calculate the average potential evapotranspiration.

Requires the control parameter:

NmbHRU

Requires the derived parameter:

HRUAreaFraction

Requires the flux sequence:

PotentialEvapotranspiration

Calculates the flux sequence:

MeanPotentialEvapotranspiration

Basic equation:

\(MeanPotentialEvapotranspiration = \sum_{i=1}^{NmbHRU} HRUAreaFraction_i \cdot PotentialEvapotranspiration_i\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> derived.hruareafraction(0.8, 0.2)
>>> fluxes.potentialevapotranspiration = 1.0, 2.0
>>> model.calc_meanpotentialevapotranspiration_v1()
>>> fluxes.meanpotentialevapotranspiration
meanpotentialevapotranspiration(1.2)
class hydpy.models.evap.evap_model.Calc_PotentialWaterEvaporation_PETModel_V1[source]

Bases: Method

Query the already calculated potential evapotranspiration from a submodel that complies with the PETModel_V1 interface and assume it to be water evaporation.

Required by the method:

Calc_PotentialWaterEvaporation_V1

Requires the control parameter:

NmbHRU

Calculates the flux sequence:

PotentialWaterEvaporation

Example:

We use evap_aet_minhas and evap_ret_io as an example:

>>> from hydpy.models.evap_aet_minhas import *
>>> parameterstep()
>>> nmbhru(3)
>>> with model.add_petmodel_v1("evap_ret_io"):
...     hruarea(1.0, 3.0, 2.0)
...     fluxes.referenceevapotranspiration = 1.0, 2.0, 4.0
>>> model.calc_potentialwaterevaporation_v1()
>>> fluxes.potentialwaterevaporation
potentialwaterevaporation(1.0, 2.0, 4.0)
class hydpy.models.evap.evap_model.Calc_PotentialWaterEvaporation_PETModel_V2[source]

Bases: Method

Let a submodel that complies with the PETModel_V2 interface calculate potential water evaporation and query it.

Required by the method:

Calc_PotentialWaterEvaporation_V1

Requires the control parameter:

NmbHRU

Calculates the flux sequence:

PotentialWaterEvaporation

Example:

We use evap_aet_minhas and evap_pet_ambav1 as an example:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> from hydpy.models.evap_aet_minhas import *
>>> parameterstep()
>>> nmbhru(3)
>>> interception(False, False, True)
>>> soil(False, False, True)
>>> water(True, True, False)
>>> with model.add_petmodel_v2("evap_pet_ambav1"):
...     hrutype(0)
...     plant(False)
...     measuringheightwindspeed(10.0)
...     groundalbedo(0.2)
...     groundalbedosnow(0.8)
...     leafalbedo(0.2)
...     leafalbedosnow(0.8)
...     leafareaindex(5.0)
...     cropheight(0.0)
...     cloudtypefactor(0.2)
...     nightcloudfactor(1.0)
...     inputs.relativehumidity = 80.0
...     inputs.windspeed = 2.0
...     inputs.atmosphericpressure = 1000.0
...     factors.sunshineduration = 6.0
...     factors.possiblesunshineduration = 16.0
...     fluxes.globalradiation = 190.0
...     with model.add_tempmodel_v2("meteo_temp_io"):
...         hruarea(1.0)
...         temperatureaddend(0.0, 15.0, 0.0)
...         inputs.temperature = 15.0
...     with model.add_precipmodel_v2("meteo_precip_io"):
...         hruarea(1.0)
...         precipitationfactor(1.0)
...         inputs.precipitation = 0.0
...     with model.add_snowcovermodel_v1("dummy_snowcover"):
...         inputs.snowcover = 0.0

>>> model.petmodel.determine_potentialinterceptionevaporation()
>>> model.calc_potentialwaterevaporation_v1()
>>> fluxes.potentialwaterevaporation
potentialwaterevaporation(1.890672, 3.204855, 0.0)
class hydpy.models.evap.evap_model.Calc_PotentialWaterEvaporation_V1[source]

Bases: Method

Use a submodel that complies with the PETModel_V1 or PETModel_V2 interface to determine potential soil evapotranspiration.

Required by the methods:

Determine_WaterEvaporation_V1 Determine_WaterEvaporation_V2

Required submethods:

Calc_PotentialWaterEvaporation_PETModel_V1 Calc_PotentialWaterEvaporation_PETModel_V2

Requires the control parameter:

NmbHRU

Calculates the flux sequence:

PotentialWaterEvaporation

class hydpy.models.evap.evap_model.Calc_WaterEvaporation_V1[source]

Bases: Method

Calculate the actual evaporation from water areas according to Lindström et al. (1997).

Required by the method:

Determine_WaterEvaporation_V1

Requires the control parameters:

NmbHRU Water TemperatureThresholdIce

Requires the factor sequence:

AirTemperature

Requires the flux sequence:

PotentialWaterEvaporation

Calculates the flux sequence:

WaterEvaporation

Basic equation:
\[\begin{split}WaterEvaporation = \begin{cases} PotentialWaterEvaporation &|\ AirTemperature > TemperatureThresholdIce \\ 0 &|\ AirTemperature \leq TemperatureThresholdIce \end{cases}\end{split}\]

Example:

The occurrence of an ice layer on the water’s surface prohibits evaporation completely:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(3)
>>> water(True)
>>> temperaturethresholdice(1.0)
>>> factors.airtemperature = 0.0, 1.0, 2.0
>>> fluxes.potentialwaterevaporation = 3.0
>>> model.calc_waterevaporation_v1()
>>> fluxes.waterevaporation
waterevaporation(0.0, 0.0, 3.0)

For non-water areas, water area evaporation is generally zero:

>>> water(False)
>>> model.calc_waterevaporation_v1()
>>> fluxes.waterevaporation
waterevaporation(0.0, 0.0, 0.0)
class hydpy.models.evap.evap_model.Calc_WaterEvaporation_V2[source]

Bases: Method

Accept potential evaporation from water areas as the actual one.

Required by the method:

Determine_WaterEvaporation_V2

Requires the control parameters:

NmbHRU Water

Requires the flux sequence:

PotentialWaterEvaporation

Calculates the flux sequence:

WaterEvaporation

Basic equation:

\(WaterEvaporation = PotentialWaterEvaporation\)

Example:

For non-water areas, water area evaporation is generally zero:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> water(True, False)
>>> fluxes.potentialwaterevaporation = 3.0
>>> model.calc_waterevaporation_v2()
>>> fluxes.waterevaporation
waterevaporation(3.0, 0.0)
class hydpy.models.evap.evap_model.Calc_WaterEvaporation_V3[source]

Bases: Method

Calculate the actual evaporation from water areas with the Penman equation according to LEG (2020), based on DVWK (1996).

Required by the method:

Determine_WaterEvaporation_V3

Requires the control parameters:

NmbHRU Water

Requires the derived parameter:

Days

Requires the fixed parameters:

HeatOfCondensation PsychrometricConstant

Requires the factor sequences:

DailySaturationVapourPressure DailySaturationVapourPressureSlope DailyActualVapourPressure DailyWindSpeed2m

Requires the flux sequence:

DailyNetRadiation

Calculates the flux sequence:

WaterEvaporation

Basic equation:
\[\begin{split}WaterEvaporation = \frac{P'_s\cdot R_n / H + Days \cdot \gamma\cdot (0.13 + 0.094 \cdot v) \cdot (P_s- P_a)} {P'_s+ \gamma} \\ \\ P'_s = DailySaturationVapourPressureSlope \\ R_n = DailyNetRadiation \\ H = HeatOfCondensation \\ \gamma = PsychrometricConstant \\ v = DailyWindSpeed2m \\ P_s = DailySaturationVapourPressure \\ P_a = DailyActualVapourPressure\end{split}\]

Examples:

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

>>> from hydpy.models.evap import *
>>> simulationstep("1d")
>>> parameterstep()
>>> nmbhru(7)
>>> water(True)
>>> derived.days.update()
>>> fluxes.dailynetradiation = 0.0, 50.0, 100.0, 0.0, 0.0, 0.0, 100.0
>>> factors.dailywindspeed2m = 2.0
>>> factors.dailysaturationvapourpressure = 12.0
>>> factors.dailysaturationvapourpressureslope = 0.8
>>> factors.dailyactualvapourpressure = 12.0, 12.0, 12.0, 12.0, 6.0, 0.0, 0.0
>>> model.calc_waterevaporation_v3()
>>> fluxes.waterevaporation
waterevaporation(0.0, 0.964611, 1.929222, 0.0, 0.858928, 1.717856,
                 3.647077)

The above results apply to a daily simulation time step. The following example demonstrates that Calc_WaterEvaporation_V3 calculates equivalent results for hourly time steps:

>>> simulationstep("1h")
>>> derived.days.update()
>>> fixed.heatofcondensation.restore()
>>> model.calc_waterevaporation_v3()
>>> fluxes.waterevaporation *= 24.0
>>> fluxes.waterevaporation
waterevaporation(0.0, 0.964611, 1.929222, 0.0, 0.858928, 1.717856,
                 3.647077)
class hydpy.models.evap.evap_model.Calc_WaterEvaporation_V4[source]

Bases: Method

Calculate the evaporation from water areas by applying the Penman-Monteith equation with zero surface resistance.

Required submethod:

Return_Evaporation_PenmanMonteith_V2

Requires the control parameters:

NmbHRU Water

Requires the fixed parameters:

HeatOfCondensation HeatCapacityAir PsychrometricConstant

Requires the factor sequences:

SaturationVapourPressureSlope SaturationVapourPressure ActualVapourPressure AirDensity AerodynamicResistance

Requires the flux sequences:

NetRadiation SoilHeatFlux

Calculates the flux sequence:

WaterEvaporation

Basic equation:
\[\begin{split}WaterEvaporation = \begin{cases} f_{PM}(0.0) &|\ Water \\ 0 &|\ \overline{Water} \end{cases}\end{split}\]

Examples:

Usually, one would not consider soil heat fluxes when calculating evaporation from water areas. However, Calc_WaterEvaporation_V4 takes SoilHeatFlux into account, so it should usually be set to zero beforehand. Due to considering it, the following results agree with the first example on method Calc_PotentialInterceptionEvaporation_V2:

>>> from hydpy.models.evap import *
>>> simulationstep("1d")
>>> parameterstep()
>>> nmbhru(7)
>>> water(True)
>>> factors.saturationvapourpressure = 12.0
>>> factors.saturationvapourpressureslope = 0.8
>>> factors.actualvapourpressure = 12.0, 12.0, 12.0, 12.0, 6.0, 0.0, 0.0
>>> factors.airdensity = 1.24
>>> factors.aerodynamicresistance = 106.0
>>> fluxes.netradiation = 10.0, 50.0, 100.0, 10.0, 10.0, 10.0, 100.0
>>> fluxes.soilheatflux = 10.0
>>> model.calc_waterevaporation_v4()
>>> fluxes.waterevaporation
waterevaporation(0.0, 0.771689, 1.7363, 0.0, 1.701082, 3.402164,
                 5.138464)

Water evaporation is always zero for hydrological response units dealing with non-water areas:

>>> water(False)
>>> model.calc_waterevaporation_v4()
>>> fluxes.waterevaporation
waterevaporation(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
class hydpy.models.evap.evap_model.Update_LoggedWaterEvaporation_V1[source]

Bases: Method

Log the water evaporation values of the last 24 hours.

Requires the control parameter:

NmbHRU

Requires the derived parameter:

NmbLogEntries

Requires the flux sequence:

WaterEvaporation

Updates the log sequence:

LoggedWaterEvaporation

Example:

The following example shows that each new method call successively moves the six memorised values to the right and stores the respective two new values on the leftmost position:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> derived.nmblogentries(3)
>>> logs.loggedwaterevaporation.shape = 3, 2
>>> logs.loggedwaterevaporation = 0.0, 0.0
>>> from hydpy import UnitTest
>>> test = UnitTest(model,
...                 model.update_loggedwaterevaporation_v1,
...                 last_example=4,
...                 parseqs=(fluxes.waterevaporation,
...                          logs.loggedwaterevaporation))
>>> test.nexts.waterevaporation = [1.0, 2.0], [3.0, 6.0], [2.0, 4.0], [4.0, 8.0]
>>> del test.inits.loggedwaterevaporation
>>> test()
| ex. |      waterevaporation |                          loggedwaterevaporation |
---------------------------------------------------------------------------------
|   1 | 1.0               2.0 | 1.0  2.0  0.0  0.0  0.0                     0.0 |
|   2 | 3.0               6.0 | 3.0  6.0  1.0  2.0  0.0                     0.0 |
|   3 | 2.0               4.0 | 2.0  4.0  3.0  6.0  1.0                     2.0 |
|   4 | 4.0               8.0 | 4.0  8.0  2.0  4.0  3.0                     6.0 |
class hydpy.models.evap.evap_model.Calc_DailyWaterEvaporation_V1[source]

Bases: Method

Calculate the water evaporation sum of the last 24 hours.

Requires the control parameter:

NmbHRU

Requires the derived parameter:

NmbLogEntries

Requires the log sequence:

LoggedWaterEvaporation

Calculates the flux sequence:

DailyWaterEvaporation

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> derived.nmblogentries(3)
>>> logs.loggedwaterevaporation.shape = 3, 2
>>> logs.loggedwaterevaporation = [[1.0, 2.0], [5.0, 6.0], [3.0, 4.0]]
>>> model.calc_dailywaterevaporation_v1()
>>> fluxes.dailywaterevaporation
dailywaterevaporation(9.0, 12.0)
class hydpy.models.evap.evap_model.Calc_InterceptionEvaporation_V1[source]

Bases: Method

Calculate the actual interception evaporation by setting it equal to potential evapotranspiration.

Required by the method:

Determine_InterceptionEvaporation_V1

Requires the control parameters:

NmbHRU Interception

Requires the factor sequence:

InterceptedWater

Requires the flux sequence:

PotentialInterceptionEvaporation

Calculates the flux sequence:

InterceptionEvaporation

Basic equation:
\[\begin{split}InterceptionEvaporation = \begin{cases} PotentialInterceptionEvaporation &|\ InterceptedWater > 0 \\ 0 &|\ InterceptedWater = 0 \end{cases}\end{split}\]

Examples:

The availability of intercepted water may restrict the possible interception evaporation:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(4)
>>> interception(True)
>>> fluxes.potentialinterceptionevaporation(1.0)
>>> factors.interceptedwater(1.5, 1.0, 0.5, 0.0)
>>> model.calc_interceptionevaporation_v1()
>>> fluxes.interceptionevaporation
interceptionevaporation(1.0, 1.0, 0.5, 0.0)

Interception evaporation is always zero for hydrological response units not considering interception:

>>> interception(False)
>>> model.calc_interceptionevaporation_v1()
>>> fluxes.interceptionevaporation
interceptionevaporation(0.0, 0.0, 0.0, 0.0)
class hydpy.models.evap.evap_model.Calc_PotentialInterceptionEvaporation_V1[source]

Bases: Method

Calculate the potential interception evaporation using an extended Penman-Monteith equation with zero surface resistance.

Required by the method:

Determine_InterceptionEvaporation_V2

Required submethod:

Return_Evaporation_PenmanMonteith_V1

Requires the control parameters:

NmbHRU Interception Emissivity

Requires the fixed parameters:

StefanBoltzmannConstant HeatOfCondensation HeatCapacityAir PsychrometricConstant

Requires the factor sequences:

AirTemperature SaturationVapourPressureSlope SaturationVapourPressure ActualVapourPressure AirDensity AerodynamicResistance

Requires the flux sequences:

NetRadiation SoilHeatFlux

Calculates the flux sequence:

PotentialInterceptionEvaporation

Basic equation:
\[\begin{split}PotentialInterceptionEvaporation = \begin{cases} f_{PM}(0.0) &|\ Interception \\ 0 &|\ \overline{Interception} \end{cases}\end{split}\]

Examples:

The following settings agree with the first example on method Return_Evaporation_PenmanMonteith_V1:

>>> from hydpy.models.evap import *
>>> simulationstep("1d")
>>> parameterstep()
>>> nmbhru(7)
>>> interception(True)
>>> emissivity(0.96)
>>> factors.saturationvapourpressure = 12.0
>>> factors.saturationvapourpressureslope = 0.8
>>> factors.actualvapourpressure = 12.0, 12.0, 12.0, 12.0, 6.0, 0.0, 0.0
>>> factors.airdensity = 1.24
>>> factors.aerodynamicresistance = 106.0
>>> factors.airtemperature = 10.0
>>> fluxes.netradiation = 10.0, 50.0, 100.0, 10.0, 10.0, 10.0, 100.0
>>> fluxes.soilheatflux = 10.0
>>> model.calc_potentialinterceptionevaporation_v1()
>>> fluxes.potentialinterceptionevaporation
potentialinterceptionevaporation(0.0, 0.648881, 1.459982, 0.0, 2.031724,
                                 4.063447, 5.523429)

Interception evaporation is always zero for hydrological response units not considering interception:

>>> interception(False)
>>> model.calc_potentialinterceptionevaporation_v1()
>>> fluxes.potentialinterceptionevaporation
potentialinterceptionevaporation(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
class hydpy.models.evap.evap_model.Calc_PotentialInterceptionEvaporation_V2[source]

Bases: Method

Calculate the potential interception evaporation by applying the Penman-Monteith equation with zero surface resistance.

Required by the method:

Determine_PotentialInterceptionEvaporation_V1

Required submethod:

Return_Evaporation_PenmanMonteith_V2

Requires the control parameters:

NmbHRU Interception

Requires the fixed parameters:

HeatOfCondensation HeatCapacityAir PsychrometricConstant

Requires the factor sequences:

SaturationVapourPressureSlope SaturationVapourPressure ActualVapourPressure AirDensity AerodynamicResistance

Requires the flux sequences:

NetRadiation SoilHeatFlux

Calculates the flux sequence:

PotentialInterceptionEvaporation

Basic equation:
\[\begin{split}PotentialInterceptionEvaporation = \begin{cases} f_{PM}(0.0) &|\ Interception \\ 0 &|\ \overline{Interception} \end{cases}\end{split}\]

Examples:

The following settings agree with the first example on method Return_Evaporation_PenmanMonteith_V2:

>>> from hydpy.models.evap import *
>>> simulationstep("1d")
>>> parameterstep()
>>> nmbhru(7)
>>> interception(True)
>>> factors.saturationvapourpressure = 12.0
>>> factors.saturationvapourpressureslope = 0.8
>>> factors.actualvapourpressure = 12.0, 12.0, 12.0, 12.0, 6.0, 0.0, 0.0
>>> factors.airdensity = 1.24
>>> factors.aerodynamicresistance = 106.0
>>> fluxes.netradiation = 10.0, 50.0, 100.0, 10.0, 10.0, 10.0, 100.0
>>> fluxes.soilheatflux = 10.0
>>> model.calc_potentialinterceptionevaporation_v2()
>>> fluxes.potentialinterceptionevaporation
potentialinterceptionevaporation(0.0, 0.771689, 1.7363, 0.0, 1.701082,
                                 3.402164, 5.138464)

Interception evaporation is always zero for hydrological response units not considering interception:

>>> interception(False)
>>> model.calc_potentialinterceptionevaporation_v1()
>>> fluxes.potentialinterceptionevaporation
potentialinterceptionevaporation(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
class hydpy.models.evap.evap_model.Calc_PotentialInterceptionEvaporation_PETModel_V1[source]

Bases: Method

Let a submodel that complies with the PETModel_V1 interface calculate potential evapotranspiration and assume it as potential interception evaporation.

Required by the method:

Calc_PotentialInterceptionEvaporation_V3

Requires the control parameter:

NmbHRU

Calculates the flux sequence:

PotentialInterceptionEvaporation

Example:

We use evap_aet_minhas and evap_ret_io as an example:

>>> from hydpy.models.evap_aet_minhas import *
>>> parameterstep()
>>> nmbhru(3)
>>> with model.add_petmodel_v1("evap_ret_io"):
...     hruarea(1.0, 3.0, 2.0)
...     evapotranspirationfactor(0.5, 1.0, 2.0)
...     inputs.referenceevapotranspiration = 2.0
>>> model.calc_potentialinterceptionevaporation_v3()
>>> fluxes.potentialinterceptionevaporation
potentialinterceptionevaporation(1.0, 2.0, 4.0)
class hydpy.models.evap.evap_model.Calc_PotentialInterceptionEvaporation_PETModel_V2[source]

Bases: Method

Let a submodel that complies with the PETModel_V2 interface calculate potential interception evaporation and query it.

Required by the method:

Calc_PotentialInterceptionEvaporation_V3

Requires the control parameter:

NmbHRU

Calculates the flux sequence:

PotentialInterceptionEvaporation

Example:

We use evap_aet_minhas and evap_pet_ambav1 as an example:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> from hydpy.models.evap_aet_minhas import *
>>> parameterstep()
>>> nmbhru(3)
>>> interception(False, True, True)
>>> soil(False, True, True)
>>> water(True, False, False)
>>> with model.add_petmodel_v2("evap_pet_ambav1"):
...     hrutype(0)
...     plant(True)
...     measuringheightwindspeed(10.0)
...     groundalbedo(0.2)
...     groundalbedosnow(0.8)
...     leafalbedo(0.2)
...     leafalbedosnow(0.8)
...     leafareaindex(5.0)
...     cropheight(10.0)
...     cloudtypefactor(0.2)
...     nightcloudfactor(1.0)
...     inputs.relativehumidity = 80.0
...     inputs.windspeed = 2.0
...     inputs.atmosphericpressure = 1000.0
...     factors.sunshineduration = 6.0
...     factors.possiblesunshineduration = 16.0
...     fluxes.globalradiation = 190.0
...     with model.add_tempmodel_v2("meteo_temp_io"):
...         hruarea(1.0)
...         temperatureaddend(0.0)
...         inputs.temperature = 15.0
...     with model.add_precipmodel_v2("meteo_precip_io"):
...         hruarea(1.0)
...         precipitationfactor(1.0)
...         inputs.precipitation = 0.0
...     with model.add_snowcovermodel_v1("dummy_snowcover"):
...         inputs.snowcover = 0.0, 0.0, 1.0
>>> model.calc_potentialinterceptionevaporation_v3()
>>> fluxes.potentialinterceptionevaporation
potentialinterceptionevaporation(0.0, 3.301949, 1.146759)
class hydpy.models.evap.evap_model.Calc_PotentialInterceptionEvaporation_V3[source]

Bases: Method

Use a submodel that complies with the PETModel_V1 or PETModel_V2 interface to determine evaporation from water areas.

Required by the method:

Determine_InterceptionEvaporation_V1

Required submethods:

Calc_PotentialInterceptionEvaporation_PETModel_V1 Calc_PotentialInterceptionEvaporation_PETModel_V2

Requires the control parameter:

NmbHRU

Calculates the flux sequence:

PotentialInterceptionEvaporation

class hydpy.models.evap.evap_model.Calc_InterceptionEvaporation_V2[source]

Bases: Method

Calculate the actual interception evaporation by setting it equal to potential interception evaporation.

Required by the method:

Determine_InterceptionEvaporation_V2

Requires the control parameters:

NmbHRU Interception Tree

Requires the factor sequences:

InterceptedWater SnowCover SnowyCanopy

Requires the flux sequence:

PotentialInterceptionEvaporation

Calculates the flux sequence:

InterceptionEvaporation

Basic equation:
\[\begin{split}InterceptionEvaporation = \begin{cases} min(PotentialInterceptionEvaporation, \ InterceptedWater) &|\ Interception \land ( Tree \lor SnowCover = 0 ) \\ 0 &|\ \overline{Interception} \lor ( \overline{Tree} \land SnowCover > 0 ) \end{cases}\end{split}\]

Examples:

We prepare two hydrological response units. The first one is tree-like, while the second one is not:

>>> from hydpy.models.evap import *
>>> simulationstep("1d")
>>> parameterstep()
>>> nmbhru(2)
>>> interception(True)
>>> tree(True, False)
>>> factors.interceptedwater = 1.0
>>> fluxes.potentialinterceptionevaporation = 1.0

Without any snow cover, the vegetation type does not make a difference:

>>> factors.snowcover = 0.0
>>> factors.snowycanopy = 0.0, nan
>>> model.calc_interceptionevaporation_v2()
>>> fluxes.interceptionevaporation
interceptionevaporation(1.0, 1.0)

For tree-like vegetation, a snow layer (on the ground) does not affect interception evaporation. For other vegetation types, even incomplete covering suppresses interception evaporation completely:

>>> factors.snowcover = 0.1
>>> model.calc_interceptionevaporation_v2()
>>> fluxes.interceptionevaporation
interceptionevaporation(1.0, 0.0)

For tree-like vegetation, snow interception (in the canopy) suppresses interception evaporation completely:

>>> factors.snowcover = 0.0
>>> factors.snowycanopy = 1.0
>>> model.calc_interceptionevaporation_v2()
>>> fluxes.interceptionevaporation
interceptionevaporation(0.0, 1.0)

The availability of intercepted water may restrict the possible interception evaporation:

>>> factors.snowycanopy = 0.0
>>> factors.interceptedwater = 0.5, 0.0
>>> model.calc_interceptionevaporation_v2()
>>> fluxes.interceptionevaporation
interceptionevaporation(0.5, 0.0)

Interception evaporation is always zero for hydrological response units not considering interception:

>>> interception(False)
>>> model.calc_interceptionevaporation_v2()
>>> fluxes.interceptionevaporation
interceptionevaporation(0.0, 0.0)
class hydpy.models.evap.evap_model.Calc_PotentialSoilEvapotranspiration_V1[source]

Bases: Method

Calculate the potential evapotranspiration from the soil by applying the Penman-Monteith equation with an actual surface resistance that does not consider the current soil moisture.

Required submethod:

Return_Evaporation_PenmanMonteith_V2

Requires the control parameters:

NmbHRU Soil

Requires the fixed parameters:

HeatOfCondensation HeatCapacityAir PsychrometricConstant

Requires the factor sequences:

SaturationVapourPressureSlope SaturationVapourPressure ActualVapourPressure AirDensity AerodynamicResistance ActualSurfaceResistance

Requires the flux sequences:

NetRadiation SoilHeatFlux

Calculates the flux sequence:

PotentialSoilEvapotranspiration

Basic equation:
\[\begin{split}PotentialSoilEvapotranspiration = \begin{cases} f_{PM}(ActualSurfaceResistance) &|\ Soil \\ 0 &|\ \overline{Soil} \end{cases}\end{split}\]

Examples:

We prepare two hydrological response units, of which only the first one’s soil is accessible for evapotranspiration losses. The other settings agree with the last response unit in the second example on method Return_Evaporation_PenmanMonteith_V2:

>>> from hydpy.models.evap import *
>>> simulationstep("1d")
>>> parameterstep()
>>> nmbhru(2)
>>> soil(True, False)
>>> factors.saturationvapourpressure = 12.0
>>> factors.saturationvapourpressureslope = 0.8
>>> factors.actualvapourpressure = 0.0
>>> factors.airdensity = 1.24
>>> factors.aerodynamicresistance = 40.0
>>> factors.actualsurfaceresistance = 80.0
>>> fluxes.netradiation = 100.0
>>> fluxes.soilheatflux = 10.0

The determined potential evapotranspiration value for the first response unit agrees with the corresponding Return_Evaporation_PenmanMonteith_V2 example. For the soil-free unit, it is zero:

>>> model.calc_potentialsoilevapotranspiration_v1()
>>> fluxes.potentialsoilevapotranspiration
potentialsoilevapotranspiration(5.657942, 0.0)
class hydpy.models.evap.evap_model.Calc_PotentialSoilEvapotranspiration_PETModel_V1[source]

Bases: Method

Query the already calculated potential evapotranspiration from a submodel that complies with the PETModel_V1 interface and assume it as potential soil evapotranspiration.

Required by the method:

Calc_PotentialSoilEvapotranspiration_V2

Requires the control parameter:

NmbHRU

Calculates the flux sequence:

PotentialSoilEvapotranspiration

Example:

We use evap_aet_minhas and evap_ret_io as an example:

>>> from hydpy.models.evap_aet_minhas import *
>>> parameterstep()
>>> nmbhru(3)
>>> with model.add_petmodel_v1("evap_ret_io"):
...     hruarea(1.0, 3.0, 2.0)
...     fluxes.referenceevapotranspiration = 1.0, 2.0, 4.0
>>> model.calc_potentialsoilevapotranspiration_v2()
>>> fluxes.potentialsoilevapotranspiration
potentialsoilevapotranspiration(1.0, 2.0, 4.0)
class hydpy.models.evap.evap_model.Calc_PotentialSoilEvapotranspiration_PETModel_V2[source]

Bases: Method

Let a submodel that complies with the PETModel_V2 interface calculate potential soil evapotranspiration and query it.

Required by the method:

Calc_PotentialSoilEvapotranspiration_V2

Requires the control parameter:

NmbHRU

Calculates the flux sequence:

PotentialSoilEvapotranspiration

Example:

We use evap_aet_minhas and evap_pet_ambav1 as an example:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> from hydpy.models.evap_aet_minhas import *
>>> parameterstep()
>>> nmbhru(3)
>>> interception(False, True, True)
>>> soil(False, True, True)
>>> water(True, False, False)
>>> with model.add_petmodel_v2("evap_pet_ambav1"):
...     hrutype(0)
...     plant(True)
...     measuringheightwindspeed(10.0)
...     leafalbedo(0.2)
...     leafalbedosnow(0.8)
...     groundalbedo(0.2)
...     groundalbedosnow(0.8)
...     leafareaindex(5.0)
...     cropheight(10.0)
...     leafresistance(40.0)
...     wetsoilresistance(100.0)
...     soilresistanceincrease(1.0)
...     wetnessthreshold(0.5)
...     cloudtypefactor(0.2)
...     nightcloudfactor(1.0)
...     inputs.relativehumidity = 80.0
...     inputs.windspeed = 2.0
...     inputs.atmosphericpressure = 1000.0
...     factors.sunshineduration = 6.0
...     factors.possiblesunshineduration = 16.0
...     fluxes.globalradiation = 190.0
...     with model.add_tempmodel_v2("meteo_temp_io"):
...         hruarea(1.0)
...         temperatureaddend(0.0)
...         inputs.temperature = 15.0
...     with model.add_precipmodel_v2("meteo_precip_io"):
...         hruarea(1.0)
...         precipitationfactor(1.0)
...         inputs.precipitation = 0.0
...     with model.add_snowcovermodel_v1("dummy_snowcover"):
...         inputs.snowcover = 0.0, 0.0, 1.0
>>> model.petmodel.determine_potentialinterceptionevaporation()
>>> model.calc_potentialsoilevapotranspiration_v2()
>>> fluxes.potentialsoilevapotranspiration
potentialsoilevapotranspiration(0.0, 2.324763, 0.807385)
class hydpy.models.evap.evap_model.Calc_PotentialSoilEvapotranspiration_V2[source]

Bases: Method

Use a submodel that complies with the PETModel_V1 or PETModel_V2 interface to determine potential soil evapotranspiration.

Required by the methods:

Determine_SoilEvapotranspiration_V1 Determine_SoilEvapotranspiration_V2

Required submethods:

Calc_PotentialSoilEvapotranspiration_PETModel_V1 Calc_PotentialSoilEvapotranspiration_PETModel_V2

Requires the control parameter:

NmbHRU

Calculates the flux sequence:

PotentialSoilEvapotranspiration

class hydpy.models.evap.evap_model.Calc_SoilEvapotranspiration_V1[source]

Bases: Method

Calculate the actual soil evapotranspiration according to Lindström et al. (1997).

Required by the method:

Determine_SoilEvapotranspiration_V1

Requires the control parameters:

NmbHRU Soil MaxSoilWater SoilMoistureLimit

Requires the factor sequence:

SoilWater

Requires the flux sequence:

PotentialSoilEvapotranspiration

Calculates the flux sequence:

SoilEvapotranspiration

Basic equation:
\[\begin{split}et_s = pet_s \cdot \frac{s}{l \cdot m} \\ \\ et_s = SoilEvapotranspiration \\ pet_s = PotentialSoilEvapotranspiration \\ s = SoilWater \\ l = SoilMoistureLimit \\ m = MaxSoilWater\end{split}\]

Examples:

We initialise seven hydrological response units with different soil water contents, including two that fall below and above the lowest and highest possible soil moisture, respectively, to show that Calc_SoilEvapotranspiration_V1 works stably in case of eventual numerical errors:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(7)
>>> soil(True)
>>> maxsoilwater(200.0)
>>> soilmoisturelimit(0.5)
>>> fluxes.potentialsoilevapotranspiration = 2.0
>>> factors.soilwater = -1.0, 0.0, 50.0, 100.0, 150.0, 200.0, 201.0
>>> model.calc_soilevapotranspiration_v1()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(0.0, 0.0, 1.0, 2.0, 2.0, 2.0, 2.0)

When setting SoilMoistureLimit to zero, Calc_SoilEvapotranspiration_V1 sets actual soil evapotranspiration equal to possible soil evapotranspiration, except for negative soil moisture:

>>> soilmoisturelimit(0.0)
>>> model.calc_soilevapotranspiration_v1()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(0.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0)

Setting SoilMoistureLimit to one does not result in any explanatory behaviour:

>>> soilmoisturelimit(1.0)
>>> model.calc_soilevapotranspiration_v1()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(0.0, 0.0, 0.5, 1.0, 1.5, 2.0, 2.0)

Condensation does not depend on actual soil moisture. Hence, Calc_SoilEvapotranspiration_V1 generally sets actual soil evapotranspiration equal to potential soil evapotranspiration if negative:

>>> soilmoisturelimit(0.5)
>>> fluxes.potentialsoilevapotranspiration = -1.0
>>> model.calc_soilevapotranspiration_v1()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0)

For non-soil units, soil evapotranspiration is generally zero:

>>> soil(False)
>>> fluxes.potentialevapotranspiration = 2.0
>>> model.calc_soilevapotranspiration_v1()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
class hydpy.models.evap.evap_model.Calc_SoilEvapotranspiration_V2[source]

Bases: Method

Calculate the actual soil evapotranspiration according to Minhas et al. (1974).

Required by the method:

Determine_SoilEvapotranspiration_V2

Requires the control parameters:

NmbHRU Soil MaxSoilWater DisseFactor

Requires the factor sequence:

SoilWater

Requires the flux sequence:

PotentialSoilEvapotranspiration

Calculates the flux sequence:

SoilEvapotranspiration

The applied equation deviates from the original by using the formulation of Disse (1995), which is mathematically identical but simpler to parameterise and does not explicitly account for the permanent wilting point.

Basic equation:
\[\begin{split}et_s = pet_s \cdot \frac {1 - exp\left(-f\cdot \frac{w}{m } \right)} {1 + exp\left(-f\cdot \frac{w}{m } \right) - 2 \cdot exp(-f)} \\ \\ et_s = SoilEvapotranspiration \\ pet_s = PotentialSoilEvapotranspiration \\ f = DisseFactor \\ w = SoilWater \\ m = MaxSoilWater\end{split}\]

Examples:

We initialise five hydrological response units with different soil water contents, including two that fall below and above the lowest and highest possible soil moisture, respectively, to show that Calc_SoilEvapotranspiration_V2 works stably in case of eventual numerical errors:

>>> from hydpy.models.evap import *
>>> parameterstep("1d")
>>> nmbhru(5)
>>> soil(True)
>>> dissefactor(5.0)
>>> maxsoilwater(100.0)
>>> fluxes.potentialsoilevapotranspiration = 2.0
>>> factors.soilwater = -1.0, 0.0, 50.0, 100.0, 101.0
>>> model.calc_soilevapotranspiration_v2()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(0.0, 0.0, 1.717962, 2.0, 2.0)

Condensation does not depend on actual soil moisture. Hence, Calc_SoilEvapotranspiration_V2 generally sets actual soil evapotranspiration equal to potential soil evapotranspiration if negative:

>>> fluxes.potentialsoilevapotranspiration = -2.0
>>> model.calc_soilevapotranspiration_v2()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(-2.0, -2.0, -2.0, -2.0, -2.0)

For non-soil units, soil evapotranspiration is always zero:

>>> soil(False)
>>> model.calc_soilevapotranspiration_v2()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(0.0, 0.0, 0.0, 0.0, 0.0)
class hydpy.models.evap.evap_model.Calc_SoilEvapotranspiration_V3[source]

Bases: Method

Calculate the evapotranspiration from the soil by applying the Penman-Monteith equation with an actual surface resistance considering the current soil moisture.

Required by the method:

Determine_SoilEvapotranspiration_V3

Required submethod:

Return_Evaporation_PenmanMonteith_V1

Requires the control parameters:

NmbHRU Soil Tree Emissivity

Requires the fixed parameters:

StefanBoltzmannConstant HeatOfCondensation HeatCapacityAir PsychrometricConstant

Requires the factor sequences:

SnowCover AirTemperature SaturationVapourPressureSlope SaturationVapourPressure ActualVapourPressure AirDensity AerodynamicResistance ActualSurfaceResistance

Requires the flux sequences:

NetRadiation SoilHeatFlux

Calculates the flux sequence:

SoilEvapotranspiration

Basic equation:
\[\begin{split}SoilEvapotranspiration = \begin{cases} f_{PM}(ActualSurfaceResistance) &|\ Soil \land (Tree \lor SnowCover = 0 ) \\ 0 &|\ \overline{Soil } \lor ( \overline{Tree} \land SnowCover > 0 ) \end{cases}\end{split}\]

Examples:

We prepare two hydrological response units. The first one is tree-like, while the second one is not. The other settings agree with the last response unit in the second example on method Return_Evaporation_PenmanMonteith_V1:

>>> from hydpy.models.evap import *
>>> simulationstep("1d")
>>> parameterstep()
>>> nmbhru(2)
>>> soil(True)
>>> tree(True, False)
>>> emissivity(0.96)
>>> factors.saturationvapourpressure = 12.0
>>> factors.saturationvapourpressureslope = 0.8
>>> factors.actualvapourpressure = 0.0
>>> factors.airdensity = 1.24
>>> factors.aerodynamicresistance = 40.0
>>> factors.actualsurfaceresistance = 80.0
>>> factors.airtemperature = 10.0
>>> fluxes.netradiation = 100.0
>>> fluxes.soilheatflux = 10.0

Without any snow cover, the vegetation type does not make a difference:

>>> factors.snowcover(0.0)
>>> model.calc_soilevapotranspiration_v3()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(5.761072, 5.761072)

For tree-like vegetation, a snow layer (on the ground) does not affect soil evapotranspiration. For other vegetation types, even incomplete covering suppresses interception evaporation completely:

>>> factors.snowcover(0.1)
>>> model.calc_soilevapotranspiration_v3()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(5.761072, 0.0)

Soil evapotranspiration is always zero for soil-less hydrological response units:

>>> soil(False)
>>> model.calc_soilevapotranspiration_v3()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(0.0, 0.0)
class hydpy.models.evap.evap_model.Update_SoilEvapotranspiration_V1[source]

Bases: Method

Reduce actual soil evapotranspiration if the sum of interception evaporation and soil evapotranspiration exceeds potential evapotranspiration, according to Lindström et al. (1997).

Required by the method:

Determine_SoilEvapotranspiration_V1

Requires the control parameters:

NmbHRU Soil ExcessReduction

Requires the flux sequences:

PotentialInterceptionEvaporation PotentialSoilEvapotranspiration InterceptionEvaporation

Updates the flux sequence:

SoilEvapotranspiration

Lindström et al. (1997) does not distinguish between potential interception evaporation and potential soil evapotranspiration. Hence, the following equation is generalised to deal with situations where both terms are unequal. See issue 118 for further information.

Basic equation:
\[\begin{split}et_s^{new} = et_s^{old} - r \cdot \Big( et_s^{old} + e_i - \big(r \cdot pe_i + (1 - r) \cdot (pet_s + pe_i) / 2 \big) \Big) \\ \\ et_s = SoilEvapotranspiration \\ r = ExcessReduction \\ e_i = InterceptionEvaporation \\ pet = PotentialEvapotranspiration\end{split}\]

Examples:

We initialise six hydrological response units with different unmodified soil evapotranspiration values, including a negative one (condensation). When setting ExcessReduction to one, Update_SoilEvapotranspiration_V1 does not allow the sum of interception evaporation and soil evapotranspiration to exceed potential interception evaporation:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(6)
>>> soil(True)
>>> excessreduction(1.0)
>>> fluxes.potentialinterceptionevaporation = 2.0
>>> fluxes.potentialsoilevapotranspiration = 1.5
>>> fluxes.interceptionevaporation = 1.0
>>> fluxes.soilevapotranspiration = -0.5, 0.0, 0.5, 1.0, 1.5, 2.0
>>> model.update_soilevapotranspiration_v1()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(-0.5, 0.0, 0.5, 1.0, 1.0, 1.0)

When setting ExcessReduction to one, Update_SoilEvapotranspiration_V1 does not reduce any exceedances:

>>> excessreduction(0.0)
>>> fluxes.soilevapotranspiration = -0.5, 0.0, 0.5, 1.0, 1.5, 2.0
>>> model.update_soilevapotranspiration_v1()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(-0.5, 0.0, 0.5, 1.0, 1.5, 2.0)

When setting ExcessReduction to 0.5, Update_SoilEvapotranspiration_V1 takes the average of potential interception evaporation and the average of potential interception evaporation and soil evapotranspiration as the threshold and halves each exceedance above this threshold:

>>> fluxes.potentialinterceptionevaporation = 2.5
>>> fluxes.potentialsoilevapotranspiration = 0.5
>>> excessreduction(0.5)
>>> fluxes.soilevapotranspiration = -0.5, 0.0, 0.5, 1.0, 1.5, 2.0
>>> model.update_soilevapotranspiration_v1()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(-0.5, 0.0, 0.5, 1.0, 1.25, 1.5)

In the unfortunate case of interception evaporation exceeding potential evapotranspiration, previously positive soil evapotranspiration values can become negative:

>>> fluxes.interceptionevaporation = 3.0
>>> fluxes.soilevapotranspiration = -0.5, 0.0, 0.5, 1.0, 1.5, 2.0
>>> model.update_soilevapotranspiration_v1()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(-0.75, -0.5, -0.25, 0.0, 0.25, 0.5)

For negative potential evapotranspiration (condensation), Update_SoilEvapotranspiration_V1 reverses its behaviour to prevent the sum of interception and soil condensation from exceeding potential condensation (too much):

>>> fluxes.potentialinterceptionevaporation = -2.5
>>> fluxes.potentialsoilevapotranspiration = -0.5
>>> fluxes.interceptionevaporation = -1.0
>>> fluxes.soilevapotranspiration = 0.5, -0.0, -0.5, -1.0, -1.5, -2.0
>>> model.update_soilevapotranspiration_v1()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(0.5, 0.0, -0.5, -1.0, -1.25, -1.5)

For non-soil units, soil evapotranspiration is generally zero:

>>> soil(False)
>>> model.update_soilevapotranspiration_v1()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
class hydpy.models.evap.evap_model.Update_SoilEvapotranspiration_V2[source]

Bases: Method

Reduce actual soil evapotranspiration due to snow covering.

Required by the method:

Determine_SoilEvapotranspiration_V1

Requires the control parameters:

NmbHRU Soil

Requires the factor sequence:

SnowCover

Calculates the flux sequence:

SoilEvapotranspiration

Basic equations:
\[\begin{split}et_s^{new} = (1 - c) \cdot et_s^{old} \\ \\ et_s = SoilEvapotranspiration \\ c = SnowCover\end{split}\]

Examples:

We initialise five hydrological response units with different snow cover degrees:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(5)
>>> soil(True)
>>> factors.snowcover = 0.0, 0.25, 0.5, 0.75, 1.0
>>> fluxes.soilevapotranspiration = 2.0
>>> model.update_soilevapotranspiration_v2()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(2.0, 1.5, 1.0, 0.5, 0.0)

For non-soil units, soil evapotranspiration is generally zero:

>>> soil(False)
>>> model.update_soilevapotranspiration_v2()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(0.0, 0.0, 0.0, 0.0, 0.0)
class hydpy.models.evap.evap_model.Update_SoilEvapotranspiration_V3[source]

Bases: Method

Reduce actual soil evapotranspiration if interception evaporation occurs simultaneously following Wigmosta et al. (1994).

Required by the methods:

Determine_SoilEvapotranspiration_V2 Determine_SoilEvapotranspiration_V3

Requires the control parameters:

NmbHRU Interception Soil

Requires the flux sequences:

PotentialInterceptionEvaporation InterceptionEvaporation

Updates the flux sequence:

SoilEvapotranspiration

Basic equation:

\(SoilEvapotranspiration_{new} = \frac{PotentialInterceptionEvaporation - InterceptionEvaporation} {PotentialInterceptionEvaporation} \cdot SoilEvapotranspiration_{old}\)

Example:

For response units with relevant interception and soil storage, method Update_SoilEvapotranspiration_V3 applies the given base equation:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(4)
>>> interception(True)
>>> soil(True)
>>> fluxes.potentialinterceptionevaporation = 3.0
>>> fluxes.interceptionevaporation = 0.0, 1.0, 2.0, 3.0
>>> fluxes.soilevapotranspiration = 2.0
>>> model.update_soilevapotranspiration_v3()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(2.0, 1.333333, 0.666667, 0.0)

The same holds for negative values (condensation) and mixtures of positive and negative values (possibly due to different energy balances when only soil evapotranspiration takes the soil heat flux into account):

>>> fluxes.potentialinterceptionevaporation = -3.0
>>> fluxes.interceptionevaporation = 0.0, -1.0, -2.0, -3.0
>>> fluxes.soilevapotranspiration = -2.0
>>> model.update_soilevapotranspiration_v3()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(-2.0, -1.333333, -0.666667, 0.0)

>>> fluxes.potentialinterceptionevaporation = 3.0
>>> fluxes.interceptionevaporation = 0.0, 1.0, 2.0, 3.0
>>> fluxes.soilevapotranspiration = -2.0
>>> model.update_soilevapotranspiration_v3()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(-2.0, -1.333333, -0.666667, 0.0)

Update_SoilEvapotranspiration_V3 sets the soil evapotranspiration to zero if potential interception evaporation is also zero:

>>> fluxes.potentialinterceptionevaporation = 0.0
>>> fluxes.interceptionevaporation = 0.0
>>> fluxes.soilevapotranspiration = 2.0
>>> model.update_soilevapotranspiration_v3()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(0.0, 0.0, 0.0, 0.0)

For response units that do not consider interception, Update_SoilEvapotranspiration_V3 never modifies soil evapotranspiration:

>>> interception(False)
>>> fluxes.potentialinterceptionevaporation = 3.0
>>> fluxes.soilevapotranspiration = 2.0
>>> model.update_soilevapotranspiration_v3()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(2.0, 2.0, 2.0, 2.0)

For response units without relevant soil storage, Update_SoilEvapotranspiration_V3 generally sets soil evapotranspiration to zero:

>>> soil(False)
>>> model.update_soilevapotranspiration_v3()
>>> fluxes.soilevapotranspiration
soilevapotranspiration(0.0, 0.0, 0.0, 0.0)
class hydpy.models.evap.evap_model.Determine_PotentialEvapotranspiration_V1[source]

Bases: Method

Interface method that applies the complete application model by executing all “run methods”.

class hydpy.models.evap.evap_model.Get_PotentialEvapotranspiration_V1[source]

Bases: Method

Get the current reference evapotranspiration from the selected hydrological response unit.

Requires the flux sequence:

ReferenceEvapotranspiration

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> fluxes.referenceevapotranspiration = 2.0, 4.0
>>> from hydpy import round_
>>> round_(model.get_potentialevapotranspiration_v1(0))
2.0
>>> round_(model.get_potentialevapotranspiration_v1(1))
4.0
class hydpy.models.evap.evap_model.Get_PotentialEvapotranspiration_V2[source]

Bases: Method

Get the current potential evapotranspiration from the selected hydrological response unit.

Requires the flux sequence:

PotentialEvapotranspiration

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> fluxes.potentialevapotranspiration = 2.0, 4.0
>>> from hydpy import round_
>>> round_(model.get_potentialevapotranspiration_v2(0))
2.0
>>> round_(model.get_potentialevapotranspiration_v2(1))
4.0
class hydpy.models.evap.evap_model.Get_MeanPotentialEvapotranspiration_V1[source]

Bases: Method

Get the averaged reference evapotranspiration.

Requires the flux sequence:

MeanReferenceEvapotranspiration

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> fluxes.meanreferenceevapotranspiration = 3.0
>>> model.get_meanpotentialevapotranspiration_v1()
3.0
class hydpy.models.evap.evap_model.Get_MeanPotentialEvapotranspiration_V2[source]

Bases: Method

Get the averaged potential evapotranspiration.

Requires the flux sequence:

MeanPotentialEvapotranspiration

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> fluxes.meanpotentialevapotranspiration = 3.0
>>> model.get_meanpotentialevapotranspiration_v2()
3.0
class hydpy.models.evap.evap_model.Determine_PotentialInterceptionEvaporation_V1[source]

Bases: AutoMethod

Determine the potential interception evaporation according to AMBAV 1.0 (Löpmeier, 2014).

Required submethods:

Process_RadiationModel_V1 Calc_PossibleSunshineDuration_V1 Calc_SunshineDuration_V1 Calc_GlobalRadiation_V1 Calc_AirTemperature_V1 Calc_WindSpeed10m_V1 Calc_SaturationVapourPressure_V1 Calc_SaturationVapourPressureSlope_V1 Calc_ActualVapourPressure_V1 Calc_DryAirPressure_V1 Calc_AirDensity_V1 Calc_AerodynamicResistance_V2 Calc_SnowCover_V1 Calc_DailyPrecipitation_V1 Calc_DailyPotentialSoilEvapotranspiration_V1 Calc_CurrentAlbedo_V2 Calc_NetShortwaveRadiation_V2 Update_CloudCoverage_V1 Calc_AdjustedCloudCoverage_V1 Calc_NetLongwaveRadiation_V2 Calc_NetRadiation_V1 Calc_SoilHeatFlux_V4 Calc_PotentialInterceptionEvaporation_V2

Requires the control parameters:

NmbHRU HRUType Interception Soil Plant Water MeasuringHeightWindSpeed GroundAlbedo GroundAlbedoSnow LeafAlbedo LeafAlbedoSnow LeafAreaIndex WetnessThreshold CloudTypeFactor NightCloudFactor

Requires the derived parameters:

Hours Days MOY NmbLogEntries AerodynamicResistanceFactor

Requires the fixed parameters:

StefanBoltzmannConstant GasConstantDryAir GasConstantWaterVapour HeatOfCondensation HeatCapacityAir RoughnessLengthGrass PsychrometricConstant

Requires the input sequences:

WindSpeed AtmosphericPressure RelativeHumidity

Requires the log sequences:

LoggedPrecipitation LoggedPotentialSoilEvapotranspiration

Updates the state sequence:

CloudCoverage

Calculates the factor sequences:

SunshineDuration PossibleSunshineDuration AirTemperature WindSpeed10m SaturationVapourPressure SaturationVapourPressureSlope ActualVapourPressure DryAirPressure AirDensity AerodynamicResistance SnowCover CurrentAlbedo AdjustedCloudCoverage

Calculates the flux sequences:

GlobalRadiation DailyPrecipitation DailyPotentialSoilEvapotranspiration NetShortwaveRadiation NetLongwaveRadiation NetRadiation SoilHeatFlux PotentialInterceptionEvaporation

class hydpy.models.evap.evap_model.Determine_InterceptionEvaporation_V1[source]

Bases: AutoMethod

Determine the actual interception evaporation according to Lindström et al. (1997).

Required submethods:

Calc_PotentialInterceptionEvaporation_V3 Calc_InterceptedWater_V1 Calc_InterceptionEvaporation_V1

Requires the control parameters:

NmbHRU Interception

Calculates the factor sequence:

InterceptedWater

Calculates the flux sequences:

PotentialInterceptionEvaporation InterceptionEvaporation

class hydpy.models.evap.evap_model.Determine_InterceptionEvaporation_V2[source]

Bases: AutoMethod

Determine the actual interception evaporation according to Thompson et al. (1981) and LEG (2020).

Required submethods:

Process_RadiationModel_V1 Calc_PossibleSunshineDuration_V1 Calc_SunshineDuration_V1 Calc_GlobalRadiation_V1 Calc_AirTemperature_V1 Update_LoggedAirTemperature_V1 Calc_DailyAirTemperature_V1 Calc_WindSpeed10m_V1 Update_LoggedRelativeHumidity_V1 Calc_DailyRelativeHumidity_V1 Calc_SaturationVapourPressure_V2 Calc_DailySaturationVapourPressure_V1 Calc_SaturationVapourPressureSlope_V2 Calc_DailySaturationVapourPressureSlope_V1 Calc_ActualVapourPressure_V1 Calc_DailyActualVapourPressure_V1 Calc_DryAirPressure_V1 Calc_AirDensity_V1 Calc_AerodynamicResistance_V1 Calc_SnowCover_V1 Calc_SnowyCanopy_V1 Update_LoggedSunshineDuration_V1 Calc_DailySunshineDuration_V1 Update_LoggedPossibleSunshineDuration_V1 Calc_DailyPossibleSunshineDuration_V1 Calc_CurrentAlbedo_V1 Calc_NetShortwaveRadiation_V2 Calc_DailyNetLongwaveRadiation_V1 Calc_NetRadiation_V2 Calc_SoilHeatFlux_V3 Calc_PotentialInterceptionEvaporation_V1 Calc_InterceptedWater_V1 Calc_InterceptionEvaporation_V2

Requires the control parameters:

NmbHRU HRUType Interception Tree Water MeasuringHeightWindSpeed Albedo CropHeight Emissivity AverageSoilHeatFlux

Requires the derived parameters:

MOY NmbLogEntries

Requires the fixed parameters:

StefanBoltzmannConstant FactorCounterRadiation GasConstantDryAir GasConstantWaterVapour HeatOfCondensation HeatCapacityAir RoughnessLengthGrass PsychrometricConstant

Requires the input sequences:

WindSpeed AtmosphericPressure RelativeHumidity

Updates the log sequences:

LoggedAirTemperature LoggedRelativeHumidity LoggedSunshineDuration LoggedPossibleSunshineDuration

Calculates the factor sequences:

PossibleSunshineDuration SunshineDuration AirTemperature DailyAirTemperature WindSpeed10m DailyRelativeHumidity SaturationVapourPressure DailySaturationVapourPressure SaturationVapourPressureSlope DailySaturationVapourPressureSlope ActualVapourPressure DailyActualVapourPressure DryAirPressure AirDensity AerodynamicResistance SnowCover SnowyCanopy DailySunshineDuration DailyPossibleSunshineDuration CurrentAlbedo InterceptedWater

Calculates the flux sequences:

GlobalRadiation NetShortwaveRadiation DailyNetLongwaveRadiation NetRadiation SoilHeatFlux PotentialInterceptionEvaporation InterceptionEvaporation

class hydpy.models.evap.evap_model.Determine_PotentialSoilEvapotranspiration_V1[source]

Bases: AutoMethod

Determine the actual evapotranspiration from the soil according to AMBAV 1.0 (Löpmeier, 2014).

class hydpy.models.evap.evap_model.Determine_SoilEvapotranspiration_V1[source]

Bases: AutoMethod

Determine the actual evapotranspiration from the soil according to Lindström et al. (1997).

Required submethods:

Calc_SoilWater_V1 Calc_SnowCover_V1 Calc_PotentialSoilEvapotranspiration_V2 Calc_SoilEvapotranspiration_V1 Update_SoilEvapotranspiration_V1 Update_SoilEvapotranspiration_V2

Requires the control parameters:

NmbHRU Soil MaxSoilWater SoilMoistureLimit ExcessReduction

Requires the flux sequences:

PotentialInterceptionEvaporation InterceptionEvaporation

Calculates the factor sequences:

SoilWater SnowCover

Calculates the flux sequences:

PotentialSoilEvapotranspiration SoilEvapotranspiration

class hydpy.models.evap.evap_model.Determine_SoilEvapotranspiration_V2[source]

Bases: AutoMethod

Determine the actual evapotranspiration from the soil according to Minhas et al. (1974).

Required submethods:

Calc_SoilWater_V1 Calc_PotentialSoilEvapotranspiration_V2 Calc_SoilEvapotranspiration_V2 Update_SoilEvapotranspiration_V3

Requires the control parameters:

NmbHRU Interception Soil MaxSoilWater DisseFactor

Requires the flux sequences:

PotentialInterceptionEvaporation InterceptionEvaporation

Calculates the factor sequence:

SoilWater

Calculates the flux sequences:

PotentialSoilEvapotranspiration SoilEvapotranspiration

class hydpy.models.evap.evap_model.Determine_SoilEvapotranspiration_V3[source]

Bases: AutoMethod

Determine the actual evapotranspiration from the soil according to Thompson et al. (1981) and LEG (2020).

Required submethods:

Calc_SoilWater_V1 Calc_SnowCover_V1 Calc_SoilSurfaceResistance_V1 Calc_LanduseSurfaceResistance_V1 Calc_ActualSurfaceResistance_V1 Calc_SoilEvapotranspiration_V3 Update_SoilEvapotranspiration_V3

Requires the control parameters:

NmbHRU HRUType Interception Soil Tree Conifer LeafAreaIndex SurfaceResistance Emissivity MaxSoilWater SoilMoistureLimit

Requires the derived parameters:

Hours MOY

Requires the fixed parameters:

StefanBoltzmannConstant HeatOfCondensation HeatCapacityAir PsychrometricConstant

Requires the factor sequences:

PossibleSunshineDuration AirTemperature SaturationVapourPressureSlope SaturationVapourPressure ActualVapourPressure AirDensity AerodynamicResistance

Requires the flux sequences:

NetRadiation SoilHeatFlux PotentialInterceptionEvaporation InterceptionEvaporation

Calculates the factor sequences:

SoilWater SnowCover SoilSurfaceResistance LanduseSurfaceResistance ActualSurfaceResistance

Calculates the flux sequence:

SoilEvapotranspiration

class hydpy.models.evap.evap_model.Determine_PotentialWaterEvaporation_V1[source]

Bases: AutoMethod

Determine the potential evaporation from open water areas according to AMBAV 1.0 (Löpmeier, 2014).

class hydpy.models.evap.evap_model.Determine_WaterEvaporation_V1[source]

Bases: AutoMethod

Determine the actual evapotranspiration from open water areas according to Lindström et al. (1997).

Required submethods:

Calc_AirTemperature_V1 Calc_PotentialWaterEvaporation_V1 Calc_WaterEvaporation_V1

Requires the control parameters:

NmbHRU Water TemperatureThresholdIce

Calculates the factor sequence:

AirTemperature

Calculates the flux sequences:

PotentialWaterEvaporation WaterEvaporation

class hydpy.models.evap.evap_model.Determine_WaterEvaporation_V2[source]

Bases: AutoMethod

Accept potential evapotranspiration as the actual evaporation from water areas.

Required submethods:

Calc_PotentialWaterEvaporation_V1 Calc_WaterEvaporation_V2

Requires the control parameters:

NmbHRU Water

Calculates the flux sequences:

PotentialWaterEvaporation WaterEvaporation

class hydpy.models.evap.evap_model.Determine_WaterEvaporation_V3[source]

Bases: AutoMethod

Determine the actual evapotranspiration from open water areas according to LEG (2020), based on DVWK (1996).

Required submethods:

Calc_WindSpeed2m_V2 Update_LoggedWindSpeed2m_V1 Calc_DailyWindSpeed2m_V1 Update_LoggedGlobalRadiation_V1 Calc_DailyGlobalRadiation_V1 Calc_DailyNetShortwaveRadiation_V1 Calc_DailyNetRadiation_V1 Calc_WaterEvaporation_V3

Requires the control parameters:

NmbHRU Water MeasuringHeightWindSpeed

Requires the derived parameters:

Days NmbLogEntries

Requires the fixed parameters:

HeatOfCondensation PsychrometricConstant RoughnessLengthGrass

Requires the input sequence:

WindSpeed

Requires the factor sequences:

CurrentAlbedo DailySaturationVapourPressure DailySaturationVapourPressureSlope DailyActualVapourPressure

Requires the flux sequences:

GlobalRadiation DailyNetLongwaveRadiation

Updates the log sequences:

LoggedWindSpeed2m LoggedGlobalRadiation

Calculates the factor sequences:

WindSpeed2m DailyWindSpeed2m

Calculates the flux sequences:

DailyGlobalRadiation DailyNetShortwaveRadiation DailyNetRadiation WaterEvaporation

class hydpy.models.evap.evap_model.Get_WaterEvaporation_V1[source]

Bases: Method

Get the current water area evaporation from the selected hydrological response unit.

Requires the flux sequence:

WaterEvaporation

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> fluxes.waterevaporation = 2.0, 4.0
>>> from hydpy import round_
>>> round_(model.get_waterevaporation_v1(0))
2.0
>>> round_(model.get_waterevaporation_v1(1))
4.0
class hydpy.models.evap.evap_model.Get_PotentialWaterEvaporation_V1[source]

Bases: Method

Get the water area evaporation sum of the last 24 hours from the selected hydrological response unit.

Requires the derived parameter:

Days

Requires the flux sequence:

DailyWaterEvaporation

Example:

>>> from hydpy.models.evap import *
>>> simulationstep("12h")
>>> parameterstep()
>>> nmbhru(2)
>>> derived.days.update()
>>> fluxes.dailywaterevaporation = 2.0, 4.0
>>> from hydpy import round_
>>> round_(model.get_potentialwaterevaporation_v1(0))
1.0
>>> round_(model.get_potentialwaterevaporation_v1(1))
2.0
class hydpy.models.evap.evap_model.Get_PotentialInterceptionEvaporation_V1[source]

Bases: Method

Get the current potential interception evaporation from the selected hydrological response unit.

Requires the flux sequence:

PotentialInterceptionEvaporation

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> fluxes.potentialinterceptionevaporation = 2.0, 4.0
>>> from hydpy import round_
>>> round_(model.get_potentialinterceptionevaporation_v1(0))
2.0
>>> round_(model.get_potentialinterceptionevaporation_v1(1))
4.0
class hydpy.models.evap.evap_model.Get_InterceptionEvaporation_V1[source]

Bases: Method

Get the current actual interception evaporation from the selected hydrological response unit.

Requires the flux sequence:

InterceptionEvaporation

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> fluxes.interceptionevaporation = 2.0, 4.0
>>> from hydpy import round_
>>> round_(model.get_interceptionevaporation_v1(0))
2.0
>>> round_(model.get_interceptionevaporation_v1(1))
4.0
class hydpy.models.evap.evap_model.Get_PotentialSoilEvapotranspiration_V1[source]

Bases: Method

Get the current potential soil evapotranspiration from the selected hydrological response unit.

Requires the flux sequence:

PotentialSoilEvapotranspiration

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> fluxes.potentialsoilevapotranspiration = 2.0, 4.0
>>> from hydpy import round_
>>> round_(model.get_potentialsoilevapotranspiration_v1(0))
2.0
>>> round_(model.get_potentialsoilevapotranspiration_v1(1))
4.0
class hydpy.models.evap.evap_model.Get_SoilEvapotranspiration_V1[source]

Bases: Method

Get the current soil evapotranspiration from the selected hydrological response unit.

Requires the flux sequence:

SoilEvapotranspiration

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(2)
>>> fluxes.soilevapotranspiration = 2.0, 4.0
>>> from hydpy import round_
>>> round_(model.get_soilevapotranspiration_v1(0))
2.0
>>> round_(model.get_soilevapotranspiration_v1(1))
4.0
class hydpy.models.evap.evap_model.Sub_ETModel[source]

Bases: AdHocModel

Base class for submodels that comply with the submodel interfaces defined in modules petinterfaces and aetinterfaces.

static share_configuration(sharable_configuration: SharableConfiguration) → Generator[None, None, None][source]

Take the landtype_constants data to adjust the parameters HRUType and LandMonthFactor, the landtype_refindices parameter instance to adjust the index references of all parameters inherited from ZipParameter1D and the refweights parameter instance to adjust the weight references of all sequences inherited from FactorSequence1D or FluxSequence1D, temporarily:

>>> from hydpy.core.parametertools import Constants, NameParameter, Parameter
>>> consts = Constants(GRASS=1, TREES=3, WATER=2)
>>> class LandType(NameParameter):
...     __name__ = "temp.py"
...     constants = consts
>>> class Subarea(Parameter):
...     ...
>>> from hydpy.models.evap.evap_model import Sub_ETModel
>>> with Sub_ETModel.share_configuration(
...         {"landtype_constants": consts,
...          "landtype_refindices": LandType,
...          "refweights": Subarea}):
...     from hydpy.models.evap.evap_control import HRUType, LandMonthFactor
...     HRUType.constants
...     LandMonthFactor.rowmin, LandMonthFactor.rownames
...     from hydpy.models.evap.evap_parameters import ZipParameter1D
...     ZipParameter1D.refindices.__name__
...     ZipParameter1D._refweights.__name__
...     from hydpy.models.evap.evap_sequences import FactorSequence1D, FluxSequence1D
...     FactorSequence1D._refweights.__name__
...     FluxSequence1D._refweights.__name__
{'GRASS': 1, 'TREES': 3, 'WATER': 2}
(1, ('grass', 'water', 'trees'))
'LandType'
'Subarea'
'Subarea'
'Subarea'
>>> HRUType.constants
{'ANY': 0}
>>> LandMonthFactor.rowmin, LandMonthFactor.rownames
(0, ('ANY',))
>>> ZipParameter1D.refindices
>>> ZipParameter1D._refweights
>>> FactorSequence1D._refweights
>>> FluxSequence1D._refweights
prepare_nmbzones

Set the number of hydrological response units.

>>> from hydpy.models.evap_ret_tw2002 import *
>>> parameterstep()
>>> model.prepare_nmbzones(2)
>>> nmbhru
nmbhru(2)
prepare_subareas

Set the area of all hydrological response units in km².

>>> from hydpy.models.evap_ret_tw2002 import *
>>> parameterstep()
>>> nmbhru(2)
>>> model.prepare_subareas([1.0, 3.0])
>>> hruarea
hruarea(1.0, 3.0)
prepare_elevations

If such a parameter exists, set the altitude of all hydrological response units in m.

>>> from hydpy import prepare_model
>>> petmodel = prepare_model("evap_pet_hbv96")
>>> petmodel.parameters.control.nmbhru(2)
>>> petmodel.prepare_elevations([1.0, 3.0])
>>> petmodel.parameters.control.hrualtitude
hrualtitude(1.0, 3.0)
prepare_zonetypes

If such a parameter exists, set the hydrological response unit types.

>>> GRASS, TREES, WATER = 1, 3, 2
>>> from hydpy.core.parametertools import Constants
>>> constants = Constants(GRASS=GRASS, TREES=TREES, WATER=WATER)
>>> from hydpy.models.evap.evap_control import HRUType
>>> with HRUType.modify_constants(constants):
...     from hydpy.models.evap_pet_mlc import *
...     parameterstep()
>>> nmbhru(2)
>>> model.prepare_zonetypes([TREES, WATER])
>>> hrutype
hrutype(TREES, WATER)
prepare_water

Set the flag indicating whether or not the respective hydrological response units are water areas.

>>> from hydpy.models.evap_aet_hbv96 import *
>>> parameterstep()
>>> nmbhru(2)
>>> model.prepare_water([True, False])
>>> water
water(True, False)
prepare_interception

Set the flag indicating whether or not the respective hydrological response units consider interception evaporation.

>>> from hydpy.models.evap_aet_hbv96 import *
>>> parameterstep()
>>> nmbhru(2)
>>> model.prepare_interception([True, False])
>>> interception
interception(True, False)
prepare_soil

Set the flag indicating whether or not the respective hydrological response units consider evapotranspiration from the soil.

>>> from hydpy.models.evap_aet_hbv96 import *
>>> parameterstep()
>>> nmbhru(2)
>>> model.prepare_soil([True, False])
>>> soil
soil(True, False)
prepare_plant

Set the flag indicating whether or not the respective hydrological response units contain vegetation.

>>> from hydpy import prepare_model
>>> ambav = prepare_model("evap_pet_ambav1")
>>> ambav.parameters.control.nmbhru(2)
>>> ambav.prepare_plant([True, False])
>>> ambav.parameters.control.plant
plant(True, False)
prepare_tree

Set the flag indicating whether or not the respective hydrological response units contain tree-like vegetation.

>>> from hydpy.models.evap_aet_morsim import *
>>> parameterstep()
>>> nmbhru(2)
>>> model.prepare_tree([True, False])
>>> tree
tree(True, False)
prepare_conifer

Set the flag indicating whether or not the respective hydrological response units contain conifer-like vegetation.

>>> from hydpy.models.evap_aet_morsim import *
>>> parameterstep()
>>> nmbhru(2)
>>> model.prepare_conifer([True, False])
>>> conifer
conifer(True, False)
prepare_leafareaindex

Set the leaf area index in m²/m².

>>> from hydpy.models.evap_aet_morsim import *
>>> parameterstep()
>>> model.prepare_leafareaindex(10.0)
>>> leafareaindex
leafareaindex(ANY=[10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0,
                   10.0, 10.0, 10.0])
prepare_measuringheightwindspeed

Set the height above the ground of the wind speed measurements in m.

>>> from hydpy.models.evap_aet_morsim import *
>>> parameterstep()
>>> model.prepare_measuringheightwindspeed(10.0)
>>> measuringheightwindspeed
measuringheightwindspeed(10.0)
prepare_maxsoilwater

Set the maximum soil water content in mm.

>>> from hydpy.models.evap_aet_hbv96 import *
>>> parameterstep()
>>> nmbhru(2)
>>> model.prepare_maxsoilwater([100.0, 200.0])
>>> maxsoilwater
maxsoilwater(100.0, 200.0)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_RET_PETModel_V1[source]

Bases: AdHocModel

Base class for HydPy-Evap models that use submodels named retmodel and comply with the PETModel_V1 interface.

retmodel: SubmodelProperty
retmodel_is_mainmodel
retmodel_typeid
add_retmodel_v1

Initialise the given retmodel that follows the PETModel_V1 interface and is responsible for calculating the reference evapotranspiration.

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2001-01-01", "1d"
>>> from hydpy.models.evap_pet_m import *
>>> parameterstep()
>>> nmbhru(2)
>>> hruarea(2.0, 8.0)
>>> with model.add_retmodel_v1("evap_ret_io"):
...     nmbhru
nmbhru(2)
>>> model.retmodel.parameters.control.hruarea
hruarea(2.0, 8.0)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_PET_PETModel_V1[source]

Bases: AdHocModel

Base class for HydPy-Evap models that use submodels named petmodel and 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 and is responsible for calculating potential evapotranspiration.

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2001-01-01", "1d"
>>> from hydpy.models.evap_aet_hbv96 import *
>>> parameterstep()
>>> nmbhru(2)
>>> with model.add_petmodel_v1("evap_ret_io"):
...     hruarea(8.0, 2.0)
...     nmbhru
nmbhru(2)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_PET_PETModel_V2[source]

Bases: AdHocModel

Base class for HydPy-Evap models that use submodels named petmodel and 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 and is responsible for calculating potential evapotranspiration.

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2001-01-01", "1d"
>>> from hydpy.models.evap_aet_hbv96 import *
>>> parameterstep()
>>> nmbhru(2)
>>> interception(True)
>>> soil(True)
>>> water(False)
>>> with model.add_petmodel_v2("evap_pet_ambav1"):
...     nmbhru
...     interception
...     soil
...     water
nmbhru(2)
interception(True)
soil(True)
water(False)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_TempModel_V1[source]

Bases: AdHocModel, SubmodelInterface

Base class for HydPy-Evap models that can use main models as their sub-submodels if they comply with the TempModel_V1 interface.

tempmodel: SubmodelProperty
tempmodel_is_mainmodel
tempmodel_typeid
add_mainmodel_as_subsubmodel(mainmodel: Model) → bool[source]

Add the given main model as a submodel if it complies with the TempModel_V1 interface.

>>> from hydpy import prepare_model
>>> evap = prepare_model("evap_pet_hbv96")
>>> evap.add_mainmodel_as_subsubmodel(prepare_model("evap_ret_io"))
False
>>> evap.tempmodel
>>> evap.tempmodel_is_mainmodel
False
>>> evap.tempmodel_typeid
0

>>> hland = prepare_model("hland_96")
>>> evap.add_mainmodel_as_subsubmodel(hland)
True
>>> evap.tempmodel is hland
True
>>> evap.tempmodel_is_mainmodel
True
>>> evap.tempmodel_typeid
1
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_TempModel_V2A[source]

Bases: AdHocModel

Base class for HydPy-Evap models that support submodels that comply with the TempModel_V2 interface and provide subarea size information.

tempmodel: SubmodelProperty
tempmodel_is_mainmodel
tempmodel_typeid
add_tempmodel_v2

Initialise the given precipitation model that follows the TempModel_V2 interface and set the number and the subareas of its zones.

>>> from hydpy.models.evap_pet_hbv96 import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> nmbhru(2)
>>> hruarea(2.0, 8.0)
>>> with model.add_tempmodel_v2("meteo_temp_io"):
...     nmbhru
...     hruarea
...     temperatureaddend(1.0, 2.0)
nmbhru(2)
hruarea(2.0, 8.0)
>>> model.tempmodel.parameters.control.temperatureaddend
temperatureaddend(1.0, 2.0)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_TempModel_V2B[source]

Bases: AdHocModel

Base class for HydPy-Evap models that support submodels that comply with the TempModel_V2 interface and do not provide subarea size information.

tempmodel: SubmodelProperty
tempmodel_is_mainmodel
tempmodel_typeid
add_tempmodel_v2

Initialise the given precipitation model that follows the TempModel_V2 interface and set the number of its zones.

>>> from hydpy.models.evap_aet_hbv96 import *
>>> simulationstep("1d")
>>> parameterstep("1d")
>>> nmbhru(2)
>>> with model.add_tempmodel_v2("meteo_temp_io"):
...     nmbhru
...     hruarea(0.8, 0.2)
...     temperatureaddend(1.0, 2.0)
nmbhru(2)
>>> model.tempmodel.parameters.control.hruarea
hruarea(0.8, 0.2)
>>> model.tempmodel.parameters.control.temperatureaddend
temperatureaddend(1.0, 2.0)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_PrecipModel_V1[source]

Bases: AdHocModel, SubmodelInterface

Base class for HydPy-Evap models that can use main models as their sub-submodels if they comply with the PrecipModel_V1 interface.

precipmodel: SubmodelProperty
precipmodel_is_mainmodel
precipmodel_typeid
add_mainmodel_as_subsubmodel(mainmodel: Model) → bool[source]

Add the given main model as a submodel if it complies with the PrecipModel_V1 interface.

>>> from hydpy import prepare_model
>>> evap = prepare_model("evap_pet_hbv96")
>>> evap.add_mainmodel_as_subsubmodel(prepare_model("evap_ret_io"))
False
>>> evap.precipmodel
>>> evap.precipmodel_is_mainmodel
False
>>> evap.precipmodel_typeid
0

>>> hland = prepare_model("hland_96")
>>> evap.add_mainmodel_as_subsubmodel(hland)
True
>>> evap.precipmodel is hland
True
>>> evap.precipmodel_is_mainmodel
True
>>> evap.precipmodel_typeid
1
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_PrecipModel_V2A[source]

Bases: AdHocModel

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

precipmodel: SubmodelProperty
precipmodel_is_mainmodel
precipmodel_typeid
add_precipmodel_v2

Initialise the given precipitation model that follows the PrecipModel_V2 interface and set the number and the subareas of its zones.

>>> from hydpy.models.evap_pet_hbv96 import *
>>> parameterstep()
>>> nmbhru(2)
>>> hruarea(2.0, 8.0)
>>> with model.add_precipmodel_v2("meteo_precip_io"):
...     nmbhru
...     hruarea
...     precipitationfactor(1.0, 2.0)
nmbhru(2)
hruarea(2.0, 8.0)
>>> model.precipmodel.parameters.control.precipitationfactor
precipitationfactor(1.0, 2.0)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_PrecipModel_V2B[source]

Bases: AdHocModel

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

precipmodel: SubmodelProperty
precipmodel_is_mainmodel
precipmodel_typeid
add_precipmodel_v2

Initialise the given precipitation model that follows the PrecipModel_V2 interface and set the number of its zones.

>>> from hydpy.models.evap_pet_ambav1 import *
>>> parameterstep()
>>> nmbhru(2)
>>> with model.add_precipmodel_v2("meteo_precip_io"):
...     nmbhru
...     hruarea(0.8, 0.2)
...     precipitationfactor(1.0, 2.0)
nmbhru(2)
>>> model.precipmodel.parameters.control.hruarea
hruarea(0.8, 0.2)
>>> model.precipmodel.parameters.control.precipitationfactor
precipitationfactor(1.0, 2.0)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_RadiationModel_V1[source]

Bases: AdHocModel

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

radiationmodel: SubmodelProperty
radiationmodel_is_mainmodel
radiationmodel_typeid
add_radiationmodel_v1

Initialise the given radiation model that follows the RadiationModel_V1 interface.

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> from hydpy.models.evap_ret_tw2002 import *
>>> parameterstep()
>>> with model.add_radiationmodel_v1("meteo_glob_fao56"):
...     latitude(50.0)
...     longitude(5.0)
>>> model.radiationmodel.parameters.control.latitude
latitude(50.0)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_RadiationModel_V2[source]

Bases: AdHocModel

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

radiationmodel: SubmodelProperty
radiationmodel_is_mainmodel
radiationmodel_typeid
add_radiationmodel_v2

Initialise the given radiation model that follows the RadiationModel_V2 interface.

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> from hydpy.models.evap_ret_tw2002 import *
>>> parameterstep()
>>> with model.add_radiationmodel_v2("meteo_glob_io"):
...     inputs.globalradiation = 100.0
>>> model.radiationmodel.sequences.inputs.globalradiation
globalradiation(100.0)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_RadiationModel_V3[source]

Bases: AdHocModel

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

radiationmodel: SubmodelProperty
radiationmodel_is_mainmodel
radiationmodel_typeid
add_radiationmodel_v3

Initialise the given radiation model that follows the RadiationModel_V3 interface.

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> from hydpy.models.evap_ret_fao56 import *
>>> parameterstep()
>>> with model.add_radiationmodel_v3("meteo_clear_glob_io"):
...     inputs.clearskysolarradiation = 200.0
...     inputs.globalradiation = 100.0
>>> model.radiationmodel.sequences.inputs.clearskysolarradiation
clearskysolarradiation(200.0)
>>> model.radiationmodel.sequences.inputs.globalradiation
globalradiation(100.0)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_RadiationModel_V4[source]

Bases: AdHocModel

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

radiationmodel: SubmodelProperty
radiationmodel_is_mainmodel
radiationmodel_typeid
add_radiationmodel_v4

Initialise the given radiation model that follows the RadiationModel_V4 interface.

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> from hydpy.models.evap_pet_ambav1 import *
>>> parameterstep()
>>> with model.add_radiationmodel_v4("meteo_psun_sun_glob_io"):
...     inputs.possiblesunshineduration = 12.0
...     inputs.sunshineduration = 6.0
...     inputs.globalradiation = 100.0
>>> model.radiationmodel.sequences.inputs.possiblesunshineduration
possiblesunshineduration(12.0)
>>> model.radiationmodel.sequences.inputs.sunshineduration
sunshineduration(6.0)
>>> model.radiationmodel.sequences.inputs.globalradiation
globalradiation(100.0)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_IntercModel_V1[source]

Bases: AdHocModel, SubmodelInterface

Base class for HydPy-Evap models that can use main models as their sub-submodels if they comply with the IntercModel_V1 interface.

intercmodel: SubmodelProperty
intercmodel_is_mainmodel
intercmodel_typeid
add_mainmodel_as_subsubmodel(mainmodel: Model) → bool[source]

Add the given main model as a submodel if it complies with the IntercModel_V1 interface.

>>> from hydpy import prepare_model
>>> evap = prepare_model("evap_aet_hbv96")
>>> evap.add_mainmodel_as_subsubmodel(prepare_model("evap_ret_io"))
False
>>> evap.intercmodel
>>> evap.intercmodel_is_mainmodel
False
>>> evap.intercmodel_typeid
0

>>> hland = prepare_model("hland_96")
>>> evap.add_mainmodel_as_subsubmodel(hland)
True
>>> evap.intercmodel is hland
True
>>> evap.intercmodel_is_mainmodel
True
>>> evap.intercmodel_typeid
1
add_intercmodel_v1

Initialise the given interception model that follows the IntercModel_V1 interface and set the number of its zones.

>>> from hydpy.models.evap_aet_hbv96 import *
>>> parameterstep()
>>> nmbhru(2)
>>> with model.add_intercmodel_v1("dummy_interceptedwater"):
...     nmbhru
nmbhru(2)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_SoilWaterModel_V1[source]

Bases: AdHocModel, SubmodelInterface

Base class for HydPy-Evap models that can use main models as their sub-submodels if they comply with the SoilWaterModel_V1 interface.

soilwatermodel: SubmodelProperty
soilwatermodel_is_mainmodel
soilwatermodel_typeid
add_mainmodel_as_subsubmodel(mainmodel: Model) → bool[source]

Add the given main model as a submodel if it complies with the SoilWaterModel_V1 interface.

>>> from hydpy import prepare_model
>>> evap = prepare_model("evap_aet_hbv96")
>>> evap.add_mainmodel_as_subsubmodel(prepare_model("evap_ret_io"))
False
>>> evap.soilwatermodel
>>> evap.soilwatermodel_is_mainmodel
False
>>> evap.soilwatermodel_typeid
0

>>> hland = prepare_model("hland_96")
>>> evap.add_mainmodel_as_subsubmodel(hland)
True
>>> evap.soilwatermodel is hland
True
>>> evap.soilwatermodel_is_mainmodel
True
>>> evap.soilwatermodel_typeid
1
add_soilwatermodel_v1

Initialise the given soil water model that follows the SoilWaterModel_V1 interface and set the number of its zones.

>>> from hydpy.models.evap_aet_hbv96 import *
>>> parameterstep()
>>> nmbhru(2)
>>> with model.add_soilwatermodel_v1("dummy_soilwater"):
...     nmbhru
nmbhru(2)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_SnowCoverModel_V1[source]

Bases: AdHocModel, SubmodelInterface

Base class for HydPy-Evap models that can use main models as their sub-submodels if they comply with the SnowCoverModel_V1 interface.

snowcovermodel: SubmodelProperty
snowcovermodel_is_mainmodel
snowcovermodel_typeid
add_mainmodel_as_subsubmodel(mainmodel: Model) → bool[source]

Add the given main model as a submodel if it complies with the SnowCoverModel_V1 interface.

>>> from hydpy import prepare_model
>>> evap = prepare_model("evap_aet_hbv96")
>>> evap.add_mainmodel_as_subsubmodel(prepare_model("evap_ret_io"))
False
>>> evap.snowcovermodel
>>> evap.snowcovermodel_is_mainmodel
False
>>> evap.snowcovermodel_typeid
0

>>> hland = prepare_model("hland_96")
>>> evap.add_mainmodel_as_subsubmodel(hland)
True
>>> evap.snowcovermodel is hland
True
>>> evap.snowcovermodel_is_mainmodel
True
>>> evap.snowcovermodel_typeid
1
add_snowcovermodel_v1

Initialise the given snow cover model that follows the SnowCoverModel_V1 interface and set the number of its zones.

>>> from hydpy.models.evap_aet_hbv96 import *
>>> parameterstep()
>>> nmbhru(2)
>>> with model.add_snowcovermodel_v1("dummy_snowcover"):
...     nmbhru
nmbhru(2)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_SnowyCanopyModel_V1[source]

Bases: AdHocModel, SubmodelInterface

Base class for HydPy-Evap models that can use main models as their sub-submodels if they comply with the SnowyCanopyModel_V1 interface.

snowycanopymodel: SubmodelProperty
snowycanopymodel_is_mainmodel
snowycanopymodel_typeid
add_mainmodel_as_subsubmodel(mainmodel: Model) → bool[source]

Add the given main model as a submodel if it complies with the SnowyCanopyModel_V1 interface.

>>> from hydpy import prepare_model
>>> evap = prepare_model("evap_aet_morsim")
>>> evap.add_mainmodel_as_subsubmodel(prepare_model("evap_ret_io"))
False
>>> evap.snowycanopymodel
>>> evap.snowycanopymodel_is_mainmodel
False
>>> evap.snowycanopymodel_typeid
0

>>> lland = prepare_model("lland_knauf_ic")
>>> evap.add_mainmodel_as_subsubmodel(lland)
True
>>> evap.snowycanopymodel is lland
True
>>> evap.snowycanopymodel_is_mainmodel
True
>>> evap.snowycanopymodel_typeid
1
add_snowycanopymodel_v1

Initialise the given snow cover model that follows the SnowyCanopyModel_V1 interface and set the number of its zones.

>>> from hydpy.models.evap_aet_morsim import *
>>> parameterstep()
>>> nmbhru(2)
>>> with model.add_snowycanopymodel_v1("dummy_snowycanopy"):
...     nmbhru
nmbhru(2)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()
class hydpy.models.evap.evap_model.Main_SnowAlbedoModel_V1[source]

Bases: AdHocModel, SubmodelInterface

Base class for HydPy-Evap models that can use main models as their sub-submodels if they comply with the SnowAlbedoModel_V1 interface.

snowalbedomodel: SubmodelProperty
snowalbedomodel_is_mainmodel
snowalbedomodel_typeid
add_mainmodel_as_subsubmodel(mainmodel: Model) → bool[source]

Add the given main model as a submodel if it complies with the SnowAlbedoModel_V1 interface.

>>> from hydpy import prepare_model
>>> evap = prepare_model("evap_aet_morsim")
>>> evap.add_mainmodel_as_subsubmodel(prepare_model("evap_ret_io"))
False
>>> evap.snowalbedomodel
>>> evap.snowalbedomodel_is_mainmodel
False
>>> evap.snowalbedomodel_typeid
0

>>> lland = prepare_model("lland_knauf")
>>> evap.add_mainmodel_as_subsubmodel(lland)
True
>>> evap.snowalbedomodel is lland
True
>>> evap.snowalbedomodel_is_mainmodel
True
>>> evap.snowalbedomodel_typeid
1
add_snowalbedomodel_v1

Initialise the given albedo model that follows the SnowAlbedoModel_V1 interface and set the number of its zones.

>>> from hydpy.models.evap_aet_morsim import *
>>> parameterstep()
>>> nmbhru(2)
>>> with model.add_snowalbedomodel_v1("dummy_snowalbedo"):
...     nmbhru
nmbhru(2)
REUSABLE_METHODS: ClassVar[tuple[type[ReusableMethod], ...]] = ()

Parameter Features

Parameter tools

class hydpy.models.evap.evap_parameters.LandMonthParameter(subvars: SubParameters)[source]

Bases: KeywordParameter2D

Base class for parameters whose values depend on the actual month and land cover type.

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2001-01-01", "1d"
>>> from hydpy.models.wland_wag import *
>>> parameterstep()
>>> nu(2)
>>> at(10.0)
>>> aur(0.2, 0.8)
>>> lt(FIELD, WATER)
>>> with model.add_petmodel_v1("evap_pet_mlc"):
...     pass
>>> model.petmodel.parameters.control.landmonthfactor
landmonthfactor(sealed=[nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
                ...
                water=[nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
                       nan, nan])
columnnames: tuple[str, ...] = ('jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec')
rownames: tuple[str, ...] = ('ANY',)
name: str = 'landmonthparameter'

Name of the variable in lowercase letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.evap.evap_parameters.ZipParameter1D(subvars: SubParameters)[source]

Bases: ZipParameter

Base class for 1-dimensional parameters that provide additional keyword-based zipping functionalities.

>>> from hydpy.models.hland_96 import *
>>> parameterstep()
>>> nmbzones(5)
>>> area(10.0)
>>> zonearea(0.5, 1.5, 2.5, 1.0, 4.5)
>>> zonetype(FIELD, FOREST, GLACIER, ILAKE, SEALED)
>>> zonez(2.0)
>>> fc(200.0)
>>> with model.add_aetmodel_v1("evap_aet_hbv96"):
...     soil
soil(field=True, forest=True, glacier=False, ilake=False, sealed=False)
>>> model.aetmodel.parameters.control.water
water(field=False, forest=False, glacier=False, ilake=True,
      sealed=False)
>>> model.aetmodel.parameters.control.water.average_values()
0.1
constants: dict[str, int] = {}

Mapping of the constants’ names and values.

mask: masktools.IndexMask
name: str = 'zipparameter1d'

Name of the variable in lowercase letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.evap.evap_parameters.SoilParameter1D(subvars: SubParameters)[source]

Bases: ZipParameter1D

Base class for soil-related 1-dimensional parameters.

>>> from hydpy.models.hland_96 import *
>>> parameterstep()
>>> nmbzones(6)
>>> area(9.0)
>>> zonearea(2.0, 3.0, 1.0, 1.0, 1.0, 1.0)
>>> zonetype(FIELD, FOREST, GLACIER, ILAKE, SEALED, FIELD)
>>> zonez(2.0)
>>> fc(200.0)
>>> with model.add_aetmodel_v1("evap_aet_hbv96"):
...     excessreduction(field=1.0, forest=0.5)
>>> model.aetmodel.parameters.control.excessreduction
excessreduction(field=1.0, forest=0.5)
>>> model.aetmodel.parameters.control.excessreduction.average_values()
0.75
mask: masktools.IndexMask
name: str = 'soilparameter1d'

Name of the variable in lowercase letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.evap.evap_parameters.PlantParameter1D(subvars: SubParameters)[source]

Bases: ZipParameter1D

Base class for plant-related 1-dimensional parameters.

>>> from hydpy.models.lland_dd import *
>>> parameterstep()
>>> nhru(6)
>>> lnk(WASSER, GLETS, BODEN, ACKER, BAUMB, MISCHW)
>>> ft(10.0)
>>> fhru(0.1, 0.1, 0.2, 0.1, 0.3, 0.2)
>>> wmax(200.0)
>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "1d"
>>> with model.add_aetmodel_v1("evap_aet_minhas"):
...     with model.add_petmodel_v2("evap_pet_ambav1"):
...         leafresistance(acker=30.0, baumb=40.0, mischw=50.0)
>>> r = model.aetmodel.petmodel.parameters.control.leafresistance
>>> r
leafresistance(acker=30.0, baumb=40.0, mischw=50.0)
>>> from hydpy import round_
>>> round_(r.average_values())
41.666667
mask: masktools.IndexMask
name: str = 'plantparameter1d'

Name of the variable in lowercase letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.evap.evap_parameters.WaterParameter1D(subvars: SubParameters)[source]

Bases: ZipParameter1D

Base class for water area-related 1-dimensional parameters.

>>> from hydpy.models.hland_96 import *
>>> parameterstep()
>>> nmbzones(5)
>>> area(6.0)
>>> zonearea(2.0, 1.0, 1.0, 1.0, 1.0)
>>> zonetype(ILAKE, FOREST, GLACIER, ILAKE, SEALED)
>>> zonez(2.0)
>>> fc(200.0)
>>> with model.add_aetmodel_v1("evap_aet_hbv96"):
...     temperaturethresholdice(ilake=1.0)
>>> model.aetmodel.parameters.control.temperaturethresholdice
temperaturethresholdice(1.0)
>>> model.aetmodel.parameters.control.temperaturethresholdice.average_values()
1.0
mask: masktools.IndexMask
name: str = 'waterparameter1d'

Name of the variable in lowercase letters.

unit: str = '?'

Unit of the variable.

Control parameters

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

Bases: SubParameters

Control parameters of model evap.

The following classes are selected:

  • NmbHRU() The number of separately modelled hydrological response units [-].

  • HRUType() Hydrological response unit type [-].

  • Water() A flag that indicates whether the individual zones are water areas or not.

  • Interception() A flag that indicates whether interception evaporation is relevant for the individual zones.

  • Soil() A flag that indicates whether soil evapotranspiration is relevant for the individual zones.

  • Plant() A flag that indicates whether the individual zones contain any vegetation.

  • Tree() A flag that indicates whether the individual zones contain tree-like vegetation.

  • Conifer() A flag that indicates whether the individual zones contain conifer-like vegetation.

  • HRUArea() The area of each hydrological response unit [km²].

  • HRUAltitude() The altitude of each hydrological response unit [m].

  • MeasuringHeightWindSpeed() The height above ground of the wind speed measurements [m].

  • CoastFactor() The “coast factor” of Turc-Wendling’s reference evapotranspiration equation [-].

  • Albedo() Earth surface albedo [-].

  • GroundAlbedo() The albedo of the snow-free ground (including soils, sealed surfaces, and water areas) [-].

  • GroundAlbedoSnow() The albedo of the snow-covered ground (including soils and sealed surfaces) [-].

  • LeafAlbedo() The albedo of the snow-free leaves [-].

  • LeafAlbedoSnow() The albedo of the snow-covered leaves [-].

  • LeafAreaIndex() Leaf area index [-].

  • CropHeight() Crop height [m].

  • CloudTypeFactor() Cloud type-specific factor for calculating atmospheric longwave counter radiation [-].

  • NightCloudFactor() Factor for adjusting daytime estimates of the cloud coverage degree to nighttime [-].

  • Emissivity() The emissivity of the land surface [-].

  • AverageSoilHeatFlux() Monthly averages of the soil heat flux [W/m²].

  • SurfaceResistance() Surface resistance of water areas, sealed areas, and vegetation with sufficient water supply [s/m].

  • WetSoilResistance() Surface resistance of wet soils [s/m].

  • SoilResistanceIncrease() Increase in soil surface resistance if evaporation dominates precipitation [s/m/T].

  • WetnessThreshold() The ratio between precipitation and potential evapotranspiration above which the topmost soil layer becomes wet [-].

  • LeafResistance() Surface resistance of plant leaves [s/m].

  • EvapotranspirationFactor() The adjustment factor for potential evapotranspiration [-].

  • MonthFactor() Factor for converting general potential evaporation or evapotranspiration (usually grass reference evapotranspiration) to month-specific potential evaporation or evapotranspiration [-].

  • LandMonthFactor() Factor for converting general potential evaporation or evapotranspiration (usually grass reference evapotranspiration) to land-use- and month-specific potential evaporation or evapotranspiration [-].

  • AltitudeFactor() Decrease of potential evapotranspiration with altitude [-1/100m].

  • PrecipitationFactor() Decrease in potential evapotranspiration due to precipitation [T/mm].

  • AirTemperatureFactor() Temperature factor related to the difference of current reference evapotranspiration and normal reference evapotranspiration [1/°C].

  • DampingFactor() Damping factor (temporal weighting factor) for potential evapotranspiration [-].

  • TemperatureThresholdIce() Temperature threshold for evaporation from water areas [°C].

  • MaxSoilWater() Maximum soil water content [mm].

  • SoilMoistureLimit() Relative soil moisture limit for potential evapotranspiration [-].

  • ExcessReduction() A factor for restricting actual to potential evapotranspiration [-].

  • DisseFactor() Factor for calculating actual soil evapotranspiration based on potential evapotranspiration estimates that follow the Disse (1995) formulation of the Minhas et al. (1974) equation.

class hydpy.models.evap.evap_control.NmbHRU(subvars: SubParameters)[source]

Bases: Parameter

The number of separately modelled hydrological response units [-].

Required by the methods:

Adjust_ReferenceEvapotranspiration_V1 Calc_ActualSurfaceResistance_V1 Calc_ActualSurfaceResistance_V2 Calc_ActualVapourPressure_V1 Calc_AerodynamicResistance_V1 Calc_AerodynamicResistance_V2 Calc_AirDensity_V1 Calc_AirTemperature_TempModel_V1 Calc_AirTemperature_TempModel_V2 Calc_AirTemperature_V1 Calc_CurrentAlbedo_SnowAlbedoModel_V1 Calc_CurrentAlbedo_V1 Calc_CurrentAlbedo_V2 Calc_DailyActualVapourPressure_V1 Calc_DailyAirTemperature_V1 Calc_DailyNetLongwaveRadiation_V1 Calc_DailyNetRadiation_V1 Calc_DailyNetShortwaveRadiation_V1 Calc_DailyPotentialSoilEvapotranspiration_V1 Calc_DailyPrecipitation_V1 Calc_DailySaturationVapourPressureSlope_V1 Calc_DailySaturationVapourPressure_V1 Calc_DailyWaterEvaporation_V1 Calc_DryAirPressure_V1 Calc_InterceptedWater_IntercModel_V1 Calc_InterceptedWater_V1 Calc_InterceptionEvaporation_V1 Calc_InterceptionEvaporation_V2 Calc_LanduseSurfaceResistance_V1 Calc_MeanPotentialEvapotranspiration_V1 Calc_MeanReferenceEvapotranspiration_V1 Calc_NetLongwaveRadiation_V1 Calc_NetLongwaveRadiation_V2 Calc_NetRadiation_V1 Calc_NetRadiation_V2 Calc_NetShortwaveRadiation_V1 Calc_NetShortwaveRadiation_V2 Calc_PotentialEvapotranspiration_V1 Calc_PotentialEvapotranspiration_V2 Calc_PotentialEvapotranspiration_V3 Calc_PotentialInterceptionEvaporation_PETModel_V1 Calc_PotentialInterceptionEvaporation_PETModel_V2 Calc_PotentialInterceptionEvaporation_V1 Calc_PotentialInterceptionEvaporation_V2 Calc_PotentialInterceptionEvaporation_V3 Calc_PotentialSoilEvapotranspiration_PETModel_V1 Calc_PotentialSoilEvapotranspiration_PETModel_V2 Calc_PotentialSoilEvapotranspiration_V1 Calc_PotentialSoilEvapotranspiration_V2 Calc_PotentialWaterEvaporation_PETModel_V1 Calc_PotentialWaterEvaporation_PETModel_V2 Calc_PotentialWaterEvaporation_V1 Calc_Precipitation_PrecipModel_V1 Calc_Precipitation_PrecipModel_V2 Calc_ReferenceEvapotranspiration_PETModel_V1 Calc_ReferenceEvapotranspiration_V1 Calc_ReferenceEvapotranspiration_V2 Calc_ReferenceEvapotranspiration_V3 Calc_ReferenceEvapotranspiration_V4 Calc_ReferenceEvapotranspiration_V5 Calc_SaturationVapourPressureSlope_V1 Calc_SaturationVapourPressureSlope_V2 Calc_SaturationVapourPressure_V1 Calc_SaturationVapourPressure_V2 Calc_SnowCover_SnowCoverModel_V1 Calc_SnowCover_V1 Calc_SnowyCanopy_SnowyCanopyModel_V1 Calc_SnowyCanopy_V1 Calc_SoilEvapotranspiration_V1 Calc_SoilEvapotranspiration_V2 Calc_SoilEvapotranspiration_V3 Calc_SoilHeatFlux_V1 Calc_SoilHeatFlux_V2 Calc_SoilHeatFlux_V3 Calc_SoilHeatFlux_V4 Calc_SoilSurfaceResistance_V1 Calc_SoilWater_SoilWaterModel_V1 Calc_SoilWater_V1 Calc_WaterEvaporation_V1 Calc_WaterEvaporation_V2 Calc_WaterEvaporation_V3 Calc_WaterEvaporation_V4 Determine_InterceptionEvaporation_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_SoilEvapotranspiration_V1 Determine_SoilEvapotranspiration_V2 Determine_SoilEvapotranspiration_V3 Determine_WaterEvaporation_V1 Determine_WaterEvaporation_V2 Determine_WaterEvaporation_V3 Update_LoggedAirTemperature_V1 Update_LoggedPotentialSoilEvapotranspiration_V1 Update_LoggedPrecipitation_V1 Update_LoggedWaterEvaporation_V1 Update_PotentialEvapotranspiration_V1 Update_SoilEvapotranspiration_V1 Update_SoilEvapotranspiration_V2 Update_SoilEvapotranspiration_V3 Update_SoilResistance_V1

NDIM: int = 0
TYPE

alias of int

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0, None)
name: str = 'nmbhru'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.HRUType(subvars: SubParameters)[source]

Bases: NameParameter

Hydrological response unit type [-].

Required by the methods:

Calc_ActualSurfaceResistance_V1 Calc_ActualSurfaceResistance_V2 Calc_AerodynamicResistance_V1 Calc_AerodynamicResistance_V2 Calc_CurrentAlbedo_V1 Calc_CurrentAlbedo_V2 Calc_LanduseSurfaceResistance_V1 Calc_PotentialEvapotranspiration_V2 Calc_SoilHeatFlux_V4 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_SoilEvapotranspiration_V3

NDIM: int = 1
TYPE

alias of int

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (None, None)
constants: Constants = {'ANY': 0}
name: str = 'hrutype'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.Water(subvars: SubParameters)[source]

Bases: ZipParameter1D

A flag that indicates whether the individual zones are water areas or not.

Required by the methods:

Calc_SoilHeatFlux_V2 Calc_SoilHeatFlux_V3 Calc_SoilHeatFlux_V4 Calc_WaterEvaporation_V1 Calc_WaterEvaporation_V2 Calc_WaterEvaporation_V3 Calc_WaterEvaporation_V4 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_WaterEvaporation_V1 Determine_WaterEvaporation_V2 Determine_WaterEvaporation_V3

TYPE

alias of bool

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (False, True)
name: str = 'water'

Name of the variable in lowercase letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.evap.evap_control.Interception(subvars: SubParameters)[source]

Bases: ZipParameter1D

A flag that indicates whether interception evaporation is relevant for the individual zones.

Required by the methods:

Calc_InterceptionEvaporation_V1 Calc_InterceptionEvaporation_V2 Calc_PotentialInterceptionEvaporation_V1 Calc_PotentialInterceptionEvaporation_V2 Determine_InterceptionEvaporation_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_SoilEvapotranspiration_V2 Determine_SoilEvapotranspiration_V3 Update_SoilEvapotranspiration_V3

TYPE

alias of bool

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (False, True)
name: str = 'interception'

Name of the variable in lowercase letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.evap.evap_control.Soil(subvars: SubParameters)[source]

Bases: ZipParameter1D

A flag that indicates whether soil evapotranspiration is relevant for the individual zones.

Required by the methods:

Calc_ActualSurfaceResistance_V1 Calc_ActualSurfaceResistance_V2 Calc_CurrentAlbedo_V2 Calc_LanduseSurfaceResistance_V1 Calc_PotentialSoilEvapotranspiration_V1 Calc_SoilEvapotranspiration_V1 Calc_SoilEvapotranspiration_V2 Calc_SoilEvapotranspiration_V3 Calc_SoilSurfaceResistance_V1 Determine_PotentialInterceptionEvaporation_V1 Determine_SoilEvapotranspiration_V1 Determine_SoilEvapotranspiration_V2 Determine_SoilEvapotranspiration_V3 Update_SoilEvapotranspiration_V1 Update_SoilEvapotranspiration_V2 Update_SoilEvapotranspiration_V3 Update_SoilResistance_V1

TYPE

alias of bool

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (False, True)
name: str = 'soil'

Name of the variable in lowercase letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.evap.evap_control.Plant(subvars: SubParameters)[source]

Bases: ZipParameter1D

A flag that indicates whether the individual zones contain any vegetation.

Required by the methods:

Calc_ActualSurfaceResistance_V2 Calc_CurrentAlbedo_V2 Determine_PotentialInterceptionEvaporation_V1

TYPE

alias of bool

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (False, True)
name: str = 'plant'

Name of the variable in lowercase letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.evap.evap_control.Tree(subvars: SubParameters)[source]

Bases: ZipParameter1D

A flag that indicates whether the individual zones contain tree-like vegetation.

Required by the methods:

Calc_InterceptionEvaporation_V2 Calc_SoilEvapotranspiration_V3 Determine_InterceptionEvaporation_V2 Determine_SoilEvapotranspiration_V3

TYPE

alias of bool

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (False, True)
name: str = 'tree'

Name of the variable in lowercase letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.evap.evap_control.Conifer(subvars: SubParameters)[source]

Bases: ZipParameter1D

A flag that indicates whether the individual zones contain conifer-like vegetation.

Required by the methods:

Calc_LanduseSurfaceResistance_V1 Determine_SoilEvapotranspiration_V3

TYPE

alias of bool

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (False, True)
name: str = 'conifer'

Name of the variable in lowercase letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.evap.evap_control.HRUArea(subvars: SubParameters)[source]

Bases: Parameter

The area of each hydrological response unit [km²].

NDIM: int = 1
TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
name: str = 'hruarea'

Name of the variable in lowercase letters.

unit: str = 'km²'

Unit of the variable.

class hydpy.models.evap.evap_control.HRUAltitude(subvars: SubParameters)[source]

Bases: ZipParameter1D

The altitude of each hydrological response unit [m].

Required by the methods:

Calc_PotentialEvapotranspiration_V3 Calc_ReferenceEvapotranspiration_V2

TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (None, None)
INIT: int | float | bool | None = 0.0
name: str = 'hrualtitude'

Name of the variable in lowercase letters.

unit: str = 'm'

Unit of the variable.

class hydpy.models.evap.evap_control.MeasuringHeightWindSpeed(subvars: SubParameters)[source]

Bases: Parameter

The height above ground of the wind speed measurements [m].

Required by the methods:

Calc_WindSpeed10m_V1 Calc_WindSpeed2m_V1 Calc_WindSpeed2m_V2 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_WaterEvaporation_V3 Return_AdjustedWindSpeed_V1

NDIM: int = 0
TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0, None)
INIT: int | float | bool | None = 10.0
name: str = 'measuringheightwindspeed'

Name of the variable in lowercase letters.

unit: str = 'm'

Unit of the variable.

class hydpy.models.evap.evap_control.AirTemperatureAddend(subvars: SubParameters)[source]

Bases: ZipParameter1D

Adjustment addend for air temperature [K].

TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (None, None)
INIT: int | float | bool | None = 0.0
name: str = 'airtemperatureaddend'

Name of the variable in lowercase letters.

unit: str = 'K'

Unit of the variable.

class hydpy.models.evap.evap_control.CoastFactor(subvars: SubParameters)[source]

Bases: ZipParameter1D

The “coast factor” of Turc-Wendling’s reference evapotranspiration equation [-].

Required by the method:

Calc_ReferenceEvapotranspiration_V2

TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.6, 1.0)
INIT: int | float | bool | None = 1.0
name: str = 'coastfactor'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.Albedo(subvars: SubParameters)[source]

Bases: LandMonthParameter

Earth surface albedo [-].

Required by the methods:

Calc_CurrentAlbedo_V1 Determine_InterceptionEvaporation_V2

TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)
INIT: int | float | bool | None = 0.5
name: str = 'albedo'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.GroundAlbedo(subvars: SubParameters)[source]

Bases: ZipParameter1D

The albedo of the snow-free ground (including soils, sealed surfaces, and water areas) [-].

Required by the methods:

Calc_CurrentAlbedo_V2 Determine_PotentialInterceptionEvaporation_V1

TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)
INIT: int | float | bool | None = 0.2
name: str = 'groundalbedo'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.GroundAlbedoSnow(subvars: SubParameters)[source]

Bases: ZipParameter1D

The albedo of the snow-covered ground (including soils and sealed surfaces) [-].

Required by the methods:

Calc_CurrentAlbedo_V2 Determine_PotentialInterceptionEvaporation_V1

TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)
INIT: int | float | bool | None = 0.8
name: str = 'groundalbedosnow'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.LeafAlbedo(subvars: SubParameters)[source]

Bases: PlantParameter1D

The albedo of the snow-free leaves [-].

Required by the methods:

Calc_CurrentAlbedo_V2 Determine_PotentialInterceptionEvaporation_V1

TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)
INIT: int | float | bool | None = 0.2
name: str = 'leafalbedo'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.LeafAlbedoSnow(subvars: SubParameters)[source]

Bases: PlantParameter1D

The albedo of the snow-covered leaves [-].

Required by the methods:

Calc_CurrentAlbedo_V2 Determine_PotentialInterceptionEvaporation_V1

TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)
INIT: int | float | bool | None = 0.8
name: str = 'leafalbedosnow'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.LeafAreaIndex(subvars: SubParameters)[source]

Bases: LandMonthParameter

Leaf area index [-].

Required by the methods:

Calc_ActualSurfaceResistance_V1 Calc_ActualSurfaceResistance_V2 Calc_CurrentAlbedo_V2 Calc_SoilHeatFlux_V2 Calc_SoilHeatFlux_V4 Determine_PotentialInterceptionEvaporation_V1 Determine_SoilEvapotranspiration_V3

TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
INIT: int | float | bool | None = 5.0
name: str = 'leafareaindex'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.CropHeight(subvars: SubParameters)[source]

Bases: LandMonthParameter

Crop height [m].

Required by the methods:

Calc_AerodynamicResistance_V1 Determine_InterceptionEvaporation_V2

TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
INIT: int | float | bool | None = 1.0
name: str = 'cropheight'

Name of the variable in lowercase letters.

unit: str = 'm'

Unit of the variable.

class hydpy.models.evap.evap_control.CloudTypeFactor(subvars: SubParameters)[source]

Bases: Parameter

Cloud type-specific factor for calculating atmospheric longwave counter radiation [-].

Required by the methods:

Calc_NetLongwaveRadiation_V2 Determine_PotentialInterceptionEvaporation_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.2
name: str = 'cloudtypefactor'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.NightCloudFactor(subvars: SubParameters)[source]

Bases: Parameter

Factor for adjusting daytime estimates of the cloud coverage degree to nighttime [-].

Required by the methods:

Calc_AdjustedCloudCoverage_V1 Determine_PotentialInterceptionEvaporation_V1

NDIM: int = 0
TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
INIT: int | float | bool | None = 1.0
name: str = 'nightcloudfactor'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.Emissivity(subvars: SubParameters)[source]

Bases: Parameter

The emissivity of the land surface [-].

Required by the methods:

Calc_DailyNetLongwaveRadiation_V1 Calc_PotentialInterceptionEvaporation_V1 Calc_SoilEvapotranspiration_V3 Determine_InterceptionEvaporation_V2 Determine_SoilEvapotranspiration_V3 Return_Evaporation_PenmanMonteith_V1

NDIM: int = 0
TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)
INIT: int | float | bool | None = 0.95
name: str = 'emissivity'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.AverageSoilHeatFlux(subvars: SubParameters)[source]

Bases: MonthParameter

Monthly averages of the soil heat flux [W/m²].

Required by the methods:

Calc_SoilHeatFlux_V2 Calc_SoilHeatFlux_V3 Determine_InterceptionEvaporation_V2

NDIM: int = 1
TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (None, None)
INIT: int | float | bool | None = 0.0
name: str = 'averagesoilheatflux'

Name of the variable in lowercase letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.evap.evap_control.SurfaceResistance(subvars: SubParameters)[source]

Bases: LandMonthParameter

Surface resistance of water areas, sealed areas, and vegetation with sufficient water supply [s/m].

Required by the methods:

Calc_LanduseSurfaceResistance_V1 Determine_SoilEvapotranspiration_V3

TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
INIT: int | float | bool | None = 100.0
name: str = 'surfaceresistance'

Name of the variable in lowercase letters.

unit: str = 's/m'

Unit of the variable.

class hydpy.models.evap.evap_control.WetSoilResistance(subvars: SubParameters)[source]

Bases: SoilParameter1D

Surface resistance of wet soils [s/m].

Required by the method:

Update_SoilResistance_V1

TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
INIT: int | float | bool | None = 100.0
name: str = 'wetsoilresistance'

Name of the variable in lowercase letters.

unit: str = 's/m'

Unit of the variable.

class hydpy.models.evap.evap_control.SoilResistanceIncrease(subvars: SubParameters)[source]

Bases: SoilParameter1D

Increase in soil surface resistance if evaporation dominates precipitation [s/m/T].

Required by the method:

Update_SoilResistance_V1

TYPE

alias of float

TIME: bool | None = True
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
INIT: int | float | bool | None = 0.0
name: str = 'soilresistanceincrease'

Name of the variable in lowercase letters.

unit: str = 's/m/T'

Unit of the variable.

class hydpy.models.evap.evap_control.WetnessThreshold(subvars: SubParameters)[source]

Bases: SoilParameter1D

The ratio between precipitation and potential evapotranspiration above which the topmost soil layer becomes wet [-].

Required by the methods:

Calc_CurrentAlbedo_V2 Determine_PotentialInterceptionEvaporation_V1 Update_SoilResistance_V1

TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
INIT: int | float | bool | None = 1.0
name: str = 'wetnessthreshold'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.LeafResistance(subvars: SubParameters)[source]

Bases: PlantParameter1D

Surface resistance of plant leaves [s/m].

Required by the method:

Calc_ActualSurfaceResistance_V2

TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
INIT: int | float | bool | None = 100.0
name: str = 'leafresistance'

Name of the variable in lowercase letters.

unit: str = 's/m'

Unit of the variable.

class hydpy.models.evap.evap_control.EvapotranspirationFactor(subvars: SubParameters)[source]

Bases: ZipParameter1D

The adjustment factor for potential evapotranspiration [-].

Required by the method:

Adjust_ReferenceEvapotranspiration_V1

TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
INIT: int | float | bool | None = 1.0
name: str = 'evapotranspirationfactor'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.MonthFactor(subvars: SubParameters)[source]

Bases: MonthParameter

Factor for converting general potential evaporation or evapotranspiration (usually grass reference evapotranspiration) to month-specific potential evaporation or evapotranspiration [-].

Required by the method:

Calc_PotentialEvapotranspiration_V1

NDIM: int = 1
TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
name: str = 'monthfactor'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.LandMonthFactor(subvars: SubParameters)[source]

Bases: LandMonthParameter

Factor for converting general potential evaporation or evapotranspiration (usually grass reference evapotranspiration) to land-use- and month-specific potential evaporation or evapotranspiration [-].

Required by the method:

Calc_PotentialEvapotranspiration_V2

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

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.AltitudeFactor(subvars: SubParameters)[source]

Bases: ZipParameter1D

Decrease of potential evapotranspiration with altitude [-1/100m].

Required by the method:

Calc_PotentialEvapotranspiration_V3

In the terminology of HBV96: ECAlt.

NDIM: int = 1
TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (None, None)
INIT: int | float | bool | None = 0.1
name: str = 'altitudefactor'

Name of the variable in lowercase letters.

unit: str = '-1/100m'

Unit of the variable.

class hydpy.models.evap.evap_control.PrecipitationFactor(subvars: SubParameters)[source]

Bases: ZipParameter1D

Decrease in potential evapotranspiration due to precipitation [T/mm].

Required by the method:

Calc_PotentialEvapotranspiration_V3

In the terminology of HBV96: EPF.

NDIM: int = 1
TYPE

alias of float

TIME: bool | None = False
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
INIT: int | float | bool | None = 0.0
name: str = 'precipitationfactor'

Name of the variable in lowercase letters.

unit: str = 'T/mm'

Unit of the variable.

class hydpy.models.evap.evap_control.AirTemperatureFactor(subvars: SubParameters)[source]

Bases: ZipParameter1D

Temperature factor related to the difference of current reference evapotranspiration and normal reference evapotranspiration [1/°C].

Required by the method:

Calc_ReferenceEvapotranspiration_V5

In the terminology of HBV96: ETF.

NDIM: int = 1
TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (None, None)
INIT: int | float | bool | None = 0.1
name: str = 'airtemperaturefactor'

Name of the variable in lowercase letters.

unit: str = '1/°C'

Unit of the variable.

class hydpy.models.evap.evap_control.DampingFactor(subvars: SubParameters)[source]

Bases: ZipParameter1D

Damping factor (temporal weighting factor) for potential evapotranspiration [-].

Required by the method:

Update_PotentialEvapotranspiration_V1

NDIM: int = 1
TYPE

alias of float

TIME: bool | None = True
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)
INIT: int | float | bool | None = 0.0
name: str = 'dampingfactor'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.TemperatureThresholdIce(subvars: SubParameters)[source]

Bases: WaterParameter1D

Temperature threshold for evaporation from water areas [°C].

Required by the methods:

Calc_WaterEvaporation_V1 Determine_WaterEvaporation_V1

In the terminology of HBV96: TTIce.

NDIM: int = 1
TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (None, None)
name: str = 'temperaturethresholdice'

Name of the variable in lowercase letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.evap.evap_control.MaxSoilWater(subvars: SubParameters)[source]

Bases: SoilParameter1D

Maximum soil water content [mm].

Required by the methods:

Calc_LanduseSurfaceResistance_V1 Calc_SoilEvapotranspiration_V1 Calc_SoilEvapotranspiration_V2 Calc_SoilSurfaceResistance_V1 Determine_SoilEvapotranspiration_V1 Determine_SoilEvapotranspiration_V2 Determine_SoilEvapotranspiration_V3

In the terminology of HBV96: FC.

NDIM: int = 1
TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
INIT: int | float | bool | None = 200.0
name: str = 'maxsoilwater'

Name of the variable in lowercase letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.evap.evap_control.SoilMoistureLimit(subvars: SubParameters)[source]

Bases: SoilParameter1D

Relative soil moisture limit for potential evapotranspiration [-].

Required by the methods:

Calc_LanduseSurfaceResistance_V1 Calc_SoilEvapotranspiration_V1 Determine_SoilEvapotranspiration_V1 Determine_SoilEvapotranspiration_V3

In the terminology of HBV96: LP. Typical value: 0.9.

In the terminology of MORECS: PY. Typical value: 0.6.

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)
INIT: int | float | bool | None = 0.9
name: str = 'soilmoisturelimit'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.ExcessReduction(subvars: SubParameters)[source]

Bases: SoilParameter1D

A factor for restricting actual to potential evapotranspiration [-].

Required by the methods:

Determine_SoilEvapotranspiration_V1 Update_SoilEvapotranspiration_V1

In the terminology of HBV96: ERED.

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

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_control.DisseFactor(subvars: SubParameters)[source]

Bases: SoilParameter1D

Factor for calculating actual soil evapotranspiration based on potential evapotranspiration estimates that follow the Disse (1995) formulation of the Minhas et al. (1974) equation.

Required by the methods:

Calc_SoilEvapotranspiration_V2 Determine_SoilEvapotranspiration_V2

In the terminology of Minhas et al. (1974) and Disse (1995): r.

In the terminology of LARSIM: GRASREF_R.

NDIM: int = 1
TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
INIT: int | float | bool | None = 5.0
name: str = 'dissefactor'

Name of the variable in lowercase letters.

unit: str = '?'

Unit of the variable.

Derived parameters

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

Bases: SubParameters

Derived parameters of model evap.

The following classes are selected:

  • MOY() References the “global” month of the year index array [-].

  • HRUAreaFraction() The area fraction of each hydrological response unit [-].

  • Altitude() Average (reference) subbasin altitude [100m].

  • Hours() The length of the actual simulation step size in hours [h].

  • Days() The length of the actual simulation step size in days [d].

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

  • RoughnessLength() Roughness length [m].

  • AerodynamicResistanceFactor() Factor for calculating aerodynamic resistance [-].

class hydpy.models.evap.evap_derived.MOY(subvars: SubParameters)[source]

Bases: MOYParameter

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

Required by the methods:

Calc_ActualSurfaceResistance_V1 Calc_ActualSurfaceResistance_V2 Calc_AerodynamicResistance_V1 Calc_AerodynamicResistance_V2 Calc_CurrentAlbedo_V1 Calc_CurrentAlbedo_V2 Calc_LanduseSurfaceResistance_V1 Calc_PotentialEvapotranspiration_V1 Calc_PotentialEvapotranspiration_V2 Calc_SoilHeatFlux_V2 Calc_SoilHeatFlux_V3 Calc_SoilHeatFlux_V4 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_SoilEvapotranspiration_V3

name: str = 'moy'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_derived.HRUAreaFraction(subvars: SubParameters)[source]

Bases: Parameter

The area fraction of each hydrological response unit [-].

Required by the methods:

Calc_MeanPotentialEvapotranspiration_V1 Calc_MeanReferenceEvapotranspiration_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)
update() → None[source]

Calculate the fractions based on \(HRUAreaFraction_i = HRUArea_i / \Sigma HRUArea\).

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(5)
>>> hruarea(10.0, 40.0, 20.0, 25.0, 5.0)
>>> derived.hruareafraction.update()
>>> derived.hruareafraction
hruareafraction(0.1, 0.4, 0.2, 0.25, 0.05)
name: str = 'hruareafraction'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_derived.Altitude(subvars: SubParameters)[source]

Bases: Parameter

Average (reference) subbasin altitude [100m].

Required by the method:

Calc_PotentialEvapotranspiration_V3

NDIM: int = 0
TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (None, None)
update() → None[source]

Average the individual hydrological response units’ altitudes.

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(3)
>>> hruarea(5.0, 3.0, 2.0)
>>> hrualtitude(1.0, 3.0, 8.0)
>>> derived.altitude.update()
>>> derived.altitude
altitude(3.0)
name: str = 'altitude'

Name of the variable in lowercase letters.

unit: str = '100m'

Unit of the variable.

class hydpy.models.evap.evap_derived.Seconds(subvars: SubParameters)[source]

Bases: SecondsParameter

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

name: str = 'seconds'

Name of the variable in lowercase letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.evap.evap_derived.Hours(subvars: SubParameters)[source]

Bases: HoursParameter

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

Required by the methods:

Calc_ActualSurfaceResistance_V1 Calc_ActualSurfaceResistance_V2 Calc_AdjustedCloudCoverage_V1 Calc_ReferenceEvapotranspiration_V1 Calc_SoilHeatFlux_V2 Calc_SoilHeatFlux_V4 Determine_PotentialInterceptionEvaporation_V1 Determine_SoilEvapotranspiration_V3 Update_CloudCoverage_V1

name: str = 'hours'

Name of the variable in lowercase letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.evap.evap_derived.Days(subvars: SubParameters)[source]

Bases: DaysParameter

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

Required by the methods:

Calc_ReferenceEvapotranspiration_V1 Calc_SoilHeatFlux_V1 Calc_WaterEvaporation_V3 Determine_PotentialInterceptionEvaporation_V1 Determine_WaterEvaporation_V3 Get_PotentialWaterEvaporation_V1 Update_CloudCoverage_V1

name: str = 'days'

Name of the variable in lowercase letters.

unit: str = 'd'

Unit of the variable.

class hydpy.models.evap.evap_derived.NmbLogEntries(subvars: SubParameters)[source]

Bases: Parameter

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

Required by the methods:

Calc_DailyAirTemperature_V1 Calc_DailyGlobalRadiation_V1 Calc_DailyPossibleSunshineDuration_V1 Calc_DailyPotentialSoilEvapotranspiration_V1 Calc_DailyPrecipitation_V1 Calc_DailyRelativeHumidity_V1 Calc_DailySunshineDuration_V1 Calc_DailyWaterEvaporation_V1 Calc_DailyWindSpeed2m_V1 Calc_NetLongwaveRadiation_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_WaterEvaporation_V3 Update_LoggedAirTemperature_V1 Update_LoggedClearSkySolarRadiation_V1 Update_LoggedGlobalRadiation_V1 Update_LoggedPossibleSunshineDuration_V1 Update_LoggedPotentialSoilEvapotranspiration_V1 Update_LoggedPrecipitation_V1 Update_LoggedRelativeHumidity_V1 Update_LoggedSunshineDuration_V1 Update_LoggedWaterEvaporation_V1 Update_LoggedWindSpeed2m_V1

NDIM: int = 0
TYPE

alias of int

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (1, None)
update()[source]

Calculate the number of entries and adjust the shape of all relevant log sequences.

The aimed memory duration is one day. Hence, the number of required log entries depends on the simulation step size:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> from hydpy import pub
>>> pub.timegrids = "2000-01-01", "2000-01-02", "8h"
>>> nmbhru(2)
>>> derived.nmblogentries.update()
>>> derived.nmblogentries
nmblogentries(3)
>>> logs.loggedglobalradiation
loggedglobalradiation(nan, nan, nan)

For 1-dimensional logged properties, there is a second axis whose size depends on the selected number of hydrological response units:

>>> logs.loggedairtemperature
loggedairtemperature([[nan, nan],
                      [nan, nan],
                      [nan, nan]])

>>> logs.loggedpotentialevapotranspiration
loggedpotentialevapotranspiration(nan, nan, nan)

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

>>> logs.loggedglobalradiation = 1.0
>>> logs.loggedairtemperature = 2.0
>>> logs.loggedpotentialevapotranspiration = 3.0
>>> derived.nmblogentries.update()
>>> logs.loggedglobalradiation
loggedglobalradiation(1.0, 1.0, 1.0)
>>> logs.loggedairtemperature
loggedairtemperature([[2.0, 2.0],
                      [2.0, 2.0],
                      [2.0, 2.0]])
>>> logs.loggedpotentialevapotranspiration
loggedpotentialevapotranspiration(3.0, 3.0, 3.0)

There is an explicit check for inappropriate simulation step sizes:

>>> pub.timegrids = "2000-01-01 00:00", "2000-01-01 10:00", "5h"
>>> derived.nmblogentries.update()
Traceback (most recent call last):
...
ValueError: The value of parameter `nmblogentries` of element `?` cannot be determined for a the current simulation step size.  The fraction of the memory period (1d) and the simulation step size (5h) leaves a remainder.
name: str = 'nmblogentries'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_derived.RoughnessLength(subvars: SubParameters)[source]

Bases: LandMonthParameter

Roughness length [m].

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 roughness length based on \(max(0.13 \cdot CropHeight, \ 0.00013)\).

The original equation seems to go back to Montheith. We added the minimum value of 0.13 mm to cope with water areas and bare soils (to avoid zero roughness lengths):

ToDo: Add a reference.

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> nmbhru(3)
>>> cropheight(
...     ANY=[0.0, 0.001, 0.01, 0.1, 1.0, 2.0, 3.0, 4.0, 5.0, 10.0, 15.0, 20.0])
>>> derived.roughnesslength.update()
>>> derived.roughnesslength
roughnesslength(ANY=[0.00013, 0.00013, 0.0013, 0.013, 0.13, 0.26, 0.39,
                     0.52, 0.65, 1.3, 1.95, 2.6])
name: str = 'roughnesslength'

Name of the variable in lowercase letters.

unit: str = 'm'

Unit of the variable.

class hydpy.models.evap.evap_derived.AerodynamicResistanceFactor(subvars: SubParameters)[source]

Bases: LandMonthParameter

Factor for calculating aerodynamic resistance [-].

Required by the methods:

Calc_AerodynamicResistance_V2 Determine_PotentialInterceptionEvaporation_V1

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 factor for calculating aerodynamic resistance based on the \(max \big( ln(2 / z_0) \cdot ln(10 / z_0) / 0.41^2, \ \tau \big)\) with \(z_0\) being the RoughnessLength (Löpmeier, 2014) and \(\tau\) the “alternative value” suggested by Thompson et al. (1981) and also used by LEG (2020).

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> derived.roughnesslength(
...     ANY=[0.00013, 0.00013, 0.0013, 0.013, 0.13, 0.26, 0.39, 0.52, 0.65,
...          1.3, 1.95, 2.6])
>>> derived.aerodynamicresistancefactor.update()
>>> derived.aerodynamicresistancefactor
aerodynamicresistancefactor(ANY=[752.975177, 752.975177, 476.301466,
                                 262.708041, 112.194903, 94.0, 94.0, 94.0,
                                 94.0, 94.0, 94.0, 94.0])
name: str = 'aerodynamicresistancefactor'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

Fixed parameters

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

Bases: SubParameters

Fixed parameters of model evap.

The following classes are selected:
class hydpy.models.evap.evap_fixed.StefanBoltzmannConstant(subvars: SubParameters)[source]

Bases: FixedParameter

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

Required by the methods:

Calc_DailyNetLongwaveRadiation_V1 Calc_NetLongwaveRadiation_V2 Calc_PotentialInterceptionEvaporation_V1 Calc_SoilEvapotranspiration_V3 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_SoilEvapotranspiration_V3 Return_Evaporation_PenmanMonteith_V1

NDIM: int = 0
TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
INIT: int | float | bool = 5.67e-08
name: str = 'stefanboltzmannconstant'

Name of the variable in lowercase letters.

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

Unit of the variable.

class hydpy.models.evap.evap_fixed.FactorCounterRadiation(subvars: SubParameters)[source]

Bases: FixedParameter

A factor for adjusting the atmospheric counter radiation [-].

Required by the methods:

Calc_DailyNetLongwaveRadiation_V1 Determine_InterceptionEvaporation_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)
INIT: int | float | bool = 1.28
name: str = 'factorcounterradiation'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_fixed.GasConstantDryAir(subvars: SubParameters)[source]

Bases: FixedParameter

Gas constant for dry air [J/kg/K].

Required by the methods:

Calc_AirDensity_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_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 = 287.058
name: str = 'gasconstantdryair'

Name of the variable in lowercase letters.

unit: str = 'J/kg/K'

Unit of the variable.

class hydpy.models.evap.evap_fixed.GasConstantWaterVapour(subvars: SubParameters)[source]

Bases: FixedParameter

Gas constant for water vapour [J/kg/K].

Required by the methods:

Calc_AirDensity_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_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 = 461.495
name: str = 'gasconstantwatervapour'

Name of the variable in lowercase letters.

unit: str = 'J/kg/K'

Unit of the variable.

class hydpy.models.evap.evap_fixed.HeatCapacityAir(subvars: SubParameters)[source]

Bases: FixedParameter

Specific heat capacity of air [J/kg/K].

Required by the methods:

Calc_PotentialInterceptionEvaporation_V1 Calc_PotentialInterceptionEvaporation_V2 Calc_PotentialSoilEvapotranspiration_V1 Calc_SoilEvapotranspiration_V3 Calc_WaterEvaporation_V4 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_SoilEvapotranspiration_V3 Return_Evaporation_PenmanMonteith_V1 Return_Evaporation_PenmanMonteith_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)
INIT: int | float | bool = 1005.0
name: str = 'heatcapacityair'

Name of the variable in lowercase letters.

unit: str = 'J/kg/K'

Unit of the variable.

class hydpy.models.evap.evap_fixed.HeatOfCondensation(subvars: SubParameters)[source]

Bases: FixedParameter

Latent condensation heat of water at 15°C [WT/kg].

Required by the methods:

Calc_PotentialInterceptionEvaporation_V1 Calc_PotentialInterceptionEvaporation_V2 Calc_PotentialSoilEvapotranspiration_V1 Calc_SoilEvapotranspiration_V3 Calc_WaterEvaporation_V3 Calc_WaterEvaporation_V4 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_SoilEvapotranspiration_V3 Determine_WaterEvaporation_V3 Return_Evaporation_PenmanMonteith_V1 Return_Evaporation_PenmanMonteith_V2

NDIM: int = 0
TYPE

alias of float

TIME: bool | None = False
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
INIT: int | float | bool = 28.5
name: str = 'heatofcondensation'

Name of the variable in lowercase letters.

unit: str = 'WT/kg'

Unit of the variable.

class hydpy.models.evap.evap_fixed.RoughnessLengthGrass(subvars: SubParameters)[source]

Bases: FixedParameter

Roughness length for short grass [m].

Required by the methods:

Calc_WindSpeed10m_V1 Calc_WindSpeed2m_V2 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_WaterEvaporation_V3 Return_AdjustedWindSpeed_V1

NDIM: int = 0
TYPE

alias of float

TIME: bool | None = None
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
INIT: int | float | bool = 0.003
name: str = 'roughnesslengthgrass'

Name of the variable in lowercase letters.

unit: str = 'm'

Unit of the variable.

class hydpy.models.evap.evap_fixed.PsychrometricConstant(subvars: SubParameters)[source]

Bases: FixedParameter

Psychrometric constant [hPa/K].

Required by the methods:

Calc_PotentialInterceptionEvaporation_V1 Calc_PotentialInterceptionEvaporation_V2 Calc_PotentialSoilEvapotranspiration_V1 Calc_SoilEvapotranspiration_V3 Calc_WaterEvaporation_V3 Calc_WaterEvaporation_V4 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_SoilEvapotranspiration_V3 Determine_WaterEvaporation_V3 Return_Evaporation_PenmanMonteith_V1 Return_Evaporation_PenmanMonteith_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)
INIT: int | float | bool = 0.655
name: str = 'psychrometricconstant'

Name of the variable in lowercase letters.

unit: str = 'hPa/K'

Unit of the variable.

class hydpy.models.evap.evap_fixed.AerodynamicResistanceFactorMinimum(subvars: SubParameters)[source]

Bases: FixedParameter

The lowest allowed factor for calculating aerodynamic resistance [-].

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 = 94.0
name: str = 'aerodynamicresistancefactorminimum'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

Sequence Features

Sequence tools

class hydpy.models.evap.evap_sequences.FactorSequence1D(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence

Base class for 1-dimensional factor sequences.

NDIM: int = 1
mask
name: str = 'factorsequence1d'

Name of the variable in lowercase letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.evap.evap_sequences.FluxSequence1D(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence

Base class for 1-dimensional flux sequences.

NDIM: int = 1
mask
name: str = 'fluxsequence1d'

Name of the variable in lowercase letters.

unit: str = '?'

Unit of the variable.

class hydpy.models.evap.evap_sequences.StateSequence1D(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: StateSequence

Base class for 1-dimensional state sequences.

NDIM: int = 1
NUMERIC: bool = False
mask
name: str = 'statesequence1d'

Name of the variable in lowercase letters.

unit: str = '?'

Unit of the variable.

Input sequences

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

Bases: InputSequences

Input sequences of model evap.

The following classes are selected:
class hydpy.models.evap.evap_inputs.ReferenceEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: InputSequence

Reference evapotranspiration [mm/T].

Required by the method:

Calc_ReferenceEvapotranspiration_V3

NDIM: int = 0
NUMERIC: bool = False
STANDARD_NAME: ClassVar[StandardInputNames] = 'potential_evapotranspiration'
name: str = 'referenceevapotranspiration'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.evap.evap_inputs.RelativeHumidity(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: InputSequence

Relative humidity [%].

Required by the methods:

Calc_ActualVapourPressure_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Update_LoggedRelativeHumidity_V1

NDIM: int = 0
NUMERIC: bool = False
STANDARD_NAME: ClassVar[StandardInputNames] = 'relative_humidity'
name: str = 'relativehumidity'

Name of the variable in lowercase letters.

unit: str = '%'

Unit of the variable.

class hydpy.models.evap.evap_inputs.WindSpeed(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: InputSequence

Wind speed [m/s].

Required by the methods:

Calc_WindSpeed10m_V1 Calc_WindSpeed2m_V1 Calc_WindSpeed2m_V2 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_WaterEvaporation_V3 Return_AdjustedWindSpeed_V1

NDIM: int = 0
NUMERIC: bool = False
STANDARD_NAME: ClassVar[StandardInputNames] = 'wind_speed'
name: str = 'windspeed'

Name of the variable in lowercase letters.

unit: str = 'm/s'

Unit of the variable.

class hydpy.models.evap.evap_inputs.AtmosphericPressure(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: InputSequence

Atmospheric pressure [hPa].

Required by the methods:

Calc_DryAirPressure_V1 Calc_PsychrometricConstant_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

NDIM: int = 0
NUMERIC: bool = False
STANDARD_NAME: ClassVar[StandardInputNames] = 'atmospheric_pressure'
name: str = 'atmosphericpressure'

Name of the variable in lowercase letters.

unit: str = 'hPa'

Unit of the variable.

class hydpy.models.evap.evap_inputs.NormalAirTemperature(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: InputSequence

Normal air temperature [°C].

Required by the method:

Calc_ReferenceEvapotranspiration_V5

In the terminology of HBV96: TN.

NDIM: int = 0
NUMERIC: bool = False
STANDARD_NAME: ClassVar[StandardInputNames] = 'normal_air_temperature'
name: str = 'normalairtemperature'

Name of the variable in lowercase letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.evap.evap_inputs.NormalEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: InputSequence

Normal evapotranspiration [mm/T].

Required by the method:

Calc_ReferenceEvapotranspiration_V5

In the terminology of HBV96: EPN.

NDIM: int = 0
NUMERIC: bool = False
STANDARD_NAME: ClassVar[StandardInputNames] = 'normal_evapotranspiration'
name: str = 'normalevapotranspiration'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

Factor sequences

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

Bases: FactorSequences

Factor sequences of model evap.

The following classes are selected:
class hydpy.models.evap.evap_factors.MeanAirTemperature(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence

The basin’s mean air temperature [°C].

Required by the method:

Calc_ReferenceEvapotranspiration_V5

NDIM: int = 0
NUMERIC: bool = False
name: str = 'meanairtemperature'

Name of the variable in lowercase letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.evap.evap_factors.AirTemperature(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

Air temperature [°C].

Calculated by the methods:

Calc_AirTemperature_TempModel_V1 Calc_AirTemperature_TempModel_V2 Calc_AirTemperature_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_WaterEvaporation_V1

Required by the methods:

Calc_AirDensity_V1 Calc_LanduseSurfaceResistance_V1 Calc_NetLongwaveRadiation_V1 Calc_NetLongwaveRadiation_V2 Calc_PotentialInterceptionEvaporation_V1 Calc_ReferenceEvapotranspiration_V1 Calc_ReferenceEvapotranspiration_V2 Calc_SaturationVapourPressureSlope_V1 Calc_SaturationVapourPressureSlope_V2 Calc_SaturationVapourPressure_V1 Calc_SaturationVapourPressure_V2 Calc_SoilEvapotranspiration_V3 Calc_WaterEvaporation_V1 Determine_SoilEvapotranspiration_V3 Return_Evaporation_PenmanMonteith_V1 Update_LoggedAirTemperature_V1

NUMERIC: bool = False
name: str = 'airtemperature'

Name of the variable in lowercase letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.evap.evap_factors.DailyAirTemperature(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

The average air temperature in the last 24 hours [°C].

Calculated by the methods:

Calc_DailyAirTemperature_V1 Determine_InterceptionEvaporation_V2

Required by the methods:

Calc_DailyNetLongwaveRadiation_V1 Calc_DailySaturationVapourPressureSlope_V1 Calc_DailySaturationVapourPressure_V1

NUMERIC: bool = False
name: str = 'dailyairtemperature'

Name of the variable in lowercase letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.evap.evap_factors.WindSpeed2m(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence

Wind speed at 2 m above grass-like vegetation [m/s].

Calculated by the methods:

Calc_WindSpeed2m_V1 Calc_WindSpeed2m_V2 Determine_WaterEvaporation_V3

Required by the methods:

Calc_ReferenceEvapotranspiration_V1 Update_LoggedWindSpeed2m_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'windspeed2m'

Name of the variable in lowercase letters.

unit: str = 'm/s'

Unit of the variable.

class hydpy.models.evap.evap_factors.DailyWindSpeed2m(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence

Average wind speed 2 meters above ground in the last 24 hours [m/s].

Calculated by the methods:

Calc_DailyWindSpeed2m_V1 Determine_WaterEvaporation_V3

Required by the method:

Calc_WaterEvaporation_V3

NDIM: int = 0
NUMERIC: bool = False
name: str = 'dailywindspeed2m'

Name of the variable in lowercase letters.

unit: str = 'm/s'

Unit of the variable.

class hydpy.models.evap.evap_factors.WindSpeed10m(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence

Wind speed at 10 m above grass-like vegetation [m/s].

Calculated by the methods:

Calc_WindSpeed10m_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Calc_AerodynamicResistance_V1 Calc_AerodynamicResistance_V2

NDIM: int = 0
NUMERIC: bool = False
name: str = 'windspeed10m'

Name of the variable in lowercase letters.

unit: str = 'm/s'

Unit of the variable.

class hydpy.models.evap.evap_factors.DailyRelativeHumidity(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence

Average relative humidity in the last 24 hours [%].

Calculated by the methods:

Calc_DailyRelativeHumidity_V1 Determine_InterceptionEvaporation_V2

Required by the method:

Calc_DailyActualVapourPressure_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'dailyrelativehumidity'

Name of the variable in lowercase letters.

unit: str = '%'

Unit of the variable.

class hydpy.models.evap.evap_factors.SunshineDuration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence

Sunshine duration [h].

Calculated by the methods:

Calc_SunshineDuration_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Update_CloudCoverage_V1 Update_LoggedSunshineDuration_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'sunshineduration'

Name of the variable in lowercase letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.evap.evap_factors.PossibleSunshineDuration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence

Astronomically possible sunshine duration [h].

Calculated by the methods:

Calc_PossibleSunshineDuration_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Calc_ActualSurfaceResistance_V1 Calc_ActualSurfaceResistance_V2 Calc_AdjustedCloudCoverage_V1 Calc_SoilHeatFlux_V2 Calc_SoilHeatFlux_V4 Determine_SoilEvapotranspiration_V3 Update_CloudCoverage_V1 Update_LoggedPossibleSunshineDuration_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'possiblesunshineduration'

Name of the variable in lowercase letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.evap.evap_factors.DailySunshineDuration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence

The actual sunshine duration in the last 24 hours [h].

Calculated by the methods:

Calc_DailySunshineDuration_V1 Determine_InterceptionEvaporation_V2

Required by the method:

Calc_DailyNetLongwaveRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'dailysunshineduration'

Name of the variable in lowercase letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.evap.evap_factors.DailyPossibleSunshineDuration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence

The astronomically possible sunshine duration in the last 24 hours [h].

Calculated by the methods:

Calc_DailyPossibleSunshineDuration_V1 Determine_InterceptionEvaporation_V2

Required by the methods:

Calc_DailyNetLongwaveRadiation_V1 Calc_SoilHeatFlux_V2

NDIM: int = 0
NUMERIC: bool = False
name: str = 'dailypossiblesunshineduration'

Name of the variable in lowercase letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.evap.evap_factors.SaturationVapourPressure(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

Saturation vapour pressure [hPa].

Calculated by the methods:

Calc_SaturationVapourPressure_V1 Calc_SaturationVapourPressure_V2 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Calc_ActualVapourPressure_V1 Calc_LanduseSurfaceResistance_V1 Calc_PotentialInterceptionEvaporation_V1 Calc_PotentialInterceptionEvaporation_V2 Calc_PotentialSoilEvapotranspiration_V1 Calc_ReferenceEvapotranspiration_V1 Calc_SaturationVapourPressureSlope_V1 Calc_SoilEvapotranspiration_V3 Calc_WaterEvaporation_V4 Determine_SoilEvapotranspiration_V3 Return_Evaporation_PenmanMonteith_V1 Return_Evaporation_PenmanMonteith_V2

NUMERIC: bool = False
name: str = 'saturationvapourpressure'

Name of the variable in lowercase letters.

unit: str = 'hPa'

Unit of the variable.

class hydpy.models.evap.evap_factors.DailySaturationVapourPressure(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

Average saturation vapour pressure in the last 24 hours [hPa].

Calculated by the methods:

Calc_DailySaturationVapourPressure_V1 Determine_InterceptionEvaporation_V2

Required by the methods:

Calc_DailyActualVapourPressure_V1 Calc_WaterEvaporation_V3 Determine_WaterEvaporation_V3

NUMERIC: bool = False
name: str = 'dailysaturationvapourpressure'

Name of the variable in lowercase letters.

unit: str = 'hPa'

Unit of the variable.

class hydpy.models.evap.evap_factors.SaturationVapourPressureSlope(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

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

Calculated by the methods:

Calc_SaturationVapourPressureSlope_V1 Calc_SaturationVapourPressureSlope_V2 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Calc_PotentialInterceptionEvaporation_V1 Calc_PotentialInterceptionEvaporation_V2 Calc_PotentialSoilEvapotranspiration_V1 Calc_ReferenceEvapotranspiration_V1 Calc_SoilEvapotranspiration_V3 Calc_WaterEvaporation_V4 Determine_SoilEvapotranspiration_V3 Return_Evaporation_PenmanMonteith_V1 Return_Evaporation_PenmanMonteith_V2

NUMERIC: bool = False
name: str = 'saturationvapourpressureslope'

Name of the variable in lowercase letters.

unit: str = 'hPa/K'

Unit of the variable.

class hydpy.models.evap.evap_factors.DailySaturationVapourPressureSlope(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

Average saturation vapour pressure slope in the last 24 hours [hPa/K].

Calculated by the methods:

Calc_DailySaturationVapourPressureSlope_V1 Determine_InterceptionEvaporation_V2

Required by the methods:

Calc_WaterEvaporation_V3 Determine_WaterEvaporation_V3

NUMERIC: bool = False
name: str = 'dailysaturationvapourpressureslope'

Name of the variable in lowercase letters.

unit: str = 'hPa/K'

Unit of the variable.

class hydpy.models.evap.evap_factors.ActualVapourPressure(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

Actual vapour pressure [hPa].

Calculated by the methods:

Calc_ActualVapourPressure_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Calc_AirDensity_V1 Calc_DryAirPressure_V1 Calc_LanduseSurfaceResistance_V1 Calc_NetLongwaveRadiation_V1 Calc_PotentialInterceptionEvaporation_V1 Calc_PotentialInterceptionEvaporation_V2 Calc_PotentialSoilEvapotranspiration_V1 Calc_ReferenceEvapotranspiration_V1 Calc_SoilEvapotranspiration_V3 Calc_WaterEvaporation_V4 Determine_SoilEvapotranspiration_V3 Return_Evaporation_PenmanMonteith_V1 Return_Evaporation_PenmanMonteith_V2

NUMERIC: bool = False
name: str = 'actualvapourpressure'

Name of the variable in lowercase letters.

unit: str = 'hPa'

Unit of the variable.

class hydpy.models.evap.evap_factors.DailyActualVapourPressure(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

The average actual vapour pressure in the last 24 hours [hPa].

Calculated by the methods:

Calc_DailyActualVapourPressure_V1 Determine_InterceptionEvaporation_V2

Required by the methods:

Calc_DailyNetLongwaveRadiation_V1 Calc_WaterEvaporation_V3 Determine_WaterEvaporation_V3

NUMERIC: bool = False
name: str = 'dailyactualvapourpressure'

Name of the variable in lowercase letters.

unit: str = 'hPa'

Unit of the variable.

class hydpy.models.evap.evap_factors.DryAirPressure(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

Dry air pressure [hPa].

Calculated by the methods:

Calc_DryAirPressure_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the method:

Calc_AirDensity_V1

NUMERIC: bool = False
name: str = 'dryairpressure'

Name of the variable in lowercase letters.

unit: str = 'hPa'

Unit of the variable.

class hydpy.models.evap.evap_factors.AirDensity(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

Air density [kg/m³].

Calculated by the methods:

Calc_AirDensity_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Calc_PotentialInterceptionEvaporation_V1 Calc_PotentialInterceptionEvaporation_V2 Calc_PotentialSoilEvapotranspiration_V1 Calc_SoilEvapotranspiration_V3 Calc_WaterEvaporation_V4 Determine_SoilEvapotranspiration_V3 Return_Evaporation_PenmanMonteith_V1 Return_Evaporation_PenmanMonteith_V2

NUMERIC: bool = False
name: str = 'airdensity'

Name of the variable in lowercase letters.

unit: str = 'kg/m³'

Unit of the variable.

class hydpy.models.evap.evap_factors.PsychrometricConstant(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence

Psychrometric constant [hPa/K].

Calculated by the method:

Calc_PsychrometricConstant_V1

Required by the method:

Calc_ReferenceEvapotranspiration_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'psychrometricconstant'

Name of the variable in lowercase letters.

unit: str = 'hPa/K'

Unit of the variable.

class hydpy.models.evap.evap_factors.CurrentAlbedo(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

The current albedo of the relevant surface [-].

Calculated by the methods:

Calc_CurrentAlbedo_SnowAlbedoModel_V1 Calc_CurrentAlbedo_V1 Calc_CurrentAlbedo_V2 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Calc_DailyNetShortwaveRadiation_V1 Calc_NetLongwaveRadiation_V2 Calc_NetShortwaveRadiation_V2 Determine_WaterEvaporation_V3

NUMERIC: bool = False
name: str = 'currentalbedo'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_factors.AdjustedCloudCoverage(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence

Adjusted degree of cloud coverage [-].

Calculated by the methods:

Calc_AdjustedCloudCoverage_V1 Determine_PotentialInterceptionEvaporation_V1

Required by the method:

Calc_NetLongwaveRadiation_V2

NDIM: int = 0
NUMERIC: bool = False
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)
name: str = 'adjustedcloudcoverage'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_factors.AerodynamicResistance(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

Aerodynamic resistance [s/m].

Calculated by the methods:

Calc_AerodynamicResistance_V1 Calc_AerodynamicResistance_V2 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Calc_PotentialInterceptionEvaporation_V1 Calc_PotentialInterceptionEvaporation_V2 Calc_PotentialSoilEvapotranspiration_V1 Calc_SoilEvapotranspiration_V3 Calc_WaterEvaporation_V4 Determine_SoilEvapotranspiration_V3 Return_Evaporation_PenmanMonteith_V1 Return_Evaporation_PenmanMonteith_V2

NUMERIC: bool = False
name: str = 'aerodynamicresistance'

Name of the variable in lowercase letters.

unit: str = 's/m'

Unit of the variable.

class hydpy.models.evap.evap_factors.SoilSurfaceResistance(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

Soil surface resistance [s/m].

Calculated by the methods:

Calc_SoilSurfaceResistance_V1 Determine_SoilEvapotranspiration_V3

Required by the method:

Calc_ActualSurfaceResistance_V1

NUMERIC: bool = False
name: str = 'soilsurfaceresistance'

Name of the variable in lowercase letters.

unit: str = 's/m'

Unit of the variable.

class hydpy.models.evap.evap_factors.LanduseSurfaceResistance(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

Surface resistance for the current moisture conditions of water areas, sealed areas, and vegetation [s/m].

Calculated by the methods:

Calc_LanduseSurfaceResistance_V1 Determine_SoilEvapotranspiration_V3

Required by the method:

Calc_ActualSurfaceResistance_V1

NUMERIC: bool = False
name: str = 'landusesurfaceresistance'

Name of the variable in lowercase letters.

unit: str = 's/m'

Unit of the variable.

class hydpy.models.evap.evap_factors.ActualSurfaceResistance(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

Actual surface resistance [s/m].

Calculated by the methods:

Calc_ActualSurfaceResistance_V1 Calc_ActualSurfaceResistance_V2 Determine_SoilEvapotranspiration_V3

Required by the methods:

Calc_PotentialSoilEvapotranspiration_V1 Calc_SoilEvapotranspiration_V3

NUMERIC: bool = False
name: str = 'actualsurfaceresistance'

Name of the variable in lowercase letters.

unit: str = 's/m'

Unit of the variable.

class hydpy.models.evap.evap_factors.InterceptedWater(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

Intercepted water [mm].

Calculated by the methods:

Calc_InterceptedWater_IntercModel_V1 Calc_InterceptedWater_V1 Determine_InterceptionEvaporation_V1 Determine_InterceptionEvaporation_V2

Required by the methods:

Calc_InterceptionEvaporation_V1 Calc_InterceptionEvaporation_V2

NUMERIC: bool = False
name: str = 'interceptedwater'

Name of the variable in lowercase letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.evap.evap_factors.SoilWater(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

Soil water content [mm].

Calculated by the methods:

Calc_SoilWater_SoilWaterModel_V1 Calc_SoilWater_V1 Determine_SoilEvapotranspiration_V1 Determine_SoilEvapotranspiration_V2 Determine_SoilEvapotranspiration_V3

Required by the methods:

Calc_LanduseSurfaceResistance_V1 Calc_SoilEvapotranspiration_V1 Calc_SoilEvapotranspiration_V2 Calc_SoilSurfaceResistance_V1

NUMERIC: bool = False
name: str = 'soilwater'

Name of the variable in lowercase letters.

unit: str = 'mm'

Unit of the variable.

class hydpy.models.evap.evap_factors.SnowCover(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

Snow cover degree [-].

Calculated by the methods:

Calc_SnowCover_SnowCoverModel_V1 Calc_SnowCover_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1 Determine_SoilEvapotranspiration_V1 Determine_SoilEvapotranspiration_V3

Required by the methods:

Calc_CurrentAlbedo_V2 Calc_InterceptionEvaporation_V2 Calc_SoilEvapotranspiration_V3 Update_SoilEvapotranspiration_V2

NUMERIC: bool = False
name: str = 'snowcover'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_factors.SnowyCanopy(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FactorSequence1D

Snow cover degree in the canopies of tree-like vegetation (is for nan non-tree-like vegetation) [-].

Calculated by the methods:

Calc_SnowyCanopy_SnowyCanopyModel_V1 Calc_SnowyCanopy_V1 Determine_InterceptionEvaporation_V2

Required by the method:

Calc_InterceptionEvaporation_V2

NUMERIC: bool = False
name: str = 'snowycanopy'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

Flux sequences

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

Bases: FluxSequences

Flux sequences of model evap.

The following classes are selected:
class hydpy.models.evap.evap_fluxes.Precipitation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Precipitation [mm/T].

Calculated by the methods:

Calc_Precipitation_PrecipModel_V1 Calc_Precipitation_PrecipModel_V2

Required by the methods:

Calc_PotentialEvapotranspiration_V3 Update_LoggedPrecipitation_V1

NUMERIC: bool = False
name: str = 'precipitation'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.DailyPrecipitation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

The precipitation sum of the last 24 hours [mm/d].

Calculated by the methods:

Calc_DailyPrecipitation_V1 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Calc_CurrentAlbedo_V2 Update_SoilResistance_V1

NUMERIC: bool = False
name: str = 'dailyprecipitation'

Name of the variable in lowercase letters.

unit: str = 'mm/d'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.GlobalRadiation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence

Global radiation [W/m²].

Calculated by the methods:

Calc_GlobalRadiation_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Calc_NetLongwaveRadiation_V1 Calc_NetLongwaveRadiation_V2 Calc_NetShortwaveRadiation_V1 Calc_NetShortwaveRadiation_V2 Calc_ReferenceEvapotranspiration_V2 Determine_WaterEvaporation_V3 Update_LoggedGlobalRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'globalradiation'

Name of the variable in lowercase letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.ClearSkySolarRadiation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence

Clear sky solar radiation [W/m²].

Calculated by the method:

Calc_ClearSkySolarRadiation_V1

Required by the methods:

Calc_NetLongwaveRadiation_V1 Update_LoggedClearSkySolarRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'clearskysolarradiation'

Name of the variable in lowercase letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.DailyGlobalRadiation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence

Average global radiation in the last 24 hours [W/m²].

Calculated by the methods:

Calc_DailyGlobalRadiation_V1 Determine_WaterEvaporation_V3

Required by the method:

Calc_DailyNetShortwaveRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'dailyglobalradiation'

Name of the variable in lowercase letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.NetShortwaveRadiation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Net shortwave radiation [W/m²].

Calculated by the methods:

Calc_NetShortwaveRadiation_V1 Calc_NetShortwaveRadiation_V2 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Calc_NetRadiation_V1 Calc_NetRadiation_V2

NUMERIC: bool = False
name: str = 'netshortwaveradiation'

Name of the variable in lowercase letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.DailyNetShortwaveRadiation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Average net shortwave radiation in the last 24 hours [W/m²].

Calculated by the methods:

Calc_DailyNetShortwaveRadiation_V1 Determine_WaterEvaporation_V3

Required by the method:

Calc_DailyNetRadiation_V1

NUMERIC: bool = False
name: str = 'dailynetshortwaveradiation'

Name of the variable in lowercase letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.NetLongwaveRadiation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Net longwave radiation [W/m²].

Calculated by the methods:

Calc_NetLongwaveRadiation_V1 Calc_NetLongwaveRadiation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the method:

Calc_NetRadiation_V1

NUMERIC: bool = False
name: str = 'netlongwaveradiation'

Name of the variable in lowercase letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.DailyNetLongwaveRadiation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Average net longwave radiation in the last 24 hours [W/m²].

Calculated by the methods:

Calc_DailyNetLongwaveRadiation_V1 Determine_InterceptionEvaporation_V2

Required by the methods:

Calc_DailyNetRadiation_V1 Calc_NetRadiation_V2 Determine_WaterEvaporation_V3

NUMERIC: bool = False
name: str = 'dailynetlongwaveradiation'

Name of the variable in lowercase letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.NetRadiation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Total net radiation [W/m²].

Calculated by the methods:

Calc_NetRadiation_V1 Calc_NetRadiation_V2 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Calc_PotentialInterceptionEvaporation_V1 Calc_PotentialInterceptionEvaporation_V2 Calc_PotentialSoilEvapotranspiration_V1 Calc_ReferenceEvapotranspiration_V1 Calc_SoilEvapotranspiration_V3 Calc_SoilHeatFlux_V1 Calc_SoilHeatFlux_V4 Calc_WaterEvaporation_V4 Determine_SoilEvapotranspiration_V3 Return_Evaporation_PenmanMonteith_V1 Return_Evaporation_PenmanMonteith_V2

NUMERIC: bool = False
name: str = 'netradiation'

Name of the variable in lowercase letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.DailyNetRadiation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Average net radiation in the last 24 hours [W/m²].

Calculated by the methods:

Calc_DailyNetRadiation_V1 Determine_WaterEvaporation_V3

Required by the methods:

Calc_SoilHeatFlux_V2 Calc_WaterEvaporation_V3

NUMERIC: bool = False
name: str = 'dailynetradiation'

Name of the variable in lowercase letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.SoilHeatFlux(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Soil heat flux [W/m²].

Calculated by the methods:

Calc_SoilHeatFlux_V1 Calc_SoilHeatFlux_V2 Calc_SoilHeatFlux_V3 Calc_SoilHeatFlux_V4 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Calc_PotentialInterceptionEvaporation_V1 Calc_PotentialInterceptionEvaporation_V2 Calc_PotentialSoilEvapotranspiration_V1 Calc_ReferenceEvapotranspiration_V1 Calc_SoilEvapotranspiration_V3 Calc_WaterEvaporation_V4 Determine_SoilEvapotranspiration_V3 Return_Evaporation_PenmanMonteith_V1 Return_Evaporation_PenmanMonteith_V2

NUMERIC: bool = False
name: str = 'soilheatflux'

Name of the variable in lowercase letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.ReferenceEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Reference (grass) evapotranspiration [mm/T].

Calculated by the methods:

Calc_ReferenceEvapotranspiration_PETModel_V1 Calc_ReferenceEvapotranspiration_V1 Calc_ReferenceEvapotranspiration_V2 Calc_ReferenceEvapotranspiration_V3 Calc_ReferenceEvapotranspiration_V4 Calc_ReferenceEvapotranspiration_V5

Updated by the method:

Adjust_ReferenceEvapotranspiration_V1

Required by the methods:

Calc_MeanReferenceEvapotranspiration_V1 Calc_PotentialEvapotranspiration_V1 Calc_PotentialEvapotranspiration_V2 Calc_PotentialEvapotranspiration_V3 Get_PotentialEvapotranspiration_V1

NUMERIC: bool = False
name: str = 'referenceevapotranspiration'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.PotentialInterceptionEvaporation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Potential interception evaporation [mm/T].

Calculated by the methods:

Calc_PotentialInterceptionEvaporation_PETModel_V1 Calc_PotentialInterceptionEvaporation_PETModel_V2 Calc_PotentialInterceptionEvaporation_V1 Calc_PotentialInterceptionEvaporation_V2 Calc_PotentialInterceptionEvaporation_V3 Determine_InterceptionEvaporation_V1 Determine_InterceptionEvaporation_V2 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Calc_InterceptionEvaporation_V1 Calc_InterceptionEvaporation_V2 Determine_SoilEvapotranspiration_V1 Determine_SoilEvapotranspiration_V2 Determine_SoilEvapotranspiration_V3 Get_PotentialInterceptionEvaporation_V1 Update_SoilEvapotranspiration_V1 Update_SoilEvapotranspiration_V3

NUMERIC: bool = False
name: str = 'potentialinterceptionevaporation'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.PotentialSoilEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Potential evapotranspiration from soils [mm/T].

Calculated by the methods:

Calc_PotentialSoilEvapotranspiration_PETModel_V1 Calc_PotentialSoilEvapotranspiration_PETModel_V2 Calc_PotentialSoilEvapotranspiration_V1 Calc_PotentialSoilEvapotranspiration_V2 Determine_SoilEvapotranspiration_V1 Determine_SoilEvapotranspiration_V2

Required by the methods:

Calc_SoilEvapotranspiration_V1 Calc_SoilEvapotranspiration_V2 Get_PotentialSoilEvapotranspiration_V1 Update_LoggedPotentialSoilEvapotranspiration_V1 Update_SoilEvapotranspiration_V1

NUMERIC: bool = False
name: str = 'potentialsoilevapotranspiration'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.PotentialEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Potential (land type-specific) evapotranspiration [mm/T].

Calculated by the methods:

Calc_PotentialEvapotranspiration_V1 Calc_PotentialEvapotranspiration_V2 Calc_PotentialEvapotranspiration_V3

Updated by the method:

Update_PotentialEvapotranspiration_V1

Required by the methods:

Calc_MeanPotentialEvapotranspiration_V1 Get_PotentialEvapotranspiration_V2

NUMERIC: bool = False
name: str = 'potentialevapotranspiration'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.DailyPotentialSoilEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

The potential soil evapotranspiration sum of the last 24 hours [mm/d].

Calculated by the methods:

Calc_DailyPotentialSoilEvapotranspiration_V1 Determine_PotentialInterceptionEvaporation_V1

Required by the methods:

Calc_CurrentAlbedo_V2 Update_SoilResistance_V1

NUMERIC: bool = False
name: str = 'dailypotentialsoilevapotranspiration'

Name of the variable in lowercase letters.

unit: str = 'mm/d'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.MeanReferenceEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence

Mean reference evapotranspiration [mm/T].

Calculated by the method:

Calc_MeanReferenceEvapotranspiration_V1

Required by the method:

Get_MeanPotentialEvapotranspiration_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'meanreferenceevapotranspiration'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.MeanPotentialEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence

Mean potential evapotranspiration [mm/T].

Calculated by the method:

Calc_MeanPotentialEvapotranspiration_V1

Required by the method:

Get_MeanPotentialEvapotranspiration_V2

NDIM: int = 0
NUMERIC: bool = False
name: str = 'meanpotentialevapotranspiration'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.PotentialWaterEvaporation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Potential evaporation from open water areas [mm/T].

Calculated by the methods:

Calc_PotentialWaterEvaporation_PETModel_V1 Calc_PotentialWaterEvaporation_PETModel_V2 Calc_PotentialWaterEvaporation_V1 Determine_WaterEvaporation_V1 Determine_WaterEvaporation_V2

Required by the methods:

Calc_WaterEvaporation_V1 Calc_WaterEvaporation_V2

NUMERIC: bool = False
name: str = 'potentialwaterevaporation'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.WaterEvaporation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Actual evaporation from open water areas [mm/T].

Calculated by the methods:

Calc_WaterEvaporation_V1 Calc_WaterEvaporation_V2 Calc_WaterEvaporation_V3 Calc_WaterEvaporation_V4 Determine_WaterEvaporation_V1 Determine_WaterEvaporation_V2 Determine_WaterEvaporation_V3

Required by the methods:

Get_WaterEvaporation_V1 Update_LoggedWaterEvaporation_V1

NUMERIC: bool = False
name: str = 'waterevaporation'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.DailyWaterEvaporation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

The water evaporation sum of the last 24 hours [mm/d].

Calculated by the method:

Calc_DailyWaterEvaporation_V1

Required by the method:

Get_PotentialWaterEvaporation_V1

NUMERIC: bool = False
name: str = 'dailywaterevaporation'

Name of the variable in lowercase letters.

unit: str = 'mm/d'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.InterceptionEvaporation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Actual interception evaporation [mm/T].

Calculated by the methods:

Calc_InterceptionEvaporation_V1 Calc_InterceptionEvaporation_V2 Determine_InterceptionEvaporation_V1 Determine_InterceptionEvaporation_V2

Required by the methods:

Determine_SoilEvapotranspiration_V1 Determine_SoilEvapotranspiration_V2 Determine_SoilEvapotranspiration_V3 Get_InterceptionEvaporation_V1 Update_SoilEvapotranspiration_V1 Update_SoilEvapotranspiration_V3

NUMERIC: bool = False
name: str = 'interceptionevaporation'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.evap.evap_fluxes.SoilEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: FluxSequence1D

Actual soil evapotranspiration [mm/T].

Calculated by the methods:

Calc_SoilEvapotranspiration_V1 Calc_SoilEvapotranspiration_V2 Calc_SoilEvapotranspiration_V3 Determine_SoilEvapotranspiration_V1 Determine_SoilEvapotranspiration_V2 Determine_SoilEvapotranspiration_V3 Update_SoilEvapotranspiration_V2

Updated by the methods:

Update_SoilEvapotranspiration_V1 Update_SoilEvapotranspiration_V3

Required by the method:

Get_SoilEvapotranspiration_V1

NUMERIC: bool = False
name: str = 'soilevapotranspiration'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

State sequences

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

Bases: StateSequences

State sequences of model evap.

The following classes are selected:
class hydpy.models.evap.evap_states.CloudCoverage(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: StateSequence

Degree of cloud coverage [-].

Updated by the methods:

Determine_PotentialInterceptionEvaporation_V1 Update_CloudCoverage_V1

Required by the method:

Calc_AdjustedCloudCoverage_V1

NDIM: int = 0
NUMERIC: bool = False
SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, 1.0)
name: str = 'cloudcoverage'

Name of the variable in lowercase letters.

unit: str = '-'

Unit of the variable.

class hydpy.models.evap.evap_states.SoilResistance(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: StateSequence1D

Actual soil surface resistance [s/m].

Updated by the method:

Update_SoilResistance_V1

Required by the method:

Calc_ActualSurfaceResistance_V2

SPAN: tuple[int | float | bool | None, int | float | bool | None] = (0.0, None)
name: str = 'soilresistance'

Name of the variable in lowercase letters.

unit: str = 's/m'

Unit of the variable.

Log sequences

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

Bases: LogSequences

Log sequences of model evap.

The following classes are selected:
class hydpy.models.evap.evap_logs.LoggedAirTemperature(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: LogSequence

Logged air temperature [°C].

Updated by the methods:

Determine_InterceptionEvaporation_V2 Update_LoggedAirTemperature_V1

Required by the method:

Calc_DailyAirTemperature_V1

NDIM: int = 2
NUMERIC: bool = False
name: str = 'loggedairtemperature'

Name of the variable in lowercase letters.

unit: str = '°C'

Unit of the variable.

class hydpy.models.evap.evap_logs.LoggedPrecipitation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: LogSequence

Logged precipitation [mm/T].

Updated by the method:

Update_LoggedPrecipitation_V1

Required by the methods:

Calc_DailyPrecipitation_V1 Determine_PotentialInterceptionEvaporation_V1

NDIM: int = 2
NUMERIC: bool = False
name: str = 'loggedprecipitation'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.evap.evap_logs.LoggedWindSpeed2m(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: LogSequence

Logged wind speed at 2 m above grass-like vegetation [m/s].

Updated by the methods:

Determine_WaterEvaporation_V3 Update_LoggedWindSpeed2m_V1

Required by the method:

Calc_DailyWindSpeed2m_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedwindspeed2m'

Name of the variable in lowercase letters.

unit: str = 'm/s'

Unit of the variable.

class hydpy.models.evap.evap_logs.LoggedRelativeHumidity(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: LogSequence

Logged relative humidity [%].

Updated by the methods:

Determine_InterceptionEvaporation_V2 Update_LoggedRelativeHumidity_V1

Required by the method:

Calc_DailyRelativeHumidity_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedrelativehumidity'

Name of the variable in lowercase letters.

unit: str = '%'

Unit of the variable.

class hydpy.models.evap.evap_logs.LoggedSunshineDuration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: LogSequence

Logged sunshine duration [h].

Updated by the methods:

Determine_InterceptionEvaporation_V2 Update_LoggedSunshineDuration_V1

Required by the method:

Calc_DailySunshineDuration_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedsunshineduration'

Name of the variable in lowercase letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.evap.evap_logs.LoggedPossibleSunshineDuration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: LogSequence

Logged astronomically possible sunshine duration [h].

Updated by the methods:

Determine_InterceptionEvaporation_V2 Update_LoggedPossibleSunshineDuration_V1

Required by the method:

Calc_DailyPossibleSunshineDuration_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedpossiblesunshineduration'

Name of the variable in lowercase letters.

unit: str = 'h'

Unit of the variable.

class hydpy.models.evap.evap_logs.LoggedGlobalRadiation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: LogSequence

Logged global radiation [W/m²].

Updated by the methods:

Determine_WaterEvaporation_V3 Update_LoggedGlobalRadiation_V1

Required by the methods:

Calc_DailyGlobalRadiation_V1 Calc_NetLongwaveRadiation_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedglobalradiation'

Name of the variable in lowercase letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.evap.evap_logs.LoggedClearSkySolarRadiation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: LogSequence

Logged clear sky radiation [W/m²].

Updated by the method:

Update_LoggedClearSkySolarRadiation_V1

Required by the method:

Calc_NetLongwaveRadiation_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedclearskysolarradiation'

Name of the variable in lowercase letters.

unit: str = 'W/m²'

Unit of the variable.

class hydpy.models.evap.evap_logs.LoggedPotentialEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: LogSequence

Logged (damped) potential evapotranspiration [mm/T].

Updated by the method:

Update_PotentialEvapotranspiration_V1

NDIM: int = 2
NUMERIC: bool = False
shape

A tuple containing the lengths of all dimensions.

LoggedPotentialEvapotranspiration is generally initialised with a length of one on the first axis:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> logs.loggedpotentialevapotranspiration.shape = 3
>>> logs.loggedpotentialevapotranspiration.shape
(1, 3)
name: str = 'loggedpotentialevapotranspiration'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.evap.evap_logs.LoggedWaterEvaporation(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: LogSequence

Logged evaporation from water areas [mm/T].

Updated by the method:

Update_LoggedWaterEvaporation_V1

Required by the method:

Calc_DailyWaterEvaporation_V1

NDIM: int = 2
NUMERIC: bool = False
name: str = 'loggedwaterevaporation'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

class hydpy.models.evap.evap_logs.LoggedPotentialSoilEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]

Bases: LogSequence

Logged potential soil evapotranspiration [mm/T].

Updated by the method:

Update_LoggedPotentialSoilEvapotranspiration_V1

Required by the methods:

Calc_DailyPotentialSoilEvapotranspiration_V1 Determine_PotentialInterceptionEvaporation_V1

NDIM: int = 2
NUMERIC: bool = False
name: str = 'loggedpotentialsoilevapotranspiration'

Name of the variable in lowercase letters.

unit: str = 'mm/T'

Unit of the variable.

Auxiliary Features

Masks

class hydpy.models.evap.Masks[source]

Bases: Masks

Masks of base model evap.

The following classes are selected:

  • Soil() Mask including hydrological response units where evapotranspiration from soils occurs.

  • Plant() Mask including hydrological response units containing any vegetation.

  • Water() Mask including hydrological response units where evaporation from open water areas.

class hydpy.models.evap.evap_masks.Soil(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)[source]

Bases: SubmodelIndexMask

Mask including hydrological response units where evapotranspiration from soils occurs.

static get_refinement(variable: variabletools.Variable) → evap_control.Soil[source]

Return a reference to the associated Soil instance.

name: str = 'soil'
class hydpy.models.evap.evap_masks.Plant(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)[source]

Bases: SubmodelIndexMask

Mask including hydrological response units containing any vegetation.

static get_refinement(variable: variabletools.Variable) → evap_control.Plant[source]

Return a reference to the associated Plant instance.

name: str = 'plant'
class hydpy.models.evap.evap_masks.Water(variable: variabletools.Variable | None = None, doc: str | None = None, **kwargs)[source]

Bases: SubmodelIndexMask

Mask including hydrological response units where evaporation from open water areas.

static get_refinement(variable: variabletools.Variable) → evap_control.Water[source]

Return a reference to the associated Water instance.

name: str = 'water'
class hydpy.models.evap.ControlParameters(master: Parameters, cls_fastaccess: type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)

Bases: SubParameters

Control parameters of model evap.

The following classes are selected:

  • NmbHRU() The number of separately modelled hydrological response units [-].

  • HRUType() Hydrological response unit type [-].

  • Water() A flag that indicates whether the individual zones are water areas or not.

  • Interception() A flag that indicates whether interception evaporation is relevant for the individual zones.

  • Soil() A flag that indicates whether soil evapotranspiration is relevant for the individual zones.

  • Plant() A flag that indicates whether the individual zones contain any vegetation.

  • Tree() A flag that indicates whether the individual zones contain tree-like vegetation.

  • Conifer() A flag that indicates whether the individual zones contain conifer-like vegetation.

  • HRUArea() The area of each hydrological response unit [km²].

  • HRUAltitude() The altitude of each hydrological response unit [m].

  • MeasuringHeightWindSpeed() The height above ground of the wind speed measurements [m].

  • CoastFactor() The “coast factor” of Turc-Wendling’s reference evapotranspiration equation [-].

  • Albedo() Earth surface albedo [-].

  • GroundAlbedo() The albedo of the snow-free ground (including soils, sealed surfaces, and water areas) [-].

  • GroundAlbedoSnow() The albedo of the snow-covered ground (including soils and sealed surfaces) [-].

  • LeafAlbedo() The albedo of the snow-free leaves [-].

  • LeafAlbedoSnow() The albedo of the snow-covered leaves [-].

  • LeafAreaIndex() Leaf area index [-].

  • CropHeight() Crop height [m].

  • CloudTypeFactor() Cloud type-specific factor for calculating atmospheric longwave counter radiation [-].

  • NightCloudFactor() Factor for adjusting daytime estimates of the cloud coverage degree to nighttime [-].

  • Emissivity() The emissivity of the land surface [-].

  • AverageSoilHeatFlux() Monthly averages of the soil heat flux [W/m²].

  • SurfaceResistance() Surface resistance of water areas, sealed areas, and vegetation with sufficient water supply [s/m].

  • WetSoilResistance() Surface resistance of wet soils [s/m].

  • SoilResistanceIncrease() Increase in soil surface resistance if evaporation dominates precipitation [s/m/T].

  • WetnessThreshold() The ratio between precipitation and potential evapotranspiration above which the topmost soil layer becomes wet [-].

  • LeafResistance() Surface resistance of plant leaves [s/m].

  • EvapotranspirationFactor() The adjustment factor for potential evapotranspiration [-].

  • MonthFactor() Factor for converting general potential evaporation or evapotranspiration (usually grass reference evapotranspiration) to month-specific potential evaporation or evapotranspiration [-].

  • LandMonthFactor() Factor for converting general potential evaporation or evapotranspiration (usually grass reference evapotranspiration) to land-use- and month-specific potential evaporation or evapotranspiration [-].

  • AltitudeFactor() Decrease of potential evapotranspiration with altitude [-1/100m].

  • PrecipitationFactor() Decrease in potential evapotranspiration due to precipitation [T/mm].

  • AirTemperatureFactor() Temperature factor related to the difference of current reference evapotranspiration and normal reference evapotranspiration [1/°C].

  • DampingFactor() Damping factor (temporal weighting factor) for potential evapotranspiration [-].

  • TemperatureThresholdIce() Temperature threshold for evaporation from water areas [°C].

  • MaxSoilWater() Maximum soil water content [mm].

  • SoilMoistureLimit() Relative soil moisture limit for potential evapotranspiration [-].

  • ExcessReduction() A factor for restricting actual to potential evapotranspiration [-].

  • DisseFactor() Factor for calculating actual soil evapotranspiration based on potential evapotranspiration estimates that follow the Disse (1995) formulation of the Minhas et al. (1974) equation.

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

Bases: SubParameters

Derived parameters of model evap.

The following classes are selected:

  • MOY() References the “global” month of the year index array [-].

  • HRUAreaFraction() The area fraction of each hydrological response unit [-].

  • Altitude() Average (reference) subbasin altitude [100m].

  • Hours() The length of the actual simulation step size in hours [h].

  • Days() The length of the actual simulation step size in days [d].

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

  • RoughnessLength() Roughness length [m].

  • AerodynamicResistanceFactor() Factor for calculating aerodynamic resistance [-].

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

Bases: FactorSequences

Factor sequences of model evap.

The following classes are selected:
class hydpy.models.evap.FixedParameters(master: Parameters, cls_fastaccess: type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)

Bases: SubParameters

Fixed parameters of model evap.

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

Bases: FluxSequences

Flux sequences of model evap.

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

Bases: InputSequences

Input sequences of model evap.

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

Bases: LogSequences

Log sequences of model evap.

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

Bases: StateSequences

State sequences of model evap.

The following classes are selected: