evap

The HydPy-E model family supplies methods for calculating potential evapotranspiration.

Method Features

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

Bases: hydpy.core.modeltools.AdHocModel

The Evap base model.

The following “run methods” are called in the given sequence during each simulation step:
class hydpy.models.evap.evap_model.Calc_AdjustedWindSpeed_V1[source]

Bases: hydpy.core.modeltools.Method

Adjust the measured wind speed to a height of two meters above the ground.

Requires the control parameter:

MeasuringHeightWindSpeed

Requires the input sequence:

WindSpeed

Calculates the flux sequence:

AdjustedWindSpeed

Basic equation (Allen equation 47, modified for higher precision):

\(AdjustedWindSpeed = 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\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> measuringheightwindspeed(10.0)
>>> inputs.windspeed = 5.0
>>> model.calc_adjustedwindspeed_v1()
>>> fluxes.adjustedwindspeed
adjustedwindspeed(3.738763)
class hydpy.models.evap.evap_model.Calc_SaturationVapourPressure_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the saturation vapour pressure.

Requires the input sequence:

AirTemperature

Calculates the flux sequence:

SaturationVapourPressure

Basic equation (Allen, equation 11):

\(SaturationVapourPressure = 0.6108 \cdot \exp(\frac{17.27 \cdot AirTemperature}{AirTemperature + 237.3})\)

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> inputs.airtemperature = 10.0
>>> model.calc_saturationvapourpressure_v1()
>>> fluxes.saturationvapourpressure
saturationvapourpressure(1.227963)
class hydpy.models.evap.evap_model.Calc_SaturationVapourPressureSlope_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the slope of the saturation vapour pressure curve.

Requires the input sequence:

AirTemperature

Requires the flux sequence:

SaturationVapourPressure

Calculates the flux sequence:

SaturationVapourPressureSlope

Basic equation (Allen, equation 13):

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

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> inputs.airtemperature = 10.0
>>> fluxes.saturationvapourpressure(1.227963)
>>> model.calc_saturationvapourpressureslope_v1()
>>> fluxes.saturationvapourpressureslope
saturationvapourpressureslope(0.082283)
class hydpy.models.evap.evap_model.Calc_ActualVapourPressure_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the actual vapour pressure.

Requires the input sequence:

RelativeHumidity

Requires the flux sequence:

SaturationVapourPressure

Calculates the flux sequence:

ActualVapourPressure

Basic equation (Allen, equation 19, modified):

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

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> inputs.relativehumidity = 60.0
>>> fluxes.saturationvapourpressure = 3.0
>>> model.calc_actualvapourpressure_v1()
>>> fluxes.actualvapourpressure
actualvapourpressure(1.8)
class hydpy.models.evap.evap_model.Calc_EarthSunDistance_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the relative inverse distance between the earth and the sun.

Requires the derived parameter:

DOY

Calculates the flux sequence:

EarthSunDistance

Basic equation (Allen, equation 23):

\(EarthSunDistance = 1 + 0.033 \cdot cos( 2 \cdot \pi / 366 \cdot (DOY + 1)\)

Note that this equation differs a little from the one given by Allen. The following examples show that Calc_EarthSunDistance_V1 calculates the same distance value for a specific “day” (e.g. the 1st March) both for leap years and non-leap years. Hence, there is a tiny “jump” between the 28th February and the 1st March for non-leap years.

Examples:

We define an initialisation period covering both a leap year (2000) and a non-leap year (2001):

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> from hydpy import pub, round_
>>> pub.timegrids = "2000-01-01", "2002-01-01", "1d"
>>> derived.doy.update()

The following convenience function applies method Calc_EarthSunDistance_V1 for the given dates and prints the results:

>>> def test(*dates):
...     for date in dates:
...         model.idx_sim = pub.timegrids.init[date]
...         model.calc_earthsundistance_v1()
...         print(date, end=": ")
...         round_(fluxes.earthsundistance.value)

The results are identical for both years:

>>> test("2000-01-01", "2000-02-28", "2000-02-29",
...      "2000-03-01", "2000-07-01", "2000-12-31")
2000-01-01: 1.032995
2000-02-28: 1.017471
2000-02-29: 1.016988
2000-03-01: 1.0165
2000-07-01: 0.967
2000-12-31: 1.033

>>> test("2001-01-01", "2001-02-28",
...      "2001-03-01", "2001-07-01", "2001-12-31")
2001-01-01: 1.032995
2001-02-28: 1.017471
2001-03-01: 1.0165
2001-07-01: 0.967
2001-12-31: 1.033

The following calculation agrees with example 8 of Allen:

>>> derived.doy(246)
>>> model.idx_sim = 0
>>> model.calc_earthsundistance_v1()
>>> fluxes.earthsundistance
earthsundistance(0.984993)
class hydpy.models.evap.evap_model.Calc_SolarDeclination_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the solar declination.

Requires the derived parameter:

DOY

Calculates the flux sequence:

SolarDeclination

Basic equation (Allen, equation 24):

\(SolarDeclination = 0.409 \cdot sin( 2 \cdot \pi / 366 \cdot (DOY + 1) - 1.39)\)

Note that this equation actually differs from the one given by Allen a little, due to reasons explained in the documentation on method Calc_EarthSunDistance_V1.

Examples:

We define an initialisation period covering both a leap year (2000) and a non-leap year (2001):

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> from hydpy import pub, round_
>>> pub.timegrids = "2000-01-01", "2002-01-01", "1d"
>>> derived.doy.update()

The following convenience function applies method Calc_SolarDeclination_V1 for the given dates and prints the results:

>>> def test(*dates):
...     for date in dates:
...         model.idx_sim = pub.timegrids.init[date]
...         model.calc_solardeclination_v1()
...         print(date, end=": ")
...         round_(fluxes.solardeclination.value)

The results are identical for both years:

>>> test("2000-01-01", "2000-02-28", "2000-02-29",
...      "2000-03-01", "2000-12-31")
2000-01-01: -0.401012
2000-02-28: -0.150618
2000-02-29: -0.144069
2000-03-01: -0.137476
2000-12-31: -0.402334

>>> test("2001-01-01", "2001-02-28",
...      "2001-03-01", "2001-12-31")
2001-01-01: -0.401012
2001-02-28: -0.150618
2001-03-01: -0.137476
2001-12-31: -0.402334

The following calculation agrees with example 8 of Allen:

>>> derived.doy(246)
>>> model.idx_sim = 0
>>> model.calc_solardeclination_v1()
>>> fluxes.solardeclination
solardeclination(0.117464)
class hydpy.models.evap.evap_model.Calc_SunsetHourAngle_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the sunset hour angle.

Requires the derived parameter:

LatitudeRad

Requires the flux sequence:

SolarDeclination

Calculates the flux sequence:

SunsetHourAngle

Basic equation (Allen, equation 25):

\(SunsetHourAngle = arccos(-tan(LatitudeRad) \cdot tan(SolarDeclination))\)

Example:

The following calculation agrees with example 8 of Allen:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> derived.doy.shape = 1
>>> derived.doy(246)
>>> derived.latituderad(-.35)
>>> fluxes.solardeclination = 0.12
>>> model.calc_sunsethourangle_v1()
>>> fluxes.sunsethourangle
sunsethourangle(1.526767)
class hydpy.models.evap.evap_model.Calc_SolarTimeAngle_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the solar time angle at the midpoint of the current period.

Requires the control parameter:

Longitude

Requires the derived parameters:

DOY SCT UTCLongitude

Calculates the flux sequence:

SolarTimeAngle

Basic equations (Allen, equations 31 to 33):

\(SolarTimeAngle = \pi / 12 \cdot ((SCT + (Longitude - UTCLongitude) / 15 + S_c) - 12)\)

\(S_c = 0.1645 \cdot sin(2 \cdot b) - 0.1255 \cdot cos(b) - 0.025 \cdot sin(b)\)

\(b = (2 \cdot \pi (DOY - 80)) / 365\)

Note there are two small deviations from the equations given by Allen. The first one is to describe longitudes east of Greenwich with positive numbers and longitudes west of Greenwich with negative numbers. The second one is due to the definition of parameter DOY, as explained in the documentation on method Calc_EarthSunDistance_V1.

Examples:

>>> from hydpy import pub, round_
>>> pub.timegrids = "2000-09-03", "2000-09-04", "1h"
>>> from hydpy.models.evap import *
>>> parameterstep()
>>> longitude(15)
>>> derived.doy.update()
>>> derived.sct.update()
>>> derived.utclongitude.update()
>>> for hour in range(24):
...     model.idx_sim = hour
...     model.calc_solartimeangle_v1()
...     print(hour, end=": ")
...     round_(fluxes.solartimeangle.value)   
0: -3.004157
1: -2.742358
...
11: -0.124364
12: 0.137435
...
22: 2.755429
23: 3.017229
class hydpy.models.evap.evap_model.Calc_ExtraterrestrialRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the extraterrestrial radiation.

Requires the derived parameters:

Seconds LatitudeRad

Requires the flux sequences:

SolarTimeAngle EarthSunDistance SolarDeclination SunsetHourAngle

Calculates the flux sequence:

ExtraterrestrialRadiation

Basic equation for daily simulation steps (Allen, equation 21):

\(ExternalTerrestrialRadiation = \frac{Seconds \ 4.92}{\pi \ 60 \cdot 60} \cdot EarthSunDistance \cdot ( SunsetHourAngle \cdot sin(LatitudeRad) \cdot sin(SolarDeclination) + cos(LatitudeRad) \cdot cos(SolarDeclination) \cdot sin(SunsetHourAngle) )\)

Basic equation for (sub)hourly simulation steps (Allen, eq. 28 to 30):

\(ExternalTerrestrialRadiation = \frac{12 \cdot 4.92}{\pi} \cdot EarthSunDistance \cdot ( (\omega_2 - \omega_1) \cdot sin(LatitudeRad) \cdot sin(SolarDeclination) + cos(LatitudeRad) \cdot cos(SolarDeclination) \cdot (sin(\omega_2) - sin(\omega_1)) )\)

\(omega_1 = SolarTimeAngle - \frac{\pi \cdot Seconds}{60 \cdot 60 \cdot 24}\)

\(omega_2 = SolarTimeAngle + \frac{\pi \cdot Seconds}{60 \cdot 60 \cdot 24}\)

Examples:

The following calculation agrees with example 8 of Allen for daily time steps:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> derived.seconds(60*60*24)
>>> derived.latituderad(-0.35)
>>> fluxes.earthsundistance = 0.985
>>> fluxes.solardeclination = 0.12
>>> fluxes.sunsethourangle = 1.527
>>> model.calc_extraterrestrialradiation_v1()
>>> fluxes.extraterrestrialradiation
extraterrestrialradiation(32.173851)

The following calculation repeats the above example for an hourly simulation time step, still covering the whole day:

>>> import numpy
>>> longitude(-20)
>>> derived.utclongitude(-20)
>>> derived.seconds(60*60)
>>> derived.doy.shape = 24
>>> derived.doy(246)
>>> derived.sct.shape = 24
>>> derived.sct = numpy.linspace(0.5, 23.5, 24)
>>> sum_ = 0.0
>>> from hydpy import round_
>>> for hour in range(24):
...     model.idx_sim = hour
...     model.calc_solartimeangle_v1()
...     model.calc_extraterrestrialradiation_v1()
...     print(hour, end=": ")
...     round_(fluxes.extraterrestrialradiation.value)
...     sum_ += fluxes.extraterrestrialradiation
0: 0.0
1: 0.0
2: 0.0
3: 0.0
4: 0.0
5: 0.0
6: 0.418507
7: 1.552903
8: 2.567915
9: 3.39437
10: 3.975948
11: 4.273015
12: 4.265326
13: 3.953405
14: 3.35851
15: 2.52118
16: 1.49848
17: 0.360103
18: 0.0
19: 0.0
20: 0.0
21: 0.0
22: 0.0
23: 0.0

Note that, even with identical values of the local longitude (Longitude) and the one of the time zone (UTCLongitude), the calculated radiation values are not symmetrically shaped during the day due to the eccentricity of the Earth”s orbit (see solar time).

There is a small deviation between the directly calculated daily value and the sum of the hourly values:

>>> round_(sum_)
32.139663

For sub-daily simulation time steps, the results of method Calc_ExtraterrestrialRadiation_V1 are most accurate for the shortest time steps. On the other hand, they can be (extremely) inaccurate for timesteps between one hour and one day. We demonstrate this by comparing the sum of the sub-daily values of different step sizes with the directly calculated daily value (note the apparent total fail of method Calc_ExtraterrestrialRadiation_V1 for a step size of 720 minutes):

>>> for minutes in [1, 5, 15, 30, 60, 90, 120, 144, 160,
...                 180, 240, 288, 360, 480, 720, 1440]:
...     derived.seconds(minutes*60)
...     nmb = int(1440/minutes)
...     derived.doy.shape = nmb
...     derived.doy(246)
...     derived.sct.shape = nmb
...     derived.sct = numpy.linspace(
...         minutes/60/2, 24-minutes/60/2, nmb)
...     sum_ = 0.0
...     for idx in range(nmb):
...         model.idx_sim = idx
...         model.calc_solartimeangle_v1()
...         model.calc_extraterrestrialradiation_v1()
...         sum_ += fluxes.extraterrestrialradiation
...     print(minutes, end=": ")
...     round_(sum_-32.173851)
1: -0.000054
5: -0.000739
15: -0.008646
30: -0.034188
60: -0.034188
90: -0.034188
120: -0.034188
144: -1.246615
160: -0.823971
180: -0.034188
240: -3.86418
288: -2.201488
360: -0.034188
480: -3.86418
720: -32.173851
1440: 0.0
class hydpy.models.evap.evap_model.Calc_PossibleSunshineDuration_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the possible astronomical sunshine duration.

Requires the derived parameter:

Seconds

Requires the flux sequences:

SolarTimeAngle SunsetHourAngle

Calculates the flux sequence:

PossibleSunshineDuration

Basic equation for daily timesteps (Allen, equation 34):

\(PossibleSunshineDuration = 24 / \pi \cdot SunsetHourAngle\)

Basic equation for (sub)hourly timesteps:

\(PossibleSunshineDuration = min(max(12 / \pi \cdot (SunsetHourAngle - \tau), 0), \frac{Seconds}{60 \cdot 60})\)

\(\tau = \Bigl \lbrace { {-SolarTimeAngle - \pi \cdot Days \ | \ SolarTimeAngle \leq 0} \atop {SolarTimeAngle - \pi \cdot Days \ | \ SolarTimeAngle > 0} }\)

Examples:

The following calculation agrees with example 9 of Allen:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> derived.seconds(60*60*24)
>>> fluxes.sunsethourangle(1.527)
>>> model.calc_possiblesunshineduration_v1()
>>> fluxes.possiblesunshineduration
possiblesunshineduration(11.665421)

The following calculation repeats the above example for an hourly simulation time step, still covering the whole day. Therefore the ratio is only calculated for the hours of sunrise and sunset. In between the ratio is set to 1 (day) or 0 (night):

>>> from hydpy import round_
>>> import numpy
>>> derived.seconds(60*60)
>>> solartimeangles = numpy.linspace(-3.004157, 3.017229, 24)
>>> sum_ = 0.
>>> for hour, solartimeangle in enumerate(solartimeangles):
...     fluxes.solartimeangle = solartimeangle
...     model.calc_possiblesunshineduration_v1()
...     print(hour, end=": ")   
...     round_(fluxes.possiblesunshineduration.value)
...     sum_ += fluxes.possiblesunshineduration.value
0: 0.0
...
5: 0.0
6: 0.857676
7: 1.0
...
16: 1.0
17: 0.807745
18: 0.0
...
23: 0.0

The sum of the hourly sunshine durations equals the one-step calculation result:

>>> round_(sum_)
11.665421
class hydpy.models.evap.evap_model.Calc_ClearSkySolarRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the clear sky solar radiation.

Requires the control parameters:

AngstromConstant AngstromFactor

Requires the derived parameter:

MOY

Requires the flux sequence:

ExtraterrestrialRadiation

Calculates the flux sequence:

ClearSkySolarRadiation

Basic equation (adjusted to Calc_GlobalRadiation_V1, Allen eq. 35):

\(ClearSkySolarRadiation = ExtraterrestrialRadiation \cdot (AngstromConstant + AngstromFactor)\)

Example:

We use the Ångström coefficients (a=0.19, b=0.55) recommended for Germany by DWA-M 504 for January and the default values (a=0.25, b=0.5) for February:

>>> from hydpy import pub
>>> pub.timegrids = "2000-01-30", "2000-02-03", "1d"
>>> from hydpy.models.evap import *
>>> parameterstep()
>>> angstromconstant.jan = 0.19
>>> angstromfactor.jan = 0.55
>>> angstromconstant.feb = 0.25
>>> angstromfactor.feb = 0.5
>>> derived.moy.update()
>>> fluxes.extraterrestrialradiation = 40.0
>>> model.idx_sim = 1
>>> model.calc_clearskysolarradiation_v1()
>>> fluxes.clearskysolarradiation
clearskysolarradiation(29.6)
>>> model.idx_sim = 2
>>> model.calc_clearskysolarradiation_v1()
>>> fluxes.clearskysolarradiation
clearskysolarradiation(30.0)
class hydpy.models.evap.evap_model.Update_LoggedClearSkySolarRadiation_V1[source]

Bases: hydpy.core.modeltools.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 memorized values to the right and stores the respective new value on the most left 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.Calc_GlobalRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the extraterrestrial radiation.

Requires the control parameters:

AngstromConstant AngstromFactor

Requires the derived parameter:

MOY

Requires the input sequence:

SunshineDuration

Requires the flux sequences:

ExtraterrestrialRadiation PossibleSunshineDuration

Calculates the flux sequence:

GlobalRadiation

Basic equation (Allen, equation 35):

\(GlobalRadiation = ExtraterrestrialRadiation \cdot ( AngstromConstant + AngstromFactor \cdot SunshineDuration / PossibleSunshineDuration )\)

Example:

We use the Ångström coefficients (a=0.19, b=0.55) recommended for Germany by DWA-M 504 for January and the default values (a=0.25, b=0.5) for February:

>>> from hydpy import pub, round_
>>> pub.timegrids = "2000-01-30", "2000-02-03", "1d"
>>> from hydpy.models.evap import *
>>> parameterstep()
>>> angstromconstant.jan = 0.19
>>> angstromfactor.jan = 0.55
>>> angstromconstant.feb = 0.25
>>> angstromfactor.feb = 0.5
>>> derived.moy.update()
>>> inputs.sunshineduration = 12.0
>>> fluxes.possiblesunshineduration = 14.0
>>> fluxes.extraterrestrialradiation = 40.0
>>> model.idx_sim = 1
>>> model.calc_globalradiation_v1()
>>> fluxes.globalradiation
globalradiation(26.457143)
>>> model.idx_sim = 2
>>> model.calc_globalradiation_v1()
>>> fluxes.globalradiation
globalradiation(27.142857)

For zero possible sunshine durations, Calc_GlobalRadiation_V1 sets GlobalRadiation to zero:

>>> fluxes.possiblesunshineduration = 0.0
>>> model.calc_globalradiation_v1()
>>> fluxes.globalradiation
globalradiation(0.0)
class hydpy.models.evap.evap_model.Update_LoggedGlobalRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Log the global radiation values of the last 24 hours.

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 memorized values to the right and stores the respective new value on the most left 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_NetShortwaveRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the net shortwave radiation for the hypothetical grass reference crop.

Requires the flux sequence:

GlobalRadiation

Calculates the flux sequence:

NetShortwaveRadiation

Basic equation (Allen, equation 38):

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

Example:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> fluxes.globalradiation = 20.0
>>> model.calc_netshortwaveradiation_v1()
>>> fluxes.netshortwaveradiation
netshortwaveradiation(15.4)
class hydpy.models.evap.evap_model.Calc_NetLongwaveRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the net longwave radiation.

Requires the derived parameters:

NmbLogEntries Seconds

Requires the input sequence:

AirTemperature

Requires the flux sequences:

ClearSkySolarRadiation GlobalRadiation ActualVapourPressure

Requires the log sequences:

LoggedGlobalRadiation LoggedClearSkySolarRadiation

Calculates the flux sequence:

NetLongwaveRadiation

Basic equation (Allen, equation 39, modified):

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

\(GR = \Bigl \lbrace { {GlobalRadiation \ | \ ClearSkySolarRadiation > 0} \atop {\sum{LoggedGlobalRadiation} \ | \ ClearSkySolarRadiation = 0} }\)

\(CSSR = \Bigl \lbrace { {ClearSkySolarRadiation \ | \ ClearSkySolarRadiation > 0} \atop {\sum{LoggedClearSkySolarRadiation} \ | \ ClearSkySolarRadiation = 0} }\)

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

Note that during night periods, when clear sky radiation is zero, we use the global radiation and clear sky radiation sums of the last 24 hours. Averaging over the last three hours before sunset, as suggested by Allen, could be a more precise but also more complicated and error-prone approach.

Example:

The following calculation agrees with example 11 of Allen:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> derived.seconds(60*60*24)
>>> derived.nmblogentries(1)
>>> inputs.airtemperature = 22.1
>>> fluxes.actualvapourpressure = 2.1
>>> fluxes.clearskysolarradiation = 18.8
>>> fluxes.globalradiation = 14.5
>>> model.calc_netlongwaveradiation_v1()
>>> fluxes.netlongwaveradiation
netlongwaveradiation(3.531847)

>>> fluxes.clearskysolarradiation = 0.0
>>> logs.loggedclearskysolarradiation.shape = 1
>>> logs.loggedclearskysolarradiation = 12.0
>>> logs.loggedglobalradiation.shape = 1
>>> logs.loggedglobalradiation = 10.0
>>> model.calc_netlongwaveradiation_v1()
>>> fluxes.netlongwaveradiation
netlongwaveradiation(3.959909)
class hydpy.models.evap.evap_model.Calc_NetRadiation_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the total net radiation.

Requires the flux sequences:

NetShortwaveRadiation NetLongwaveRadiation

Calculates the flux sequence:

NetRadiation

Basic equation (Allen, equation 40):

\(NetRadiation = NetShortwaveRadiation-NetLongwaveRadiation\)

Example:

The following calculation agrees with example 12 of Allen:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> fluxes.netshortwaveradiation  = 11.1
>>> fluxes.netlongwaveradiation  = 3.5
>>> model.calc_netradiation_v1()
>>> fluxes.netradiation
netradiation(7.6)
class hydpy.models.evap.evap_model.Calc_SoilHeatFlux_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the soil heat flux.

Requires the derived parameter:

Seconds

Requires the flux sequence:

NetRadiation

Calculates the flux sequence:

SoilHeatFlux

Basic equation for daily timesteps (Allen, equation 42):

\(SoilHeatFlux = 0\)

Basic equation for (sub)hourly timesteps (Allen, 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 one day, we define all steps with a positive NetRadiation to be part of the daylight period and all steps with a negative NetRadiation to be part of the nighttime period. In case the summed NetRadiation of all daylight steps is five times as high as the absolute summed NetRadiation of all nighttime steps, the total SoilHeatFlux is zero:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> derived.seconds(60*60)
>>> fluxes.netradiation = 10.0
>>> model.calc_soilheatflux_v1()
>>> fluxes.soilheatflux
soilheatflux(1.0)
>>> fluxes.netradiation = -2.0
>>> model.calc_soilheatflux_v1()
>>> fluxes.soilheatflux
soilheatflux(-1.0)

For any simulation step size of least one day, method Calc_SoilHeatFlux_V1 sets the SoilHeatFlux to zero, which is suggested by Allen for daily simulation steps only:

>>> derived.seconds(60*60*24)
>>> fluxes.netradiation = 10.0
>>> model.calc_soilheatflux_v1()
>>> fluxes.soilheatflux
soilheatflux(0.0)
>>> fluxes.netradiation = -2.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_PsychrometricConstant_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the psychrometric constant.

Requires the input sequence:

AtmosphericPressure

Calculates the flux sequence:

PsychrometricConstant

Basic equation (Allen, equation 8):

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

Example:

The following calculation agrees with example 2 of Allen:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> inputs.atmosphericpressure = 81.8
>>> model.calc_psychrometricconstant_v1()
>>> fluxes.psychrometricconstant
psychrometricconstant(0.054397)
class hydpy.models.evap.evap_model.Calc_ReferenceEvapotranspiration_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the reference evapotranspiration constant.

Requires the derived parameter:

Seconds

Requires the input sequence:

AirTemperature

Requires the flux sequences:

SaturationVapourPressureSlope NetRadiation SoilHeatFlux PsychrometricConstant AdjustedWindSpeed SaturationVapourPressure ActualVapourPressure

Calculates the flux sequence:

ReferenceEvapotranspiration

Basic equation (Allen, equation 6):

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

Note that Allen recommends the coefficient 37 for hourly simulations and the coefficient 900 for daily simulations. Function Calc_ReferenceEvapotranspiration_V1 generally uses 37.5, which gives 900 when multiplied with 24.

Example:

The following calculation agrees with example 18 of Allen, dealing with a daily simulation step:

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> derived.seconds(24*60*60)
>>> inputs.airtemperature = 16.9
>>> fluxes.netradiation = 13.28
>>> fluxes.soilheatflux = 0.0
>>> fluxes.psychrometricconstant = 0.0666
>>> fluxes.adjustedwindspeed = 2.078
>>> fluxes.actualvapourpressure = 1.409
>>> fluxes.saturationvapourpressure = 1.997
>>> fluxes.saturationvapourpressureslope = 0.122
>>> model.calc_referenceevapotranspiration_v1()
>>> fluxes.referenceevapotranspiration
referenceevapotranspiration(3.877117)

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

>>> derived.seconds(60*60)
>>> inputs.airtemperature = 38.0
>>> fluxes.netradiation = 1.749
>>> fluxes.soilheatflux = 0.175
>>> fluxes.psychrometricconstant = 0.0673
>>> fluxes.adjustedwindspeed = 3.3
>>> fluxes.actualvapourpressure = 3.445
>>> fluxes.saturationvapourpressure = 6.625
>>> fluxes.saturationvapourpressureslope = 0.358
>>> model.calc_referenceevapotranspiration_v1()
>>> fluxes.referenceevapotranspiration
referenceevapotranspiration(0.629106)

Parameter Features

Control parameters

class hydpy.models.evap.ControlParameters(master: hydpy.core.parametertools.Parameters, cls_fastaccess: Optional[Type[hydpy.core.parametertools.FastAccessParameter]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.variabletools.SubVariables[hydpy.core.parametertools.Parameters, Parameter, hydpy.core.parametertools.FastAccessParameter]

Control parameters of model evap.

The following classes are selected:
class hydpy.models.evap.evap_control.Latitude(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The latitude [decimal degrees].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (-90.0, 90.0)
name: str = 'latitude'
unit: str = 'decimal degrees'
class hydpy.models.evap.evap_control.Longitude(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The longitude [decimal degrees].

Required by the method:

Calc_SolarTimeAngle_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (-180.0, 180.0)
name: str = 'longitude'
unit: str = 'decimal degrees'
class hydpy.models.evap.evap_control.MeasuringHeightWindSpeed(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The height above ground of the wind speed measurements [m].

Required by the method:

Calc_AdjustedWindSpeed_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0, None)
name: str = 'measuringheightwindspeed'
unit: str = 'm'
class hydpy.models.evap.evap_control.AngstromConstant(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The Ångström “a” coefficient for calculating global radiation [-].

Required by the methods:

Calc_ClearSkySolarRadiation_V1 Calc_GlobalRadiation_V1

TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.25
trim(lower=None, upper=None)[source]

Trim values following \(AngstromConstant \leq 1 - AngstromFactor\) or at least following \(AngstromConstant \leq 1\).

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> angstromconstant(1.5)
>>> angstromconstant
angstromconstant(1.0)
>>> angstromfactor.value = 0.6
>>> angstromconstant(0.5)
>>> angstromconstant
angstromconstant(0.4)
name: str = 'angstromconstant'
unit: str = '-'
class hydpy.models.evap.evap_control.AngstromFactor(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The Ångström “b” coefficient for calculating global radiation [-].

Required by the methods:

Calc_ClearSkySolarRadiation_V1 Calc_GlobalRadiation_V1

TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool, None] = 0.5
trim(lower=None, upper=None)[source]

Trim values in accordance with \(AngstromFactor \leq 1 - AngstromConstant\) or at least in accordance with \(AngstromFactor \leq 1\).

>>> from hydpy.models.evap import *
>>> parameterstep()
>>> angstromfactor(1.5)
>>> angstromfactor
angstromfactor(1.0)
>>> angstromconstant.value = 0.6
>>> angstromfactor(0.5)
>>> angstromfactor
angstromfactor(0.4)
name: str = 'angstromfactor'
unit: str = '-'

Derived parameters

class hydpy.models.evap.DerivedParameters(master: hydpy.core.parametertools.Parameters, cls_fastaccess: Optional[Type[hydpy.core.parametertools.FastAccessParameter]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.variabletools.SubVariables[hydpy.core.parametertools.Parameters, Parameter, hydpy.core.parametertools.FastAccessParameter]

Derived parameters of model evap.

The following classes are selected:

  • DOY() References the “global” day of the year index array [-].

  • MOY() References the “global” month of the year index array [-].

  • Seconds() The length of the actual simulation step size in seconds [s].

  • SCT() References the “global” standard clock time array [h].

  • UTCLongitude() Longitude of the centre of the local time zone [°].

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

  • LatitudeRad() The latitude [rad].

class hydpy.models.evap.evap_derived.DOY(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

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

Required by the methods:

Calc_EarthSunDistance_V1 Calc_SolarDeclination_V1 Calc_SolarTimeAngle_V1

name: str = 'doy'
unit: str = '-'
class hydpy.models.evap.evap_derived.MOY(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

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

Required by the methods:

Calc_ClearSkySolarRadiation_V1 Calc_GlobalRadiation_V1

name: str = 'moy'
unit: str = '-'
class hydpy.models.evap.evap_derived.Seconds(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The length of the actual simulation step size in seconds [s].

Required by the methods:

Calc_ExtraterrestrialRadiation_V1 Calc_NetLongwaveRadiation_V1 Calc_PossibleSunshineDuration_V1 Calc_ReferenceEvapotranspiration_V1 Calc_SoilHeatFlux_V1

name: str = 'seconds'
unit: str = 's'
class hydpy.models.evap.evap_derived.SCT(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

References the “global” standard clock time array [h].

Required by the method:

Calc_SolarTimeAngle_V1

name: str = 'sct'
unit: str = 'h'
class hydpy.models.evap.evap_derived.UTCLongitude(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Longitude of the centre of the local time zone [°].

Required by the method:

Calc_SolarTimeAngle_V1

name: str = 'utclongitude'
unit: str = '°'
class hydpy.models.evap.evap_derived.NmbLogEntries(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

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

Required by the methods:

Calc_NetLongwaveRadiation_V1 Update_LoggedClearSkySolarRadiation_V1 Update_LoggedGlobalRadiation_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[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 the 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", "1h"
>>> derived.nmblogentries.update()
>>> derived.nmblogentries
nmblogentries(24)
>>> for seq in logs:
...     print(seq)
loggedglobalradiation(nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
                      nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
                      nan, nan, nan, nan)
loggedclearskysolarradiation(nan, nan, nan, nan, nan, nan, nan, nan,
                             nan, nan, nan, nan, nan, nan, nan, nan,
                             nan, nan, nan, nan, nan, nan, nan, nan)

There is an explicit check for inappropriate simulation step sizes:

>>> pub.timegrids = "2000-01-01 00:00", "2000-01-01 10:00", "5h"
>>> derived.nmblogentries.update()
Traceback (most recent call last):
...
ValueError: The value of parameter `nmblogentries` of element `?` cannot be determined for a the current simulation step size.  The fraction of the memory period (1d) and the simulation step size (5h) leaves a remainder.
name: str = 'nmblogentries'
unit: str = '-'
class hydpy.models.evap.evap_derived.LatitudeRad(subvars: SubVariablesType)[source]

Bases: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

The latitude [rad].

Required by the methods:

Calc_ExtraterrestrialRadiation_V1 Calc_SunsetHourAngle_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (-1.5708, 1.5708)
update()[source]

Update LatitudeRad based on parameter Latitude.

>>> from hydpy import round_
>>> from hydpy.models.evap import *
>>> parameterstep()
>>> for value in (-90.0, -45.0, 0.0, 45.0, 90.0):
...     latitude(value)
...     derived.latituderad.update()
...     round_(latitude.value, end=": ")
...     round_(derived.latituderad.value)
-90.0: -1.570796
-45.0: -0.785398
0.0: 0.0
45.0: 0.785398
90.0: 1.570796
name: str = 'latituderad'
unit: str = 'rad'

Sequence Features

Input sequences

class hydpy.models.evap.InputSequences(master: hydpy.core.sequencetools.Sequences, cls_fastaccess: Optional[Type[FastAccessType]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.sequencetools.ModelIOSequences[InputSequence, hydpy.core.sequencetools.FastAccessInputSequence]

Input sequences of model evap.

The following classes are selected:
class hydpy.models.evap.evap_inputs.AirTemperature(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelIOSequence[hydpy.core.sequencetools.InputSequences, hydpy.core.sequencetools.FastAccessInputSequence]

Air temperature [°C].

Required by the methods:

Calc_NetLongwaveRadiation_V1 Calc_ReferenceEvapotranspiration_V1 Calc_SaturationVapourPressureSlope_V1 Calc_SaturationVapourPressure_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'airtemperature'
unit: str = '°C'
class hydpy.models.evap.evap_inputs.RelativeHumidity(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelIOSequence[hydpy.core.sequencetools.InputSequences, hydpy.core.sequencetools.FastAccessInputSequence]

Relative humidity [%].

Required by the method:

Calc_ActualVapourPressure_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'relativehumidity'
unit: str = '%'
class hydpy.models.evap.evap_inputs.WindSpeed(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelIOSequence[hydpy.core.sequencetools.InputSequences, hydpy.core.sequencetools.FastAccessInputSequence]

Wind speed [m/s].

Required by the method:

Calc_AdjustedWindSpeed_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'windspeed'
unit: str = 'm/s'
class hydpy.models.evap.evap_inputs.SunshineDuration(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelIOSequence[hydpy.core.sequencetools.InputSequences, hydpy.core.sequencetools.FastAccessInputSequence]

Sunshine duration [h].

Required by the method:

Calc_GlobalRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'sunshineduration'
unit: str = 'h'
class hydpy.models.evap.evap_inputs.AtmosphericPressure(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelIOSequence[hydpy.core.sequencetools.InputSequences, hydpy.core.sequencetools.FastAccessInputSequence]

Atmospheric pressure [kPA].

Required by the method:

Calc_PsychrometricConstant_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'atmosphericpressure'
unit: str = 'kPA'

Flux sequences

class hydpy.models.evap.FluxSequences(master: hydpy.core.sequencetools.Sequences, cls_fastaccess: Optional[Type[FastAccessType]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.sequencetools.OutputSequences[FluxSequence]

Flux sequences of model evap.

The following classes are selected:
class hydpy.models.evap.evap_fluxes.AdjustedWindSpeed(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Adjusted wind speed [m/s].

Calculated by the method:

Calc_AdjustedWindSpeed_V1

Required by the method:

Calc_ReferenceEvapotranspiration_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'adjustedwindspeed'
unit: str = 'm/s'
class hydpy.models.evap.evap_fluxes.SaturationVapourPressure(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Saturation vapour pressure [kPa].

Calculated by the method:

Calc_SaturationVapourPressure_V1

Required by the methods:

Calc_ActualVapourPressure_V1 Calc_ReferenceEvapotranspiration_V1 Calc_SaturationVapourPressureSlope_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'saturationvapourpressure'
unit: str = 'kPa'
class hydpy.models.evap.evap_fluxes.SaturationVapourPressureSlope(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

The slope of the saturation vapour pressure curve [kPa/°C].

Calculated by the method:

Calc_SaturationVapourPressureSlope_V1

Required by the method:

Calc_ReferenceEvapotranspiration_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'saturationvapourpressureslope'
unit: str = 'kPa/°C'
class hydpy.models.evap.evap_fluxes.ActualVapourPressure(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Actual vapour pressure [kPa].

Calculated by the method:

Calc_ActualVapourPressure_V1

Required by the methods:

Calc_NetLongwaveRadiation_V1 Calc_ReferenceEvapotranspiration_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'actualvapourpressure'
unit: str = 'kPa'
class hydpy.models.evap.evap_fluxes.EarthSunDistance(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

The relative inverse distance between the earth and the sun [-].

Calculated by the method:

Calc_EarthSunDistance_V1

Required by the method:

Calc_ExtraterrestrialRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'earthsundistance'
unit: str = '-'
class hydpy.models.evap.evap_fluxes.SolarDeclination(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Solar declination [-].

Calculated by the method:

Calc_SolarDeclination_V1

Required by the methods:

Calc_ExtraterrestrialRadiation_V1 Calc_SunsetHourAngle_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'solardeclination'
unit: str = '-'
class hydpy.models.evap.evap_fluxes.SunsetHourAngle(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Sunset hour angle [rad].

Calculated by the method:

Calc_SunsetHourAngle_V1

Required by the methods:

Calc_ExtraterrestrialRadiation_V1 Calc_PossibleSunshineDuration_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'sunsethourangle'
unit: str = 'rad'
class hydpy.models.evap.evap_fluxes.SolarTimeAngle(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Solar time angle [rad].

Calculated by the method:

Calc_SolarTimeAngle_V1

Required by the methods:

Calc_ExtraterrestrialRadiation_V1 Calc_PossibleSunshineDuration_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'solartimeangle'
unit: str = 'rad'
class hydpy.models.evap.evap_fluxes.ExtraterrestrialRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Extraterrestial radiation [MJ/m²/T].

Calculated by the method:

Calc_ExtraterrestrialRadiation_V1

Required by the methods:

Calc_ClearSkySolarRadiation_V1 Calc_GlobalRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'extraterrestrialradiation'
unit: str = 'MJ/m²/T'
class hydpy.models.evap.evap_fluxes.PossibleSunshineDuration(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Possible astronomical sunshine duration [h].

Calculated by the method:

Calc_PossibleSunshineDuration_V1

Required by the method:

Calc_GlobalRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'possiblesunshineduration'
unit: str = 'h'
class hydpy.models.evap.evap_fluxes.ClearSkySolarRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Clear sky solar radiation [MJ/m²/T].

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'
unit: str = 'MJ/m²/T'
class hydpy.models.evap.evap_fluxes.GlobalRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Global radiation [MJ/m²/T].

Calculated by the method:

Calc_GlobalRadiation_V1

Required by the methods:

Calc_NetLongwaveRadiation_V1 Calc_NetShortwaveRadiation_V1 Update_LoggedGlobalRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'globalradiation'
unit: str = 'MJ/m²/T'
class hydpy.models.evap.evap_fluxes.NetShortwaveRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Net shortwave radiation [MJ/m²/T].

Calculated by the method:

Calc_NetShortwaveRadiation_V1

Required by the method:

Calc_NetRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'netshortwaveradiation'
unit: str = 'MJ/m²/T'
class hydpy.models.evap.evap_fluxes.NetLongwaveRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Net longwave radiation [MJ/m²/T].

Calculated by the method:

Calc_NetLongwaveRadiation_V1

Required by the method:

Calc_NetRadiation_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'netlongwaveradiation'
unit: str = 'MJ/m²/T'
class hydpy.models.evap.evap_fluxes.NetRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Total net radiation [MJ/m²/T].

Calculated by the method:

Calc_NetRadiation_V1

Required by the methods:

Calc_ReferenceEvapotranspiration_V1 Calc_SoilHeatFlux_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'netradiation'
unit: str = 'MJ/m²/T'
class hydpy.models.evap.evap_fluxes.SoilHeatFlux(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Soil heat flux [MJ/m²/T].

Calculated by the method:

Calc_SoilHeatFlux_V1

Required by the method:

Calc_ReferenceEvapotranspiration_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'soilheatflux'
unit: str = 'MJ/m²/T'
class hydpy.models.evap.evap_fluxes.PsychrometricConstant(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Psychrometric constant [kPa/°C].

Calculated by the method:

Calc_PsychrometricConstant_V1

Required by the method:

Calc_ReferenceEvapotranspiration_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'psychrometricconstant'
unit: str = 'kPa/°C'
class hydpy.models.evap.evap_fluxes.ReferenceEvapotranspiration(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.FluxSequences]

Reference evapotranspiration [mm/T].

Calculated by the method:

Calc_ReferenceEvapotranspiration_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'referenceevapotranspiration'
unit: str = 'mm/T'

Log sequences

class hydpy.models.evap.LogSequences(master: hydpy.core.sequencetools.Sequences, cls_fastaccess: Optional[Type[FastAccessType]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.sequencetools.ModelSequences[LogSequence, hydpy.core.variabletools.FastAccess]

Log sequences of model evap.

The following classes are selected:
class hydpy.models.evap.evap_logs.LoggedGlobalRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.LogSequences, hydpy.core.variabletools.FastAccess]

Logged global radiation [MJ/m²/T].

Updated by the method:

Update_LoggedGlobalRadiation_V1

Required by the method:

Calc_NetLongwaveRadiation_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedglobalradiation'
unit: str = 'MJ/m²/T'
class hydpy.models.evap.evap_logs.LoggedClearSkySolarRadiation(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.LogSequences, hydpy.core.variabletools.FastAccess]

Logged clear sky radiation [MJ/m²/T].

Updated by the method:

Update_LoggedClearSkySolarRadiation_V1

Required by the method:

Calc_NetLongwaveRadiation_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedclearskysolarradiation'
unit: str = 'MJ/m²/T'
class hydpy.models.evap.ControlParameters(master: hydpy.core.parametertools.Parameters, cls_fastaccess: Optional[Type[hydpy.core.parametertools.FastAccessParameter]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.variabletools.SubVariables[hydpy.core.parametertools.Parameters, Parameter, hydpy.core.parametertools.FastAccessParameter]

Control parameters of model evap.

The following classes are selected:
class hydpy.models.evap.DerivedParameters(master: hydpy.core.parametertools.Parameters, cls_fastaccess: Optional[Type[hydpy.core.parametertools.FastAccessParameter]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.variabletools.SubVariables[hydpy.core.parametertools.Parameters, Parameter, hydpy.core.parametertools.FastAccessParameter]

Derived parameters of model evap.

The following classes are selected:

  • DOY() References the “global” day of the year index array [-].

  • MOY() References the “global” month of the year index array [-].

  • Seconds() The length of the actual simulation step size in seconds [s].

  • SCT() References the “global” standard clock time array [h].

  • UTCLongitude() Longitude of the centre of the local time zone [°].

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

  • LatitudeRad() The latitude [rad].

class hydpy.models.evap.FluxSequences(master: hydpy.core.sequencetools.Sequences, cls_fastaccess: Optional[Type[FastAccessType]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.sequencetools.OutputSequences[FluxSequence]

Flux sequences of model evap.

The following classes are selected:
class hydpy.models.evap.InputSequences(master: hydpy.core.sequencetools.Sequences, cls_fastaccess: Optional[Type[FastAccessType]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.sequencetools.ModelIOSequences[InputSequence, hydpy.core.sequencetools.FastAccessInputSequence]

Input sequences of model evap.

The following classes are selected:
class hydpy.models.evap.LogSequences(master: hydpy.core.sequencetools.Sequences, cls_fastaccess: Optional[Type[FastAccessType]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.sequencetools.ModelSequences[LogSequence, hydpy.core.variabletools.FastAccess]

Log sequences of model evap.

The following classes are selected: