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:
Calc_AirTemperature_V1
Let a submodel that complies with theTempModel_V1
orTempModel_V2
interface determine the air temperature of the individual hydrological response units.Update_LoggedAirTemperature_V1
Log the air temperature values of the last 24 hours.Calc_DailyAirTemperature_V1
Calculate the average air temperature of the last 24 hours.Calc_WindSpeed2m_V1
Adjust the measured wind speed to a height of two meters above the ground following Allen et al. (1998).Calc_WindSpeed2m_V2
Adjust the measured wind speed to a height of 2 meters above the ground following LEG (2020).Update_LoggedWindSpeed2m_V1
Log the wind speed values 2 meters above the ground of the last 24 hours.Calc_DailyWindSpeed2m_V1
Calculate the average wind speed 2 meters above ground of the last 24 hours.Calc_WindSpeed10m_V1
Adjust the measured wind speed to a height of 10 meters above the ground following LEG (2020).Update_LoggedRelativeHumidity_V1
Log the relative humidity values of the last 24 hours.Calc_DailyRelativeHumidity_V1
Calculate the average of the relative humidity of the last 24 hours.Calc_SaturationVapourPressure_V1
Calculate the saturation vapour pressure according to Allen et al. (1998).Calc_SaturationVapourPressure_V2
Calculate the saturation vapour pressure according to Weischet and Endlicher (1983).Calc_DailySaturationVapourPressure_V1
Calculate the average of the saturation vapour pressure of the last 24 hours according to Weischet and Endlicher (1983).Calc_SaturationVapourPressureSlope_V1
Calculate the slope of the saturation vapour pressure curve according to Allen et al. (1998).Calc_SaturationVapourPressureSlope_V2
Calculate the slope of the saturation vapour pressure curve according to Weischet and Endlicher (1983).Calc_DailySaturationVapourPressureSlope_V1
Average the slope of the saturation vapour pressure curve according to Weischet and Endlicher (1983) of the last 24 hours.Calc_ActualVapourPressure_V1
Calculate the actual vapour pressure according to Allen et al. (1998).Calc_DailyActualVapourPressure_V1
Calculate the average of the actual vapour pressure of the last 24 hours.Calc_DryAirPressure_V1
Calculate the dry air pressure (DWD, 1987).Calc_AirDensity_V1
Calculate the air density (DWD, 1987).Process_RadiationModel_V1
Let a submodel that complies with theRadiationModel_V1
interface preprocess all eventually required data.Calc_PossibleSunshineDuration_V1
Query the possible sunshine duration from a submodel that complies with theRadiationModel_V1
orRadiationModel_V4
interface.Calc_SunshineDuration_V1
Query the actual sunshine duration from a submodel that complies with theRadiationModel_V1
orRadiationModel_V4
interface.Calc_ClearSkySolarRadiation_V1
Query the global radiation from a submodel that complies with theRadiationModel_V1
orRadiationModel_V3
interface.Calc_GlobalRadiation_V1
Query the global radiation from a submodel that complies with theRadiationModel_V1
,RadiationModel_V2
,RadiationModel_V3
, orRadiationModel_V4
interface.Update_LoggedSunshineDuration_V1
Log the sunshine duration values of the last 24 hours.Calc_DailySunshineDuration_V1
Calculate the sunshine duration sum of the last 24 hours.Update_LoggedPossibleSunshineDuration_V1
Log the astronomically possible sunshine duration values of the last 24 hours.Calc_DailyPossibleSunshineDuration_V1
Calculate the sunshine duration sum of the last 24 hours.Update_LoggedClearSkySolarRadiation_V1
Log the clear sky solar radiation values of the last 24 hours.Update_LoggedGlobalRadiation_V1
Log the global radiation values of the last 24 hours.Calc_CurrentAlbedo_V1
Take the land type- and month-specific albedo from parameterAlbedo
or a submodel that complies with theSnowAlbedoModel_V1
interface.Calc_CurrentAlbedo_V2
Calculate the earth’s surface albedo based on the current leaf area index and snow conditions following Löpmeier (2014).Calc_DailyGlobalRadiation_V1
Average the global radiation of the last 24 hours.Calc_NetShortwaveRadiation_V1
Calculate the net shortwave radiation for the hypothetical grass reference crop according to Allen et al. (1998).Calc_NetShortwaveRadiation_V2
Calculate the net shortwave radiation for a time-variable albedo.Calc_DailyNetShortwaveRadiation_V1
Calculate the net shortwave radiation average for the last 24 hours.Update_CloudCoverage_V1
Update the degree of cloud coverage.Calc_AdjustedCloudCoverage_V1
Calculate the adjusted cloud coverage degree.Calc_NetLongwaveRadiation_V1
Calculate the net longwave radiation according to Allen et al. (1998).Calc_NetLongwaveRadiation_V2
Calculate the net longwave radiation according to Löpmeier (2014), based on Holtslag et al. (1981), Idso and Jackson (1969), and Sellers (1960).Calc_DailyNetLongwaveRadiation_V1
Calculate the average net longwave radiation of the last 24 hours according to LEG (2020).Calc_NetRadiation_V1
Calculate the total net radiation according to Allen et al. (1998) and according to Löpmeier (2014).Calc_NetRadiation_V2
Calculate the total net radiation according to LEG (2020).Calc_DailyNetRadiation_V1
Calculate the average of the net radiation of the last 24 hours.Calc_SoilHeatFlux_V1
Calculate the soil heat flux according to Allen et al. (1998).Calc_SoilHeatFlux_V2
Calculate the MORECS-like soil heat flux roughly based on LEG (2020) and Thompson et al. (1981).Calc_SoilHeatFlux_V3
Take the monthly average soil heat flux as the current soil heat flux.Calc_SoilHeatFlux_V4
Calculate the AMBAV-like soil heat flux based on Löpmeier (2014).Calc_PsychrometricConstant_V1
Calculate the psychrometric constant according to Allen et al. (1998).Calc_AerodynamicResistance_V1
Calculate the aerodynamic resistance according to LEG (2020) and based on Thompson et al. (1981).Calc_AerodynamicResistance_V2
Calculate the aerodynamic resistance according to Löpmeier (2014).Calc_SoilSurfaceResistance_V1
Calculate the resistance of the bare soil surface according to LEG (2020) and based on Thompson et al. (1981).Calc_DailyPrecipitation_V1
Calculate the precipitation sum of the last 24 hours.Calc_DailyPotentialSoilEvapotranspiration_V1
Calculate the potential soil evapotranspiration sum of the last 24 hours.Update_SoilResistance_V1
Update the soil surface resistance following Löpmeier (2014).Calc_LanduseSurfaceResistance_V1
Calculate the resistance of vegetation surfaces, water surfaces and sealed surfaces according to LEG (2020) and based on Thompson et al. (1981).Calc_ActualSurfaceResistance_V1
Calculate the actual surface resistance according to LEG (2020), based on Grant (1975).Calc_ActualSurfaceResistance_V2
Calculate the actual surface resistance according to Löpmeier (2014) and based on Thompson et al. (1981).Calc_ReferenceEvapotranspiration_V1
Calculate the reference evapotranspiration constant according to Allen et al. (1998).Calc_ReferenceEvapotranspiration_V2
Calculate reference evapotranspiration after Turc-Wendling.Calc_ReferenceEvapotranspiration_V3
Take the input reference evapotranspiration for each hydrological response unit.Calc_ReferenceEvapotranspiration_V4
Let a submodel that complies with thePETModel_V1
interface calculate the reference evapotranspiration.Calc_ReferenceEvapotranspiration_V5
Adjust the normal evapotranspiration to the difference between actual air temperature and normal air temperature (Lindström et al., 1997).Adjust_ReferenceEvapotranspiration_V1
Adjust the previously calculated reference evapotranspiration.Calc_PotentialEvapotranspiration_V1
Calculate month-specific potential evaporation based on reference evapotranspiration.Calc_PotentialEvapotranspiration_V2
Calculate month- and land cover-specific potential evaporation based on reference evapotranspiration.Calc_PotentialEvapotranspiration_V3
Apply the altitude- and precipitation-related adjustment factors on reference evapotranspiration to determine potential evapotranspiration (Lindström et al., 1997).Update_PotentialEvapotranspiration_V1
Damp the given potential evapotranspiration and update the corresponding log sequence.Calc_MeanReferenceEvapotranspiration_V1
Calculate the average reference evapotranspiration.Calc_MeanPotentialEvapotranspiration_V1
Calculate the average potential evapotranspiration.Calc_InterceptedWater_V1
Let a submodel that complies with theIntercModel_V1
interface determine the current amount of intercepted water.Calc_SoilWater_V1
Let a submodel that complies with theSoilWaterModel_V1
interface determine the current soil water amount.Calc_SnowCover_V1
Let a submodel that complies with theSnowCoverModel_V1
interface determine the current snow cover degree.Calc_SnowyCanopy_V1
Query the current snow cover degree in the canopies of tree-like vegetation from a submodel that follows theSnowyCanopyModel_V1
interface, if available.Calc_PotentialWaterEvaporation_V1
Use a submodel that complies with thePETModel_V1
orPETModel_V2
interface to determine potential soil evapotranspiration.Calc_WaterEvaporation_V1
Calculate the actual evaporation from water areas according to Lindström et al. (1997).Calc_WaterEvaporation_V2
Accept potential evaporation from water areas as the actual one.Calc_WaterEvaporation_V3
Calculate the actual evaporation from water areas with the Penman equation according to LEG (2020), based on DVWK (1996).Calc_WaterEvaporation_V4
Calculate the evaporation from water areas by applying the Penman-Monteith equation with zero surface resistance.Update_LoggedWaterEvaporation_V1
Log the water evaporation values of the last 24 hours.Calc_DailyWaterEvaporation_V1
Calculate the water evaporation sum of the last 24 hours.Calc_InterceptionEvaporation_V1
Calculate the actual interception evaporation by setting it equal to potential evapotranspiration.Calc_PotentialInterceptionEvaporation_V1
Calculate the potential interception evaporation using an extended Penman-Monteith equation with zero surface resistance.Calc_PotentialInterceptionEvaporation_V2
Calculate the potential interception evaporation by applying the Penman-Monteith equation with zero surface resistance.Calc_PotentialInterceptionEvaporation_V3
Use a submodel that complies with thePETModel_V1
orPETModel_V2
interface to determine evaporation from water areas.Calc_InterceptionEvaporation_V2
Calculate the actual interception evaporation by setting it equal to potential interception evaporation.Calc_PotentialSoilEvapotranspiration_V1
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.Calc_PotentialSoilEvapotranspiration_V2
Use a submodel that complies with thePETModel_V1
orPETModel_V2
interface to determine potential soil evapotranspiration.Calc_SoilEvapotranspiration_V1
Calculate the actual soil evapotranspiration according to Lindström et al. (1997).Calc_SoilEvapotranspiration_V2
Calculate the actual soil evapotranspiration according to Minhas et al. (1974).Calc_SoilEvapotranspiration_V3
Calculate the evapotranspiration from the soil by applying the Penman-Monteith equation with an actual surface resistance considering the current soil moisture.Update_SoilEvapotranspiration_V1
Reduce actual soil evapotranspiration if the sum of interception evaporation and soil evapotranspiration exceeds potential evapotranspiration, according to Lindström et al. (1997).Update_SoilEvapotranspiration_V2
Reduce actual soil evapotranspiration due to snow covering.Update_SoilEvapotranspiration_V3
Reduce actual soil evapotranspiration if interception evaporation occurs simultaneously following Wigmosta et al. (1994).Update_LoggedPrecipitation_V1
Log the precipitation values of the last 24 hours.Update_LoggedPotentialSoilEvapotranspiration_V1
Log the potential soil evapotranspiration values of the last 24 hours.
- The following interface methods are available to main models using the defined model as a submodel:
Determine_PotentialEvapotranspiration_V1
Interface method that applies the complete application model by executing all “run methods”.Get_PotentialEvapotranspiration_V1
Get the current reference evapotranspiration from the selected hydrological response unit.Get_PotentialEvapotranspiration_V2
Get the current potential evapotranspiration from the selected hydrological response unit.Get_MeanPotentialEvapotranspiration_V1
Get the averaged reference evapotranspiration.Get_MeanPotentialEvapotranspiration_V2
Get the averaged potential evapotranspiration.Determine_InterceptionEvaporation_V1
Determine the actual interception evaporation according to Lindström et al. (1997).Determine_InterceptionEvaporation_V2
Determine the actual interception evaporation according to Thompson et al. (1981) and LEG (2020).Determine_PotentialInterceptionEvaporation_V1
Determine the potential interception evaporation according to AMBAV 1.0 (Löpmeier, 2014).Determine_SoilEvapotranspiration_V1
Determine the actual evapotranspiration from the soil according to Lindström et al. (1997).Determine_SoilEvapotranspiration_V2
Determine the actual evapotranspiration from the soil according to Minhas et al. (1974).Determine_SoilEvapotranspiration_V3
Determine the actual evapotranspiration from the soil according to Thompson et al. (1981) and LEG (2020).Determine_WaterEvaporation_V1
Determine the actual evapotranspiration from open water areas according to Lindström et al. (1997).Determine_WaterEvaporation_V2
Accept potential evapotranspiration as the actual evaporation from water areas.Determine_WaterEvaporation_V3
Determine the actual evapotranspiration from open water areas according to LEG (2020), based on DVWK (1996).Get_WaterEvaporation_V1
Get the current water area evaporation from the selected hydrological response unit.Get_PotentialWaterEvaporation_V1
Get the water area evaporation sum of the last 24 hours from the selected hydrological response unit.Get_PotentialInterceptionEvaporation_V1
Get the current potential interception evaporation from the selected hydrological response unit.Get_InterceptionEvaporation_V1
Get the current actual interception evaporation from the selected hydrological response unit.Get_PotentialSoilEvapotranspiration_V1
Get the current potential soil evapotranspiration from the selected hydrological response unit.Get_SoilEvapotranspiration_V1
Get the current soil evapotranspiration from the selected hydrological response unit.
- 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:
Return_AdjustedWindSpeed_V1
Adjust and return the measured wind speed to the defined height above the ground using the logarithmic wind profile.Return_SaturationVapourPressure_V1
Calculate and return the saturation vapour pressure according to Weischet and Endlicher (1983).Return_SaturationVapourPressureSlope_V1
Calculate and return the saturation vapour pressure slope according to Weischet and Endlicher (1983).Return_Evaporation_PenmanMonteith_V1
Calculate the actual evapotranspiration with the Penman-Monteith equation according to LEG (2020), based on Thompson et al. (1981).Return_Evaporation_PenmanMonteith_V2
Calculate the actual evapotranspiration with the Penman-Monteith equation according to Löpmeier (2014).Calc_ReferenceEvapotranspiration_PETModel_V1
Let a submodel that complies with thePETModel_V1
interface calculate the reference evapotranspiration.Calc_AirTemperature_TempModel_V1
Query hydrological response units’ air temperature from a main model referenced as a sub-submodel and follows theTempModel_V1
interface.Calc_AirTemperature_TempModel_V2
Let a submodel that complies with theTempModel_V2
interface determine the air temperature of the hydrological response units.Calc_Precipitation_PrecipModel_V1
Query precipitation from a main model that is referenced as a sub-submodel and follows thePrecipModel_V1
interface.Calc_Precipitation_PrecipModel_V2
Let a submodel that complies with thePrecipModel_V2
interface determine the precipitation.Calc_InterceptedWater_IntercModel_V1
Query the current amount of intercepted water from a submodel that follows theIntercModel_V1
interface.Calc_SoilWater_SoilWaterModel_V1
Query the current soil water amount from as submodel that follows theSoilWaterModel_V1
interface.Calc_SnowCover_SnowCoverModel_V1
Query the current snow cover degree from a submodel that follows theSnowCoverModel_V1
interface.Calc_SnowyCanopy_SnowyCanopyModel_V1
Query the current snow cover degree in the canopies of tree-like vegetation from a submodel that follows theSnowyCanopyModel_V1
interface.Calc_PotentialInterceptionEvaporation_PETModel_V1
Let a submodel that complies with thePETModel_V1
interface calculate potential evapotranspiration and assume it as potential interception evaporation.Calc_PotentialInterceptionEvaporation_PETModel_V2
Let a submodel that complies with thePETModel_V2
interface calculate potential interception evaporation and query it.Calc_PotentialSoilEvapotranspiration_PETModel_V1
Query the already calculated potential evapotranspiration from a submodel that complies with thePETModel_V1
interface and assume it as potential soil evapotranspiration.Calc_PotentialSoilEvapotranspiration_PETModel_V2
Let a submodel that complies with thePETModel_V2
interface calculate potential soil evapotranspiration and query it.Calc_PotentialWaterEvaporation_PETModel_V1
Query the already calculated potential evapotranspiration from a submodel that complies with thePETModel_V1
interface and assume it to be water evaporation.Calc_PotentialWaterEvaporation_PETModel_V2
Let a submodel that complies with thePETModel_V2
interface calculate potential water evaporation and query it.Calc_CurrentAlbedo_SnowAlbedoModel_V1
Query the current Earth surface albedo from a main model referenced as a sub-submodel and follows theSnowAlbedoModel_V1
interface.
- 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.
- 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:
- Requires the control parameter:
- Calculates the factor sequence:
Example:
We use the combination of
hland_96
andevap_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:
- Requires the control parameter:
- Calculates the factor sequence:
Example:
We use the combination of
evap_ret_tw2002
andmeteo_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
orTempModel_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:
- Calculates the factor sequence:
- 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:
- Requires the control parameter:
- Requires the derived parameter:
- Requires the factor sequence:
- Updates the log sequence:
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:
- Requires the control parameter:
- Requires the derived parameter:
- Requires the log sequence:
- Calculates the factor sequence:
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
andevap_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
andmeteo_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
orTempModel_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:
- Requires the input sequence:
- Calculates the factor sequence:
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:
- Requires the control parameter:
- Requires the fixed parameter:
- Requires the input sequence:
- 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:
- Required submethod:
- Requires the control parameter:
- Requires the fixed parameter:
- Requires the input sequence:
- Calculates the factor sequence:
Method
Calc_WindSpeed2m_V2
relies on methodReturn_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:
- Requires the derived parameter:
- Requires the factor sequence:
- Updates the log sequence:
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:
- Requires the derived parameter:
- Requires the log sequence:
- Calculates the factor sequence:
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:
- Requires the control parameter:
- Requires the fixed parameter:
- Requires the input sequence:
- Calculates the factor sequence:
Method
Calc_WindSpeed2m_V2
relies on methodReturn_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:
- Requires the derived parameter:
- Requires the input sequence:
- Updates the log sequence:
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:
- Requires the derived parameter:
- Requires the log sequence:
- Calculates the factor sequence:
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:
- Requires the control parameter:
- Requires the factor sequence:
- Calculates the factor sequence:
- 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:
- Required submethod:
- Requires the control parameter:
- Requires the factor sequence:
- Calculates the factor sequence:
- 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:
- Required submethod:
- Requires the control parameter:
- Requires the factor sequence:
- Calculates the factor sequence:
- 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:
- Requires the control parameter:
- Requires the factor sequences:
- Calculates the factor sequence:
- 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:
- Required submethod:
- Requires the control parameter:
- Requires the factor sequence:
- Calculates the factor sequence:
- 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:
- Required submethod:
- Requires the control parameter:
- Requires the factor sequence:
- Calculates the factor sequence:
- 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:
- Requires the input sequence:
- Requires the factor sequence:
- Calculates the factor sequence:
- 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:
- Requires the control parameter:
- Requires the factor sequences:
- Calculates the factor sequence:
- 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:
- Requires the input sequence:
- Requires the factor sequence:
- Calculates the factor sequence:
- 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:
- Requires the fixed parameters:
- Requires the factor sequences:
- Calculates the factor sequence:
- 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
andmeteo_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
orRadiationModel_V4
interface.- Required by the methods:
Determine_InterceptionEvaporation_V2
Determine_PotentialInterceptionEvaporation_V1
- Calculates the factor sequence:
Examples:
We combine
evap_pet_ambav1
with submodels that comply with different interfaces. First, withmeteo_glob_fao56
, which complies withRadiationModel_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 withRadiationModel_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
orRadiationModel_V4
interface.- Required by the methods:
Determine_InterceptionEvaporation_V2
Determine_PotentialInterceptionEvaporation_V1
- Calculates the factor sequence:
Examples:
We combine
evap_pet_ambav1
with submodels that comply with different interfaces. First, withmeteo_glob_fao56
, which complies withRadiationModel_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 withRadiationModel_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
orRadiationModel_V3
interface.- Calculates the flux sequence:
Examples:
We combine
evap_ret_fao56
with submodels that comply with different interfaces. First, withmeteo_glob_fao56
, which complies withRadiationModel_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 withRadiationModel_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
, orRadiationModel_V4
interface.- Required by the methods:
Determine_InterceptionEvaporation_V2
Determine_PotentialInterceptionEvaporation_V1
- Calculates the flux sequence:
Examples:
We combine three main models with submodels that comply with the four radiation-related interfaces. First,
evap_ret_fao56
withmeteo_glob_fao56
, which complies withRadiationModel_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
withmeteo_glob_io
, which complies withRadiationModel_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
withmeteo_clear_glob_io
, which complies withRadiationModel_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
withmeteo_psun_sun_glob_io
, which complies withRadiationModel_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:
- Requires the derived parameter:
- Requires the factor sequence:
- Updates the log sequence:
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:
- Requires the derived parameter:
- Requires the log sequence:
- Calculates the factor sequence:
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:
- Requires the derived parameter:
- Requires the factor sequence:
- Updates the log sequence:
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:
- Requires the derived parameter:
- Requires the log sequence:
- Calculates the factor sequence:
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:
- Requires the flux sequence:
- Updates the log sequence:
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:
- Requires the derived parameter:
- Requires the flux sequence:
- Updates the log sequence:
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:
- Requires the derived parameter:
- Requires the log sequence:
- Calculates the flux sequence:
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:
- Requires the control parameter:
- Calculates the factor sequence:
- 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 theSnowAlbedoModel_V1
interface.- Required by the method:
- Required submethod:
- Requires the control parameters:
- Requires the derived parameter:
- Calculates the factor sequence:
Examples:
We use the combination of
lland_knauf
andevap_aet_morsim
as an example and set different albedo values for the land typesACKER
andVERS
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 returnnan
values for snow-free conditions. In such cases (see the first and second hydrological response unit),Calc_CurrentAlbedo_V1
takes the relevant value from parameterAlbedo
. If there is a snow cover (see the third response unit), theSnowAlbedoModel_V1
submodel provides an albedo value andCalc_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 parameterAlbedo
if noSnowAlbedoModel_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:
- Requires the control parameters:
NmbHRU
HRUType
Soil
Plant
GroundAlbedo
GroundAlbedoSnow
LeafAlbedo
LeafAlbedoSnow
LeafAreaIndex
WetnessThreshold
- Requires the derived parameter:
- Requires the factor sequence:
- Requires the flux sequences:
- Calculates the factor sequence:
- 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
andevap_aet_minhas
as main models to prepare an applicableevap
instance (more precisely, anevap_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 onGroundAlbedoSnow
andLeafAlbedoSnow
instead ofGroundAlbedo
andLeafAlbedo
:>>> 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:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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:
- Requires the factor sequence:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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:
- Requires the control parameter:
- Requires the factor sequence:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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:
- Requires the derived parameters:
- Requires the factor sequences:
- Updates the state sequence:
- 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:
- Requires the control parameter:
- Requires the derived parameter:
- Requires the factor sequence:
- Requires the state sequence:
- Calculates the factor sequence:
- 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:
- Requires the derived parameter:
- Requires the factor sequences:
- Requires the flux sequences:
- Requires the log sequences:
- Calculates the flux sequence:
- 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:
- Requires the control parameters:
- Requires the fixed parameter:
- Requires the factor sequences:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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:
- Requires the control parameters:
- Requires the fixed parameters:
- Requires the factor sequences:
DailyAirTemperature
DailyActualVapourPressure
DailySunshineDuration
DailyPossibleSunshineDuration
- Calculates the flux sequence:
- 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:
- Requires the control parameter:
- Requires the flux sequences:
- Calculates the flux sequence:
- 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:
- Requires the control parameter:
- Requires the flux sequences:
- Calculates the flux sequence:
- 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:
- Requires the control parameter:
- Requires the flux sequences:
- Calculates the flux sequence:
- 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:
- Requires the derived parameter:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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 negativeNetRadiation
as part of the nighttime period. The totalSoilHeatFlux
is zero if the summedNetRadiation
during daytime is five times as high as the absolute summedNetRadiation
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 theSoilHeatFlux
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:
- Requires the derived parameters:
- Requires the factor sequences:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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 useCalc_SoilHeatFlux_V2
in any application model for now but leave it for further discussion and use the simplified methodCalc_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 applyevap
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 setsSoilHeatFlux
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) andDailyPossibleSunshineDuration
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 theAverageSoilHeatFlux
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:
- Requires the control parameters:
- Requires the derived parameter:
- Calculates the flux sequence:
- Basic equations:
\(SoilHeatFlux = AverageSoilHeatFlux\)
Note
Method
Calc_SoilHeatFlux_V3
is a workaround. We might remove it as soon as the shortcomings of methodCalc_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:
- Requires the control parameters:
- Requires the derived parameters:
- Requires the factor sequence:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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 applyevap
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:
- Calculates the factor sequence:
- 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:
- Requires the control parameters:
- Requires the derived parameter:
- Requires the factor sequence:
- Calculates the factor sequence:
- 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 applyevap
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:
- Requires the control parameters:
- Requires the derived parameters:
- Requires the factor sequence:
- Calculates the factor sequence:
- 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:
- Requires the control parameters:
- Requires the factor sequence:
- Calculates the factor sequence:
- 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 tonan
.>>> 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:
- Requires the derived parameter:
- Requires the flux sequence:
- Updates the log sequence:
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:
- Requires the control parameter:
- Requires the derived parameter:
- Requires the log sequence:
- Calculates the flux sequence:
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:
- Requires the derived parameter:
- Requires the flux sequence:
- Updates the log sequence:
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:
- Requires the control parameter:
- Requires the derived parameter:
- Requires the log sequence:
- Calculates the flux sequence:
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:
- Updates the state sequence:
- 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 tonan
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:
- Requires the control parameters:
NmbHRU
HRUType
Soil
Conifer
SurfaceResistance
MaxSoilWater
SoilMoistureLimit
- Requires the derived parameter:
- Requires the factor sequences:
AirTemperature
SaturationVapourPressure
ActualVapourPressure
SoilWater
- Calculates the factor sequence:
- 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 applyevap
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:
- Requires the control parameters:
- Requires the derived parameters:
- Requires the factor sequences:
PossibleSunshineDuration
SoilSurfaceResistance
LanduseSurfaceResistance
- Calculates the factor sequence:
- 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 applyevap
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 sequenceLanduseSurfaceResistance
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
andSoilSurfaceResistance
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:
- Requires the derived parameters:
- Requires the factor sequence:
- Requires the state sequence:
- Calculates the factor sequence:
- 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 methodCalc_ActualSurfaceResistance_V1
. We build up a comparable setting but uselland_dd
andevap_aet_minhas
as main models to prepare an applicableevap
instance (more precisely, anevap_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
andSoilResistance
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 thatCalc_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:
- Calculates the flux sequence:
Example:
We use the combination of
hland_96
andevap_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:
- Calculates the flux sequence:
Example:
We use the combination of
evap_pet_hbv96
andmeteo_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
orPrecipModel_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:
- Requires the control parameter:
- Calculates the factor sequence:
Example:
We use the combination of
hland_96
andevap_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:
- Requires the control parameter:
- Calculates the factor sequence:
- 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:
- Requires the control parameter:
- Calculates the factor sequence:
- 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:
- Required submethod:
- Requires the control parameter:
- Calculates the factor sequence:
Examples:
We use the combination of
lland_knauf_ic
andevap_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 setsSnowyCanopy
tonan
:>>> 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:
- Requires the control parameter:
- Calculates the factor sequence:
Example:
We use the combination of
hland_96
andevap_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:
- Requires the control parameter:
- Calculates the factor sequence:
- 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:
- Requires the control parameter:
- Calculates the factor sequence:
Example:
We use the combination of
hland_96
andevap_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:
- Requires the control parameter:
- Calculates the factor sequence:
- 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:
- Requires the fixed parameters:
StefanBoltzmannConstant
HeatOfCondensation
HeatCapacityAir
PsychrometricConstant
- Requires the factor sequences:
AirTemperature
SaturationVapourPressureSlope
SaturationVapourPressure
ActualVapourPressure
AirDensity
AerodynamicResistance
- Requires the flux sequences:
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
minusSoilHeatFlux
) and the vapour saturation pressure deficit (SaturationVapourPressure
minusActualVapourPressure
are identical. To make the results roughly comparable, we use resistances suitable for water surfaces by settingActualSurfaceResistance
to zero andAerodynamicResistance
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 methodReturn_Evaporation_PenmanMonteith_V1
. For response units four to six with dynamic forcing only, the results of methodReturn_Evaporation_PenmanMonteith_V1
are more than twice as large as those of methodCalc_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
andAerodynamicResistance
. The following example demonstrates this sensitivity through varyingActualSurfaceResistance
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 methodReturn_Evaporation_PenmanMonteith_V1
against this problem (and the less likely problem of zero aerodynamic resistance) by limiting the value ofAerodynamicResistance
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:
- Requires the factor sequences:
SaturationVapourPressureSlope
SaturationVapourPressure
ActualVapourPressure
AirDensity
AerodynamicResistance
- Requires the flux sequences:
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 methodReturn_Evaporation_PenmanMonteith_V1
except in neglecting the correction term C. We repeat the examples ofReturn_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:
- Requires the derived parameters:
- Requires the factor sequences:
SaturationVapourPressureSlope
PsychrometricConstant
AirTemperature
WindSpeed2m
SaturationVapourPressure
ActualVapourPressure
- Requires the flux sequences:
- Calculates the flux sequence:
- 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:
- Requires the factor sequence:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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:
- Requires the input sequence:
- Calculates the flux sequence:
- 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:
- Requires the control parameter:
- Calculates the flux sequence:
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:
- Requires the control parameter:
- Calculates the flux sequence:
- 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:
- Requires the input sequences:
- Requires the factor sequence:
- Calculates the flux sequence:
- 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:
- Requires the derived parameter:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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:
- Requires the derived parameter:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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 applyevap
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:
- Requires the derived parameter:
- Requires the flux sequences:
- Calculates the flux sequence:
- 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:
- Updates the flux sequence:
- Updates the log sequence:
- 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:
- Updates the flux sequence:
- 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:
- Requires the derived parameter:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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:
- Requires the derived parameter:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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:
- Requires the control parameter:
- Calculates the flux sequence:
Example:
We use
evap_aet_minhas
andevap_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:
- Requires the control parameter:
- Calculates the flux sequence:
Example:
We use
evap_aet_minhas
andevap_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
orPETModel_V2
interface to determine potential soil evapotranspiration.- Required by the methods:
- Required submethods:
Calc_PotentialWaterEvaporation_PETModel_V1
Calc_PotentialWaterEvaporation_PETModel_V2
- Requires the control parameter:
- Calculates the flux sequence:
- 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:
- Requires the control parameters:
- Requires the factor sequence:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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:
- Requires the control parameters:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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:
- Requires the control parameters:
- Requires the derived parameter:
- Requires the fixed parameters:
- Requires the factor sequences:
DailySaturationVapourPressure
DailySaturationVapourPressureSlope
DailyActualVapourPressure
DailyWindSpeed2m
- Requires the flux sequence:
- Calculates the flux sequence:
- 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:
- Requires the control parameters:
- Requires the fixed parameters:
- Requires the factor sequences:
SaturationVapourPressureSlope
SaturationVapourPressure
ActualVapourPressure
AirDensity
AerodynamicResistance
- Requires the flux sequences:
- Calculates the flux sequence:
- 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
takesSoilHeatFlux
into account, so it should usually be set to zero beforehand. Due to considering it, the following results agree with the first example on methodCalc_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:
- Requires the derived parameter:
- Requires the flux sequence:
- Updates the log sequence:
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:
- Requires the derived parameter:
- Requires the log sequence:
- Calculates the flux sequence:
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:
- Requires the control parameters:
- Requires the factor sequence:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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:
- Required submethod:
- Requires the control parameters:
- Requires the fixed parameters:
StefanBoltzmannConstant
HeatOfCondensation
HeatCapacityAir
PsychrometricConstant
- Requires the factor sequences:
AirTemperature
SaturationVapourPressureSlope
SaturationVapourPressure
ActualVapourPressure
AirDensity
AerodynamicResistance
- Requires the flux sequences:
- Calculates the flux sequence:
- 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:
- Required submethod:
- Requires the control parameters:
- Requires the fixed parameters:
- Requires the factor sequences:
SaturationVapourPressureSlope
SaturationVapourPressure
ActualVapourPressure
AirDensity
AerodynamicResistance
- Requires the flux sequences:
- Calculates the flux sequence:
- 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:
- Requires the control parameter:
- Calculates the flux sequence:
Example:
We use
evap_aet_minhas
andevap_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:
- Requires the control parameter:
- Calculates the flux sequence:
Example:
We use
evap_aet_minhas
andevap_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
orPETModel_V2
interface to determine evaporation from water areas.- Required by the method:
- Required submethods:
Calc_PotentialInterceptionEvaporation_PETModel_V1
Calc_PotentialInterceptionEvaporation_PETModel_V2
- Requires the control parameter:
- Calculates the flux sequence:
- 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:
- Requires the control parameters:
- Requires the factor sequences:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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:
- Requires the control parameters:
- Requires the fixed parameters:
- Requires the factor sequences:
SaturationVapourPressureSlope
SaturationVapourPressure
ActualVapourPressure
AirDensity
AerodynamicResistance
ActualSurfaceResistance
- Requires the flux sequences:
- Calculates the flux sequence:
- 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:
- Requires the control parameter:
- Calculates the flux sequence:
Example:
We use
evap_aet_minhas
andevap_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:
- Requires the control parameter:
- Calculates the flux sequence:
Example:
We use
evap_aet_minhas
andevap_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
orPETModel_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:
- Calculates the flux sequence:
- 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:
- Requires the control parameters:
- Requires the factor sequence:
- Requires the flux sequence:
- Calculates the flux sequence:
- 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:
- Requires the control parameters:
- Requires the factor sequence:
- Requires the flux sequence:
- Calculates the flux sequence:
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:
- Required submethod:
- Requires the control parameters:
- Requires the fixed parameters:
StefanBoltzmannConstant
HeatOfCondensation
HeatCapacityAir
PsychrometricConstant
- Requires the factor sequences:
SnowCover
AirTemperature
SaturationVapourPressureSlope
SaturationVapourPressure
ActualVapourPressure
AirDensity
AerodynamicResistance
ActualSurfaceResistance
- Requires the flux sequences:
- Calculates the flux sequence:
- 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:
- Requires the control parameters:
- Requires the flux sequences:
PotentialInterceptionEvaporation
PotentialSoilEvapotranspiration
InterceptionEvaporation
- Updates the flux sequence:
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:
- Requires the control parameters:
- Requires the factor sequence:
- Calculates the flux sequence:
- 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:
- Requires the flux sequences:
- Updates the flux sequence:
- 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:
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:
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:
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:
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:
- Requires the fixed parameters:
StefanBoltzmannConstant
GasConstantDryAir
GasConstantWaterVapour
HeatOfCondensation
HeatCapacityAir
RoughnessLengthGrass
PsychrometricConstant
- Requires the input sequences:
- Requires the log sequences:
- Updates the state sequence:
- 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:
- Calculates the factor sequence:
- Calculates the flux sequences:
- 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:
- Requires the fixed parameters:
StefanBoltzmannConstant
FactorCounterRadiation
GasConstantDryAir
GasConstantWaterVapour
HeatOfCondensation
HeatCapacityAir
RoughnessLengthGrass
PsychrometricConstant
- Requires the input sequences:
- 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:
- Requires the flux sequences:
- Calculates the factor sequences:
- Calculates the flux sequences:
- 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:
- Requires the flux sequences:
- Calculates the factor sequence:
- Calculates the flux sequences:
- 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:
- 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:
- 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:
- Calculates the factor sequence:
- Calculates the flux sequences:
- class hydpy.models.evap.evap_model.Determine_WaterEvaporation_V2[source]¶
Bases:
AutoMethod
Accept potential evapotranspiration as the actual evaporation from water areas.
- Required submethods:
- Requires the control parameters:
- Calculates the flux sequences:
- 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:
- Requires the derived parameters:
- Requires the fixed parameters:
HeatOfCondensation
PsychrometricConstant
RoughnessLengthGrass
- Requires the input sequence:
- Requires the factor sequences:
CurrentAlbedo
DailySaturationVapourPressure
DailySaturationVapourPressureSlope
DailyActualVapourPressure
- Requires the flux sequences:
- Updates the log sequences:
- Calculates the factor sequences:
- 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:
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:
- Requires the flux sequence:
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:
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:
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:
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:
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
andaetinterfaces
.Take the landtype_constants data to adjust the parameters
HRUType
andLandMonthFactor
, the landtype_refindices parameter instance to adjust the index references of all parameters inherited fromZipParameter1D
and the refweights parameter instance to adjust the weight references of all sequences inherited fromFactorSequence1D
orFluxSequence1D
, 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])
- 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
- mask: masktools.IndexMask¶
- 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¶
- 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¶
- 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¶
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
- 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
- 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
- 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
- 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
- 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
- class hydpy.models.evap.evap_control.Tree(subvars: SubParameters)[source]¶
Bases:
ZipParameter1D
A flag that indicates whether the individual zones contain tree-like vegetation.
- 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
- class hydpy.models.evap.evap_control.HRUArea(subvars: SubParameters)[source]¶
Bases:
Parameter
The area of each hydrological response unit [km²].
- 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
- class hydpy.models.evap.evap_control.MeasuringHeightWindSpeed(subvars: SubParameters)[source]¶
Bases:
Parameter
The height above ground of the wind speed measurements [m].
- class hydpy.models.evap.evap_control.AirTemperatureAddend(subvars: SubParameters)[source]¶
Bases:
ZipParameter1D
Adjustment addend for air temperature [K].
- 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:
- class hydpy.models.evap.evap_control.Albedo(subvars: SubParameters)[source]¶
Bases:
LandMonthParameter
Earth surface albedo [-].
- Required by the methods:
- 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
- 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
- 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
- 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
- class hydpy.models.evap.evap_control.LeafAreaIndex(subvars: SubParameters)[source]¶
Bases:
LandMonthParameter
Leaf area index [-].
- 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
- 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
- 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
- class hydpy.models.evap.evap_control.Emissivity(subvars: SubParameters)[source]¶
Bases:
Parameter
The emissivity of the land surface [-].
- 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
- 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
- class hydpy.models.evap.evap_control.WetSoilResistance(subvars: SubParameters)[source]¶
Bases:
SoilParameter1D
Surface resistance of wet soils [s/m].
- Required by the method:
- 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:
- 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
- class hydpy.models.evap.evap_control.LeafResistance(subvars: SubParameters)[source]¶
Bases:
PlantParameter1D
Surface resistance of plant leaves [s/m].
- Required by the method:
- class hydpy.models.evap.evap_control.EvapotranspirationFactor(subvars: SubParameters)[source]¶
Bases:
ZipParameter1D
The adjustment factor for potential evapotranspiration [-].
- Required by the method:
- 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:
- 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:
- class hydpy.models.evap.evap_control.AltitudeFactor(subvars: SubParameters)[source]¶
Bases:
ZipParameter1D
Decrease of potential evapotranspiration with altitude [-1/100m].
- Required by the method:
In the terminology of HBV96: ECAlt.
- 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:
In the terminology of HBV96: EPF.
- 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:
In the terminology of HBV96: ETF.
- class hydpy.models.evap.evap_control.DampingFactor(subvars: SubParameters)[source]¶
Bases:
ZipParameter1D
Damping factor (temporal weighting factor) for potential evapotranspiration [-].
- Required by the method:
- class hydpy.models.evap.evap_control.TemperatureThresholdIce(subvars: SubParameters)[source]¶
Bases:
WaterParameter1D
Temperature threshold for evaporation from water areas [°C].
- Required by the methods:
In the terminology of HBV96: TTIce.
- 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.
- 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.
- 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.
- 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.
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
- 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
- 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)
- class hydpy.models.evap.evap_derived.Altitude(subvars: SubParameters)[source]¶
Bases:
Parameter
Average (reference) subbasin altitude [100m].
- Required by the method:
- class hydpy.models.evap.evap_derived.Seconds(subvars: SubParameters)[source]¶
Bases:
SecondsParameter
The length of the actual simulation step size in seconds [h].
- 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
- class hydpy.models.evap.evap_derived.Days(subvars: SubParameters)[source]¶
Bases:
DaysParameter
The length of the actual simulation step size in days [d].
- 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
- 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.
- class hydpy.models.evap.evap_derived.RoughnessLength(subvars: SubParameters)[source]¶
Bases:
LandMonthParameter
Roughness length [m].
- 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])
- 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
- 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])
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:
StefanBoltzmannConstant()
Stefan-Boltzmann constant [W/m²/K].FactorCounterRadiation()
A factor for adjusting the atmospheric counter radiation [-].GasConstantDryAir()
Gas constant for dry air [J/kg/K].GasConstantWaterVapour()
Gas constant for water vapour [J/kg/K].HeatCapacityAir()
Specific heat capacity of air [J/kg/K].HeatOfCondensation()
Latent condensation heat of water at 15°C [WT/kg].RoughnessLengthGrass()
Roughness length for short grass [m].PsychrometricConstant()
Psychrometric constant [hPa/K].AerodynamicResistanceFactorMinimum()
The lowest allowed factor for calculating aerodynamic resistance [-].
- 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
- 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
- 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
- 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
- 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
- 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
- class hydpy.models.evap.evap_fixed.RoughnessLengthGrass(subvars: SubParameters)[source]¶
Bases:
FixedParameter
Roughness length for short grass [m].
- 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
- class hydpy.models.evap.evap_fixed.AerodynamicResistanceFactorMinimum(subvars: SubParameters)[source]¶
Bases:
FixedParameter
The lowest allowed factor for calculating aerodynamic resistance [-].
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.
- mask¶
- class hydpy.models.evap.evap_sequences.FluxSequence1D(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Base class for 1-dimensional flux sequences.
- mask¶
- class hydpy.models.evap.evap_sequences.StateSequence1D(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
StateSequence
Base class for 1-dimensional state sequences.
- mask¶
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:
ReferenceEvapotranspiration()
Reference evapotranspiration [mm/T].RelativeHumidity()
Relative humidity [%].WindSpeed()
Wind speed [m/s].AtmosphericPressure()
Atmospheric pressure [hPa].NormalAirTemperature()
Normal air temperature [°C].NormalEvapotranspiration()
Normal evapotranspiration [mm/T].
- class hydpy.models.evap.evap_inputs.ReferenceEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
InputSequence
Reference evapotranspiration [mm/T].
- Required by the method:
- STANDARD_NAME: ClassVar[StandardInputNames] = 'potential_evapotranspiration'¶
- 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
- STANDARD_NAME: ClassVar[StandardInputNames] = 'relative_humidity'¶
- 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
- STANDARD_NAME: ClassVar[StandardInputNames] = 'wind_speed'¶
- 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
- STANDARD_NAME: ClassVar[StandardInputNames] = 'atmospheric_pressure'¶
- class hydpy.models.evap.evap_inputs.NormalAirTemperature(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
InputSequence
Normal air temperature [°C].
- Required by the method:
In the terminology of HBV96: TN.
- STANDARD_NAME: ClassVar[StandardInputNames] = 'normal_air_temperature'¶
- class hydpy.models.evap.evap_inputs.NormalEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
InputSequence
Normal evapotranspiration [mm/T].
- Required by the method:
In the terminology of HBV96: EPN.
- STANDARD_NAME: ClassVar[StandardInputNames] = 'normal_evapotranspiration'¶
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:
MeanAirTemperature()
The basin’s mean air temperature [°C].AirTemperature()
Air temperature [°C].DailyAirTemperature()
The average air temperature in the last 24 hours [°C].WindSpeed2m()
Wind speed at 2 m above grass-like vegetation [m/s].DailyWindSpeed2m()
Average wind speed 2 meters above ground in the last 24 hours [m/s].WindSpeed10m()
Wind speed at 10 m above grass-like vegetation [m/s].DailyRelativeHumidity()
Average relative humidity in the last 24 hours [%].SunshineDuration()
Sunshine duration [h].PossibleSunshineDuration()
Astronomically possible sunshine duration [h].DailySunshineDuration()
The actual sunshine duration in the last 24 hours [h].DailyPossibleSunshineDuration()
The astronomically possible sunshine duration in the last 24 hours [h].SaturationVapourPressure()
Saturation vapour pressure [hPa].DailySaturationVapourPressure()
Average saturation vapour pressure in the last 24 hours [hPa].SaturationVapourPressureSlope()
The slope of the saturation vapour pressure curve [hPa/K].DailySaturationVapourPressureSlope()
Average saturation vapour pressure slope in the last 24 hours [hPa/K].ActualVapourPressure()
Actual vapour pressure [hPa].DailyActualVapourPressure()
The average actual vapour pressure in the last 24 hours [hPa].DryAirPressure()
Dry air pressure [hPa].AirDensity()
Air density [kg/m³].PsychrometricConstant()
Psychrometric constant [hPa/K].CurrentAlbedo()
The current albedo of the relevant surface [-].AdjustedCloudCoverage()
Adjusted degree of cloud coverage [-].AerodynamicResistance()
Aerodynamic resistance [s/m].SoilSurfaceResistance()
Soil surface resistance [s/m].LanduseSurfaceResistance()
Surface resistance for the current moisture conditions of water areas, sealed areas, and vegetation [s/m].ActualSurfaceResistance()
Actual surface resistance [s/m].InterceptedWater()
Intercepted water [mm].SoilWater()
Soil water content [mm].SnowCover()
Snow cover degree [-].SnowyCanopy()
Snow cover degree in the canopies of tree-like vegetation (is fornan
non-tree-like vegetation) [-].
- 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:
- 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
- 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
- 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
- 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:
- Required by the method:
- 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:
- 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:
- 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:
- 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
- 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:
- 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:
- 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
- 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
- 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
- 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:
- 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
- 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
- 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:
- 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
- class hydpy.models.evap.evap_factors.PsychrometricConstant(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FactorSequence
Psychrometric constant [hPa/K].
- Calculated by the method:
- Required by the method:
- 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
- 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:
- 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
- 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:
- 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:
- 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
- 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
- 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
- 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
- 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:
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:
Precipitation()
Precipitation [mm/T].DailyPrecipitation()
The precipitation sum of the last 24 hours [mm/d].GlobalRadiation()
Global radiation [W/m²].ClearSkySolarRadiation()
Clear sky solar radiation [W/m²].DailyGlobalRadiation()
Average global radiation in the last 24 hours [W/m²].NetShortwaveRadiation()
Net shortwave radiation [W/m²].DailyNetShortwaveRadiation()
Average net shortwave radiation in the last 24 hours [W/m²].NetLongwaveRadiation()
Net longwave radiation [W/m²].DailyNetLongwaveRadiation()
Average net longwave radiation in the last 24 hours [W/m²].NetRadiation()
Total net radiation [W/m²].DailyNetRadiation()
Average net radiation in the last 24 hours [W/m²].SoilHeatFlux()
Soil heat flux [W/m²].ReferenceEvapotranspiration()
Reference (grass) evapotranspiration [mm/T].PotentialInterceptionEvaporation()
Potential interception evaporation [mm/T].PotentialSoilEvapotranspiration()
Potential evapotranspiration from soils [mm/T].PotentialEvapotranspiration()
Potential (land type-specific) evapotranspiration [mm/T].DailyPotentialSoilEvapotranspiration()
The potential soil evapotranspiration sum of the last 24 hours [mm/d].MeanReferenceEvapotranspiration()
Mean reference evapotranspiration [mm/T].MeanPotentialEvapotranspiration()
Mean potential evapotranspiration [mm/T].PotentialWaterEvaporation()
Potential evaporation from open water areas [mm/T].WaterEvaporation()
Actual evaporation from open water areas [mm/T].DailyWaterEvaporation()
The water evaporation sum of the last 24 hours [mm/d].InterceptionEvaporation()
Actual interception evaporation [mm/T].SoilEvapotranspiration()
Actual soil evapotranspiration [mm/T].
- 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
- 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:
- 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
- class hydpy.models.evap.evap_fluxes.ClearSkySolarRadiation(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Clear sky solar radiation [W/m²].
- Calculated by the method:
- Required by the methods:
Calc_NetLongwaveRadiation_V1
Update_LoggedClearSkySolarRadiation_V1
- 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:
- Required by the method:
- 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:
- 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:
- 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:
- 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
- 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
- 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:
- Required by the methods:
- 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
- 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:
- Required by the methods:
Calc_MeanReferenceEvapotranspiration_V1
Calc_PotentialEvapotranspiration_V1
Calc_PotentialEvapotranspiration_V2
Calc_PotentialEvapotranspiration_V3
Get_PotentialEvapotranspiration_V1
- 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
- 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
- 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:
- Required by the methods:
Calc_MeanPotentialEvapotranspiration_V1
Get_PotentialEvapotranspiration_V2
- 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:
- class hydpy.models.evap.evap_fluxes.MeanReferenceEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Mean reference evapotranspiration [mm/T].
- Calculated by the method:
- Required by the method:
- class hydpy.models.evap.evap_fluxes.MeanPotentialEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Mean potential evapotranspiration [mm/T].
- Calculated by the method:
- Required by the method:
- 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:
- 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:
- 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:
- Required by the method:
- 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
- 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:
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:
CloudCoverage()
Degree of cloud coverage [-].SoilResistance()
Actual soil surface resistance [s/m].
- 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:
- class hydpy.models.evap.evap_states.SoilResistance(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
StateSequence1D
Actual soil surface resistance [s/m].
- Updated by the method:
- Required by the method:
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:
LoggedAirTemperature()
Logged air temperature [°C].LoggedPrecipitation()
Logged precipitation [mm/T].LoggedWindSpeed2m()
Logged wind speed at 2 m above grass-like vegetation [m/s].LoggedRelativeHumidity()
Logged relative humidity [%].LoggedSunshineDuration()
Logged sunshine duration [h].LoggedPossibleSunshineDuration()
Logged astronomically possible sunshine duration [h].LoggedGlobalRadiation()
Logged global radiation [W/m²].LoggedClearSkySolarRadiation()
Logged clear sky radiation [W/m²].LoggedPotentialEvapotranspiration()
Logged (damped) potential evapotranspiration [mm/T].LoggedWaterEvaporation()
Logged evaporation from water areas [mm/T].LoggedPotentialSoilEvapotranspiration()
Logged potential soil evapotranspiration [mm/T].
- 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:
- class hydpy.models.evap.evap_logs.LoggedPrecipitation(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
LogSequence
Logged precipitation [mm/T].
- Updated by the method:
- Required by the methods:
Calc_DailyPrecipitation_V1
Determine_PotentialInterceptionEvaporation_V1
- 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:
- Required by the method:
- 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:
- 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:
- 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:
- 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:
- class hydpy.models.evap.evap_logs.LoggedClearSkySolarRadiation(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
LogSequence
Logged clear sky radiation [W/m²].
- Updated by the method:
- Required by the method:
- class hydpy.models.evap.evap_logs.LoggedPotentialEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
LogSequence
Logged (damped) potential evapotranspiration [mm/T].
- Updated by the method:
- 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)
- 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:
- Required by the method:
- class hydpy.models.evap.evap_logs.LoggedPotentialSoilEvapotranspiration(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
LogSequence
Logged potential soil evapotranspiration [mm/T].
- Updated by the method:
- Required by the methods:
Calc_DailyPotentialSoilEvapotranspiration_V1
Determine_PotentialInterceptionEvaporation_V1
Auxiliary Features¶
Masks¶
- 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.
- 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.
- 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.
- 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:
MeanAirTemperature()
The basin’s mean air temperature [°C].AirTemperature()
Air temperature [°C].DailyAirTemperature()
The average air temperature in the last 24 hours [°C].WindSpeed2m()
Wind speed at 2 m above grass-like vegetation [m/s].DailyWindSpeed2m()
Average wind speed 2 meters above ground in the last 24 hours [m/s].WindSpeed10m()
Wind speed at 10 m above grass-like vegetation [m/s].DailyRelativeHumidity()
Average relative humidity in the last 24 hours [%].SunshineDuration()
Sunshine duration [h].PossibleSunshineDuration()
Astronomically possible sunshine duration [h].DailySunshineDuration()
The actual sunshine duration in the last 24 hours [h].DailyPossibleSunshineDuration()
The astronomically possible sunshine duration in the last 24 hours [h].SaturationVapourPressure()
Saturation vapour pressure [hPa].DailySaturationVapourPressure()
Average saturation vapour pressure in the last 24 hours [hPa].SaturationVapourPressureSlope()
The slope of the saturation vapour pressure curve [hPa/K].DailySaturationVapourPressureSlope()
Average saturation vapour pressure slope in the last 24 hours [hPa/K].ActualVapourPressure()
Actual vapour pressure [hPa].DailyActualVapourPressure()
The average actual vapour pressure in the last 24 hours [hPa].DryAirPressure()
Dry air pressure [hPa].AirDensity()
Air density [kg/m³].PsychrometricConstant()
Psychrometric constant [hPa/K].CurrentAlbedo()
The current albedo of the relevant surface [-].AdjustedCloudCoverage()
Adjusted degree of cloud coverage [-].AerodynamicResistance()
Aerodynamic resistance [s/m].SoilSurfaceResistance()
Soil surface resistance [s/m].LanduseSurfaceResistance()
Surface resistance for the current moisture conditions of water areas, sealed areas, and vegetation [s/m].ActualSurfaceResistance()
Actual surface resistance [s/m].InterceptedWater()
Intercepted water [mm].SoilWater()
Soil water content [mm].SnowCover()
Snow cover degree [-].SnowyCanopy()
Snow cover degree in the canopies of tree-like vegetation (is fornan
non-tree-like vegetation) [-].
- 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:
StefanBoltzmannConstant()
Stefan-Boltzmann constant [W/m²/K].FactorCounterRadiation()
A factor for adjusting the atmospheric counter radiation [-].GasConstantDryAir()
Gas constant for dry air [J/kg/K].GasConstantWaterVapour()
Gas constant for water vapour [J/kg/K].HeatCapacityAir()
Specific heat capacity of air [J/kg/K].HeatOfCondensation()
Latent condensation heat of water at 15°C [WT/kg].RoughnessLengthGrass()
Roughness length for short grass [m].PsychrometricConstant()
Psychrometric constant [hPa/K].AerodynamicResistanceFactorMinimum()
The lowest allowed factor for calculating aerodynamic resistance [-].
- 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:
Precipitation()
Precipitation [mm/T].DailyPrecipitation()
The precipitation sum of the last 24 hours [mm/d].GlobalRadiation()
Global radiation [W/m²].ClearSkySolarRadiation()
Clear sky solar radiation [W/m²].DailyGlobalRadiation()
Average global radiation in the last 24 hours [W/m²].NetShortwaveRadiation()
Net shortwave radiation [W/m²].DailyNetShortwaveRadiation()
Average net shortwave radiation in the last 24 hours [W/m²].NetLongwaveRadiation()
Net longwave radiation [W/m²].DailyNetLongwaveRadiation()
Average net longwave radiation in the last 24 hours [W/m²].NetRadiation()
Total net radiation [W/m²].DailyNetRadiation()
Average net radiation in the last 24 hours [W/m²].SoilHeatFlux()
Soil heat flux [W/m²].ReferenceEvapotranspiration()
Reference (grass) evapotranspiration [mm/T].PotentialInterceptionEvaporation()
Potential interception evaporation [mm/T].PotentialSoilEvapotranspiration()
Potential evapotranspiration from soils [mm/T].PotentialEvapotranspiration()
Potential (land type-specific) evapotranspiration [mm/T].DailyPotentialSoilEvapotranspiration()
The potential soil evapotranspiration sum of the last 24 hours [mm/d].MeanReferenceEvapotranspiration()
Mean reference evapotranspiration [mm/T].MeanPotentialEvapotranspiration()
Mean potential evapotranspiration [mm/T].PotentialWaterEvaporation()
Potential evaporation from open water areas [mm/T].WaterEvaporation()
Actual evaporation from open water areas [mm/T].DailyWaterEvaporation()
The water evaporation sum of the last 24 hours [mm/d].InterceptionEvaporation()
Actual interception evaporation [mm/T].SoilEvapotranspiration()
Actual soil evapotranspiration [mm/T].
- 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:
ReferenceEvapotranspiration()
Reference evapotranspiration [mm/T].RelativeHumidity()
Relative humidity [%].WindSpeed()
Wind speed [m/s].AtmosphericPressure()
Atmospheric pressure [hPa].NormalAirTemperature()
Normal air temperature [°C].NormalEvapotranspiration()
Normal evapotranspiration [mm/T].
- 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:
LoggedAirTemperature()
Logged air temperature [°C].LoggedPrecipitation()
Logged precipitation [mm/T].LoggedWindSpeed2m()
Logged wind speed at 2 m above grass-like vegetation [m/s].LoggedRelativeHumidity()
Logged relative humidity [%].LoggedSunshineDuration()
Logged sunshine duration [h].LoggedPossibleSunshineDuration()
Logged astronomically possible sunshine duration [h].LoggedGlobalRadiation()
Logged global radiation [W/m²].LoggedClearSkySolarRadiation()
Logged clear sky radiation [W/m²].LoggedPotentialEvapotranspiration()
Logged (damped) potential evapotranspiration [mm/T].LoggedWaterEvaporation()
Logged evaporation from water areas [mm/T].LoggedPotentialSoilEvapotranspiration()
Logged potential soil evapotranspiration [mm/T].
- 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:
CloudCoverage()
Degree of cloud coverage [-].SoilResistance()
Actual soil surface resistance [s/m].