dam¶
The HydPy-D base model provides features to implement water barriers like dams, weirs, lakes, or polders.
Method Features¶
- class hydpy.models.dam.dam_model.Model[source]¶
Bases:
ELSModel
Dam base model.
- The following “receiver update methods” are called in the given sequence before performing a simulation step:
Pic_TotalRemoteDischarge_V1
Update the receiver sequenceTotalRemoteDischarge
.Update_LoggedTotalRemoteDischarge_V1
Log a new entry of the discharge at a cross-section far downstream.Pic_LoggedRequiredRemoteRelease_V1
Update the receiver sequenceLoggedRequiredRemoteRelease
.Pic_LoggedRequiredRemoteRelease_V2
Update the receiver sequenceLoggedRequiredRemoteRelease
.Calc_RequiredRemoteRelease_V2
Get the required remote release of the last simulation step.Pic_LoggedAllowedRemoteRelief_V1
Update the receiver sequenceLoggedAllowedRemoteRelief
.Calc_AllowedRemoteRelief_V1
Get the allowed remote relief of the last simulation step.
- The following “inlet update methods” are called in the given sequence at the beginning of each simulation step:
Calc_AdjustedPrecipitation_V1
Adjust the given precipitation.Calc_AdjustedEvaporation_V1
Adjust the given potential evaporation.Calc_ActualEvaporation_V1
Calculate the actual evaporation.Pic_Inflow_V1
Update the inlet sequenceInflow
.Pic_Inflow_V2
Update the inlet sequenceInflow
.Calc_NaturalRemoteDischarge_V1
Estimate the natural discharge of a cross-section far downstream based on the last few simulation steps.Calc_RemoteDemand_V1
Estimate the discharge demand of a cross-section far downstream.Calc_RemoteFailure_V1
Estimate the shortfall of actual discharge under the required discharge of a cross section far downstream.Calc_RequiredRemoteRelease_V1
Guess the required release necessary to not fall below the threshold value at a cross section far downstream with a certain level of certainty.Calc_RequiredRelease_V1
Calculate the total water release (immediately and far downstream) required for reducing drought events.Calc_RequiredRelease_V2
Calculate the water release (immediately downstream) required for reducing drought events.Calc_TargetedRelease_V1
Calculate the targeted water release for reducing drought events, taking into account both the required water release and the actual inflow into the dam.
- The following methods define the relevant components of a system of ODE equations (e.g. direct runoff):
Pic_Inflow_V1
Update the inlet sequenceInflow
.Pic_Inflow_V2
Update the inlet sequenceInflow
.Calc_WaterLevel_V1
Determine the water level based on an interpolation approach approximating the relationship between water volume and water level.Calc_SurfaceArea_V1
Determine the surface area based on an interpolation approach approximating the relationship between water level and the surface area.Calc_AllowedDischarge_V1
Calculate the maximum discharge not leading to exceedance of the allowed water level drop.Calc_AllowedDischarge_V2
Calculate the maximum discharge not leading to exceedance of the allowed water level drop.Calc_ActualRelease_V1
Calculate the actual water release that can be supplied by the dam considering the targeted release and the given water level.Calc_ActualRelease_V2
Calculate the actual water release in aggrement with the allowed release not causing harm downstream and the actual water volume.Calc_ActualRelease_V3
Calculate an actual water release that tries to change the water storage into the direction of the actual target volume without violating the required minimum and the allowed maximum flow.Calc_PossibleRemoteRelief_V1
Calculate the highest possible water release that can be routed to a remote location based on an interpolation approach approximating the relationship between possible release and water stage.Calc_ActualRemoteRelief_V1
Calculate the actual amount of water released to a remote location to relieve the dam during high flow conditions.Calc_ActualRemoteRelease_V1
Calculate the actual remote water release that can be supplied by the dam considering the required remote release and the given water level.Update_ActualRemoteRelief_V1
Constrain the actual relief discharge to a remote location.Update_ActualRemoteRelease_V1
Constrain the actual release (supply discharge) to a remote location.Calc_FloodDischarge_V1
Calculate the discharge during and after a flood event based on seasonally varying interpolation approaches approximating the relationship(s) between discharge and water stage.Calc_Outflow_V1
Calculate the total outflow of the dam.Calc_Outflow_V2
Calculate the total outflow of the dam, taking the allowed water discharge into account.
- The following methods define the complete equations of an ODE system (e.g. change in storage of fast water due to effective precipitation and direct runoff):
Update_WaterVolume_V1
Update the actual water volume.Update_WaterVolume_V2
Update the actual water volume.Update_WaterVolume_V3
Update the actual water volume.Update_WaterVolume_V4
Update the actual water volume.
- The following “outlet update methods” are called in the given sequence at the end of each simulation step:
Pass_Outflow_V1
Update the outlet link sequenceQ
.Update_LoggedOutflow_V1
Log a new entry of discharge at a cross section far downstream.Pass_ActualRemoteRelease_V1
Update the outlet link sequenceS
.Pass_ActualRemoteRelief_V1
Update the outlet link sequenceR
.
- The following “sender update methods” are called in the given sequence after performing a simulation step:
Calc_MissingRemoteRelease_V1
Calculate the portion of the required remote demand that could not be met by the actual discharge release.Pass_MissingRemoteRelease_V1
Update the outlet link sequenceD
.Calc_AllowedRemoteRelief_V2
Calculate the allowed maximum relief that another location is allowed to discharge into the dam.Pass_AllowedRemoteRelief_V1
Update the outlet link sequenceR
.Calc_RequiredRemoteSupply_V1
Calculate the supply required from another location.Pass_RequiredRemoteSupply_V1
Update the outlet link sequenceS
.
- 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:
Fix_Min1_V1
Apply functionsmooth_min1()
without risking negative results.
- class hydpy.models.dam.dam_model.Calc_AdjustedPrecipitation_V1[source]¶
Bases:
Method
Adjust the given precipitation.
- Requires the control parameter:
- Requires the derived parameter:
- Requires the input sequence:
- Calculates the flux sequence:
- Basic equation:
\(AdjustedPrecipitation = InputFactor \cdot CorrectionPrecipitation \cdot Precipitation\)
Example:
>>> from hydpy.models.dam import * >>> simulationstep("1h") >>> parameterstep() >>> surfacearea(36.0) >>> correctionprecipitation(1.25) >>> derived.seconds.update() >>> derived.inputfactor.update() >>> inputs.precipitation = 2.0 >>> model.calc_adjustedprecipitation_v1() >>> fluxes.adjustedprecipitation adjustedprecipitation(25.0)
- class hydpy.models.dam.dam_model.Calc_AdjustedEvaporation_V1[source]¶
Bases:
Method
Adjust the given potential evaporation.
- Requires the control parameters:
- Requires the derived parameter:
- Requires the input sequence:
- Updates the log sequence:
- Calculates the flux sequence:
- Basic equation:
\(AdjustedEvaporation = WeightEvaporation \cdot InputFactor \cdot CorrectionEvaporation \cdot Evaporation + (1 - WeightEvaporation) \cdot LoggedAdjustedEvaporation\)
Examples:
Besides transforming units (mm/T to m³/s), method
Calc_AdjustedEvaporation_V1
modifies the given potential evaporation values in two ways. First, it increases or reduces its general level via parameterCorrectionEvaporation
and, second, it delays and damps its variability via parameterWeightEvaporation
. We begin with the first functionality by setting the correction factor to 1.25 and the weighting factor to 1.0:>>> from hydpy.models.dam import * >>> simulationstep("1h") >>> parameterstep("1h") >>> surfacearea(36.0) >>> correctionevaporation(1.25) >>> weightevaporation(1.0) >>> derived.seconds.update() >>> derived.inputfactor.update() >>> inputs.evaporation = 2.0 >>> logs.loggedadjustedevaporation = 20.0 >>> model.calc_adjustedevaporation_v1() >>> fluxes.adjustedevaporation adjustedevaporation(25.0)
Note that method
Calc_AdjustedEvaporation_V1
also updates the log sequenceLoggedAdjustedEvaporation
with the same value as flux sequenceAdjustedEvaporation
:>>> logs.loggedadjustedevaporation loggedadjustedevaporation(25.0)
Setting the weighting factor to a value smaller one activates the damping-delay mechanism. A value of 0.6 implies a weighting of 60 % of the “new” evaporation value (here: 2.0 mm/h or 25 m³/s) and of 40 % of the “old” evaporation value (here: 1.6 mm/h or 20 m³/s):
>>> weightevaporation(0.6) >>> logs.loggedadjustedevaporation = 20.0 >>> model.calc_adjustedevaporation_v1() >>> fluxes.adjustedevaporation adjustedevaporation(23.0) >>> logs.loggedadjustedevaporation loggedadjustedevaporation(23.0)
- class hydpy.models.dam.dam_model.Calc_ActualEvaporation_V1[source]¶
Bases:
Method
Calculate the actual evaporation.
- Requires the control parameter:
- Requires the derived parameter:
- Requires the factor sequence:
- Requires the flux sequence:
- Calculates the flux sequence:
- Basic equation:
\(ActualEvaporation = AdjustedEvaporation \cdot smooth_{logistic1}(ThresholdEvaporation - WaterLevel, SmoothParEvaporation)\)
- Used auxiliary method:
smooth_logistic1()
Examples:
First, we prepare a
UnitTest
object to illustrate the relationship between the water level and actual evaporation for different settings:>>> from hydpy.models.dam import * >>> parameterstep() >>> fluxes.adjustedevaporation = 2.0 >>> from hydpy import UnitTest >>> test = UnitTest(model, model.calc_actualevaporation_v1, ... last_example=10, ... parseqs=(factors.waterlevel, ... fluxes.actualevaporation)) >>> test.nexts.waterlevel = [value / 1000.0 for value in range(-1, 9)]
The most intuitive way to configure method
Calc_ActualEvaporation_V1
is to setWaterLevelMinimumThreshold
andWaterLevelMinimumTolerance
to zero. Then, there is a sharp transition between zero and potential evaporation around a water level of 0 m:>>> thresholdevaporation(0.0) >>> toleranceevaporation(0.0) >>> derived.smoothparevaporation.update()
>>> test() | ex. | waterlevel | actualevaporation | ---------------------------------------- | 1 | -0.001 | 0.0 | | 2 | 0.0 | 1.0 | | 3 | 0.001 | 2.0 | | 4 | 0.002 | 2.0 | | 5 | 0.003 | 2.0 | | 6 | 0.004 | 2.0 | | 7 | 0.005 | 2.0 | | 8 | 0.006 | 2.0 | | 9 | 0.007 | 2.0 | | 10 | 0.008 | 2.0 |
For numerical efficiency (and more natural transitions), it is preferable to set
WaterLevelMinimumTolerance
to a value larger than zero. Here, we set it to 1 mm and adjustWaterLevelMinimumThreshold
so that the actual evaporation values are (at least for the shown precision) zero below a water level of 0 mm:>>> thresholdevaporation(0.004) >>> toleranceevaporation(0.001) >>> derived.smoothparevaporation.update() >>> test() | ex. | waterlevel | actualevaporation | ---------------------------------------- | 1 | -0.001 | 0.0 | | 2 | 0.0 | 0.0 | | 3 | 0.001 | 0.000002 | | 4 | 0.002 | 0.000204 | | 5 | 0.003 | 0.02 | | 6 | 0.004 | 1.0 | | 7 | 0.005 | 1.98 | | 8 | 0.006 | 1.999796 | | 9 | 0.007 | 1.999998 | | 10 | 0.008 | 2.0 |
- class hydpy.models.dam.dam_model.Pic_Inflow_V1[source]¶
Bases:
Method
Update the inlet sequence
Inflow
.
- class hydpy.models.dam.dam_model.Pic_Inflow_V2[source]¶
Bases:
Method
Update the inlet sequence
Inflow
.
- class hydpy.models.dam.dam_model.Pic_TotalRemoteDischarge_V1[source]¶
Bases:
Method
Update the receiver sequence
TotalRemoteDischarge
.- Requires the receiver sequence:
- Calculates the flux sequence:
- Basic equation:
\(TotalRemoteDischarge = Q\)
- class hydpy.models.dam.dam_model.Pic_LoggedRequiredRemoteRelease_V1[source]¶
Bases:
Method
Update the receiver sequence
LoggedRequiredRemoteRelease
.- Requires the receiver sequence:
- Calculates the log sequence:
- Basic equation:
\(LoggedRequiredRemoteRelease = D\)
- class hydpy.models.dam.dam_model.Pic_LoggedRequiredRemoteRelease_V2[source]¶
Bases:
Method
Update the receiver sequence
LoggedRequiredRemoteRelease
.- Requires the receiver sequence:
- Calculates the log sequence:
- Basic equation:
\(LoggedRequiredRemoteRelease = S\)
- class hydpy.models.dam.dam_model.Pic_Exchange_V1[source]¶
Bases:
Method
Update the inlet sequence
Exchange
.- Basic equation:
\(Exchange = \sum E_{inlets}\)
- class hydpy.models.dam.dam_model.Pic_LoggedAllowedRemoteRelief_V1[source]¶
Bases:
Method
Update the receiver sequence
LoggedAllowedRemoteRelief
.- Requires the receiver sequence:
- Calculates the log sequence:
- Basic equation:
\(LoggedAllowedRemoteRelief = R\)
- class hydpy.models.dam.dam_model.Update_LoggedTotalRemoteDischarge_V1[source]¶
Bases:
Method
Log a new entry of the discharge at a cross-section far downstream.
- Requires the control parameter:
- Requires the flux sequence:
- Updates the log sequence:
Example:
The following example shows that method
Update_LoggedTotalRemoteDischarge_V1
moves the three memorised values successively to the right and stores the respective new value on the bare left position:>>> from hydpy.models.dam import * >>> parameterstep() >>> nmblogentries(3) >>> logs.loggedtotalremotedischarge = 0.0 >>> from hydpy import UnitTest >>> test = UnitTest(model, model.update_loggedtotalremotedischarge_v1, ... last_example=4, ... parseqs=(fluxes.totalremotedischarge, ... logs.loggedtotalremotedischarge)) >>> test.nexts.totalremotedischarge = [1.0, 3.0, 2.0, 4.0] >>> del test.inits.loggedtotalremotedischarge >>> test() | ex. | totalremotedischarge | loggedtotalremotedischarge | --------------------------------------------------------------------- | 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.dam.dam_model.Calc_WaterLevel_V1[source]¶
Bases:
Method
Determine the water level based on an interpolation approach approximating the relationship between water volume and water level.
- Requires the control parameter:
- Requires the state sequence:
- Calculates the factor sequence:
Example:
We prepare a straightforward relationship based on a single neuron in the hidden layer:
>>> from hydpy.models.dam import * >>> parameterstep() >>> watervolume2waterlevel( ... ANN(nmb_inputs=1, nmb_neurons=(1,), nmb_outputs=1, ... weights_input=0.5, weights_output=1.0, ... intercepts_hidden=0.0, intercepts_output=-0.5))
At least in the water volume range used in the following examples, the shape of the relationship looks acceptable:
>>> from hydpy import UnitTest >>> test = UnitTest( ... model, model.calc_waterlevel_v1, ... last_example=10, ... parseqs=(states.watervolume, factors.waterlevel)) >>> test.nexts.watervolume = range(10) >>> test() | ex. | watervolume | waterlevel | ---------------------------------- | 1 | 0.0 | 0.0 | | 2 | 1.0 | 0.122459 | | 3 | 2.0 | 0.231059 | | 4 | 3.0 | 0.317574 | | 5 | 4.0 | 0.380797 | | 6 | 5.0 | 0.424142 | | 7 | 6.0 | 0.452574 | | 8 | 7.0 | 0.470688 | | 9 | 8.0 | 0.482014 | | 10 | 9.0 | 0.489013 |
Larger neural networks or piecewise polynomials allow for more realistic approximations of measured relationships between water volume and water level.
- class hydpy.models.dam.dam_model.Calc_SurfaceArea_V1[source]¶
Bases:
Method
Determine the surface area based on an interpolation approach approximating the relationship between water level and the surface area.
- Requires the control parameter:
- Requires the state sequence:
- Calculates the aide sequence:
- Basic equation:
\(SurfaceArea = \frac{dWaterVolume}{WaterLevel}\)
Example:
Method
Calc_SurfaceArea_V1
relies on the identical neural network as methodCalc_WaterLevel_V1
. Therefore, we reuse the same network configuration:>>> from hydpy.models.dam import * >>> parameterstep()
>>> watervolume2waterlevel( ... ANN(nmb_inputs=1, nmb_neurons=(1,), nmb_outputs=1, ... weights_input=0.5, weights_output=1.0, ... intercepts_hidden=0.0, intercepts_output=-0.5))
>>> from hydpy import UnitTest >>> test = UnitTest( ... model, model.calc_surfacearea_v1, ... last_example=10, ... parseqs=(states.watervolume, aides.surfacearea)) >>> test.nexts.watervolume = range(10) >>> test() | ex. | watervolume | surfacearea | ----------------------------------- | 1 | 0.0 | 8.0 | | 2 | 1.0 | 8.510504 | | 3 | 2.0 | 10.172323 | | 4 | 3.0 | 13.409638 | | 5 | 4.0 | 19.048783 | | 6 | 5.0 | 28.529158 | | 7 | 6.0 | 44.270648 | | 8 | 7.0 | 70.291299 | | 9 | 8.0 | 113.232931 | | 10 | 9.0 | 184.056481 |
We apply the class
NumericalDifferentiator
to validate the calculated surface area corresponding to a water volume of 9 million m³:>>> from hydpy import NumericalDifferentiator, round_ >>> numdiff = NumericalDifferentiator( ... xsequence=states.watervolume, ... ysequences=[factors.waterlevel], ... methods=[model.calc_waterlevel_v1]) >>> numdiff() d_waterlevel/d_watervolume: 0.005433
Calculating the inverse of the above result (\(dV/dh\) instead of \(dh/dV\)) gives the surface area tabulated above:
>>> round_(1.0/0.005433115, decimals=5) 184.05648
- class hydpy.models.dam.dam_model.Calc_AllowedRemoteRelief_V2[source]¶
Bases:
Method
Calculate the allowed maximum relief that another location is allowed to discharge into the dam.
- Requires the control parameters:
- Requires the derived parameters:
- Requires the factor sequence:
- Calculates the flux sequence:
- Used auxiliary method:
smooth_logistic1()
- Basic equation:
\(ActualRemoteRelief = HighestRemoteRelief \cdot smooth_{logistic1}(WaterLevelReliefThreshold-WaterLevel, WaterLevelReliefSmoothPar)\)
Examples:
All control parameters involved in the calculation of
AllowedRemoteRelief
are subclasses ofSeasonalParameter
. This design allows simulating seasonal dam control schemes. To show how this works, we first define a short simulation period of two days:>>> from hydpy import pub >>> pub.timegrids = "2001.03.30", "2001.04.03", "1d"
We prepare the dam model and define two different control schemes for the hydrological summer (April to October) and winter month (November to May):
>>> from hydpy.models.dam import * >>> parameterstep() >>> highestremoterelief(_11_1_12=1.0, _03_31_12=1.0, ... _04_1_12=2.0, _10_31_12=2.0) >>> waterlevelreliefthreshold(_11_1_12=3.0, _03_31_12=2.0, ... _04_1_12=4.0, _10_31_12=4.0) >>> waterlevelrelieftolerance(_11_1_12=0.0, _03_31_12=0.0, ... _04_1_12=1.0, _10_31_12=1.0) >>> derived.waterlevelreliefsmoothpar.update() >>> derived.toy.update()
The following test function calculates
AllowedRemoteRelief
water levels ranging from 0.0 and 8.0 meters:>>> from hydpy import UnitTest >>> test = UnitTest(model, ... model.calc_allowedremoterelief_v2, ... last_example=9, ... parseqs=(factors.waterlevel, ... fluxes.allowedremoterelief)) >>> test.nexts.waterlevel = range(9)
On March 30 (which is the last day of the winter month and the first day of the simulation period), the value of
WaterLevelReliefSmoothPar
is zero. Hence,AllowedRemoteRelief
drops abruptly from 1 m³/s (defined byHighestRemoteRelief
) to 0 m³/s as soon asWaterLevel
reaches 3 m (defined by ofWaterLevelReliefThreshold
):>>> model.idx_sim = pub.timegrids.init["2001.03.30"] >>> test(first_example=2, last_example=6) | ex. | waterlevel | allowedremoterelief | ------------------------------------------ | 3 | 1.0 | 1.0 | | 4 | 2.0 | 1.0 | | 5 | 3.0 | 0.0 | | 6 | 4.0 | 0.0 |
April 1 (the first day of the summer and the last day of the simulation period) comes with increased parameter values. The value of parameter
WaterLevelReliefSmoothPar
is 1 m. Hence, loosely speaking,AllowedRemoteRelief
approaches the “discontinuous extremes (2 m³/s – defined byHighestRemoteRelief
– and 0 m³/s) to 99 % within a span of 2 m³/s around the original threshold value of 4 m³/s defined byWaterLevelReliefThreshold
:>>> model.idx_sim = pub.timegrids.init["2001.04.01"] >>> test() | ex. | waterlevel | allowedremoterelief | ------------------------------------------ | 1 | 0.0 | 2.0 | | 2 | 1.0 | 1.999998 | | 3 | 2.0 | 1.999796 | | 4 | 3.0 | 1.98 | | 5 | 4.0 | 1.0 | | 6 | 5.0 | 0.02 | | 7 | 6.0 | 0.000204 | | 8 | 7.0 | 0.000002 | | 9 | 8.0 | 0.0 |
- class hydpy.models.dam.dam_model.Calc_RequiredRemoteSupply_V1[source]¶
Bases:
Method
Calculate the supply required from another location.
- Requires the control parameters:
- Requires the derived parameters:
- Requires the factor sequence:
- Calculates the flux sequence:
- Used auxiliary method:
smooth_logistic1()
- Basic equation:
\(RequiredRemoteSupply = HighestRemoteSupply \cdot smooth_{logistic1}(WaterLevelSupplyThreshold-WaterLevel, WaterLevelSupplySmoothPar)\)
Examples:
Method
Calc_RequiredRemoteSupply_V1
is functionally identical with methodCalc_AllowedRemoteRelief_V2
. Hence, the following examples serve for testing purposes only (see the documentation on functionCalc_AllowedRemoteRelief_V2
for more detailed information):>>> from hydpy import pub >>> pub.timegrids = "2001.03.30", "2001.04.03", "1d" >>> from hydpy.models.dam import * >>> parameterstep() >>> highestremotesupply(_11_1_12=1.0, _03_31_12=1.0, ... _04_1_12=2.0, _10_31_12=2.0) >>> waterlevelsupplythreshold(_11_1_12=3.0, _03_31_12=2.0, ... _04_1_12=4.0, _10_31_12=4.0) >>> waterlevelsupplytolerance(_11_1_12=0.0, _03_31_12=0.0, ... _04_1_12=1.0, _10_31_12=1.0) >>> derived.waterlevelsupplysmoothpar.update() >>> derived.toy.update() >>> from hydpy import UnitTest >>> test = UnitTest(model, ... model.calc_requiredremotesupply_v1, ... last_example=9, ... parseqs=(factors.waterlevel, ... fluxes.requiredremotesupply)) >>> test.nexts.waterlevel = range(9) >>> model.idx_sim = pub.timegrids.init["2001.03.30"] >>> test(first_example=2, last_example=6) | ex. | waterlevel | requiredremotesupply | ------------------------------------------- | 3 | 1.0 | 1.0 | | 4 | 2.0 | 1.0 | | 5 | 3.0 | 0.0 | | 6 | 4.0 | 0.0 | >>> model.idx_sim = pub.timegrids.init["2001.04.01"] >>> test() | ex. | waterlevel | requiredremotesupply | ------------------------------------------- | 1 | 0.0 | 2.0 | | 2 | 1.0 | 1.999998 | | 3 | 2.0 | 1.999796 | | 4 | 3.0 | 1.98 | | 5 | 4.0 | 1.0 | | 6 | 5.0 | 0.02 | | 7 | 6.0 | 0.000204 | | 8 | 7.0 | 0.000002 | | 9 | 8.0 | 0.0 |
- class hydpy.models.dam.dam_model.Calc_NaturalRemoteDischarge_V1[source]¶
Bases:
Method
Estimate the natural discharge of a cross-section far downstream based on the last few simulation steps.
- Requires the control parameter:
- Requires the log sequences:
- Calculates the flux sequence:
- Basic equation:
\(RemoteDemand = max(\frac{\Sigma(LoggedTotalRemoteDischarge - LoggedOutflow)}{NmbLogEntries}), 0)\)
Examples:
Usually, the mean total remote flow should be larger than the mean dam outflow. Then, the estimated natural remote discharge is simply the difference of both averages:
>>> from hydpy.models.dam import * >>> parameterstep() >>> nmblogentries(3) >>> logs.loggedtotalremotedischarge(2.5, 2.0, 1.5) >>> logs.loggedoutflow(2.0, 1.0, 0.0) >>> model.calc_naturalremotedischarge_v1() >>> fluxes.naturalremotedischarge naturalremotedischarge(1.0)
Due to the wave travel times, the difference between remote discharge and dam outflow might sometimes be negative. To avoid negative estimates of natural discharge,
Calc_NaturalRemoteDischarge_V1
sets its value to zero in such cases:>>> logs.loggedoutflow(4.0, 3.0, 5.0) >>> model.calc_naturalremotedischarge_v1() >>> fluxes.naturalremotedischarge naturalremotedischarge(0.0)
- class hydpy.models.dam.dam_model.Calc_RemoteDemand_V1[source]¶
Bases:
Method
Estimate the discharge demand of a cross-section far downstream.
- Requires the control parameter:
- Requires the derived parameter:
- Requires the flux sequence:
- Calculates the flux sequence:
- Basic equation:
\(RemoteDemand = max(RemoteDischargeMinimum - NaturalRemoteDischarge, 0)\)
Examples:
Low water elevation is often restricted to specific months of the year. Sometimes the pursued lowest discharge value varies over the year to allow for a low flow variability in some agreement with the natural flow regime. The HydPy-Dam model supports such variations. Hence we define a short simulation period first, allowing us to show how we can define the corresponding parameter values and how calculating the remote water demand throughout the year works:
>>> from hydpy import pub >>> pub.timegrids = "2001.03.30", "2001.04.03", "1d"
Prepare the dam model:
>>> from hydpy.models.dam import * >>> parameterstep()
Assume the required discharge at a gauge downstream being 2 m³/s in the hydrological summer half-year (April to October). In the winter month (November to May), there is no such requirement:
>>> remotedischargeminimum(_11_1_12=0.0, _03_31_12=0.0, ... _04_1_12=2.0, _10_31_12=2.0) >>> derived.toy.update()
Prepare a test function, that calculates the remote discharge demand based on the parameter values defined above and for natural remote discharge values ranging between 0 and 3 m³/s:
>>> from hydpy import UnitTest >>> test = UnitTest(model, model.calc_remotedemand_v1, last_example=4, ... parseqs=(fluxes.naturalremotedischarge, ... fluxes.remotedemand)) >>> test.nexts.naturalremotedischarge = range(4)
On April 1, the required discharge is 2 m³/s:
>>> model.idx_sim = pub.timegrids.init["2001.04.01"] >>> test() | ex. | naturalremotedischarge | remotedemand | ----------------------------------------------- | 1 | 0.0 | 2.0 | | 2 | 1.0 | 1.0 | | 3 | 2.0 | 0.0 | | 4 | 3.0 | 0.0 |
On May 31, the required discharge is 0 m³/s:
>>> model.idx_sim = pub.timegrids.init["2001.03.31"] >>> test() | ex. | naturalremotedischarge | remotedemand | ----------------------------------------------- | 1 | 0.0 | 0.0 | | 2 | 1.0 | 0.0 | | 3 | 2.0 | 0.0 | | 4 | 3.0 | 0.0 |
- class hydpy.models.dam.dam_model.Calc_RemoteFailure_V1[source]¶
Bases:
Method
Estimate the shortfall of actual discharge under the required discharge of a cross section far downstream.
- Requires the control parameters:
- Requires the derived parameter:
- Requires the log sequence:
- Calculates the flux sequence:
- Basic equation:
\(RemoteFailure = \frac{\Sigma(LoggedTotalRemoteDischarge)}{NmbLogEntries} - RemoteDischargeMinimum\)
Examples:
As explained in the documentation on method
Calc_RemoteDemand_V1
, we have to define a simulation period first:>>> from hydpy import pub >>> pub.timegrids = "2001.03.30", "2001.04.03", "1d"
Now we prepare a dam model with log sequences memorizing three values:
>>> from hydpy.models.dam import * >>> parameterstep() >>> nmblogentries(3)
Again, the required discharge is 2 m³/s in summer and 0 m³/s in winter:
>>> remotedischargeminimum(_11_1_12=0.0, _03_31_12=0.0, ... _04_1_12=2.0, _10_31_12=2.0) >>> derived.toy.update()
Let it be supposed that the actual discharge at the remote cross section droped from 2 m³/s to 0 m³/s over the last three days:
>>> logs.loggedtotalremotedischarge(0.0, 1.0, 2.0)
This means that for the April 1 there would have been an averaged shortfall of 1 m³/s:
>>> model.idx_sim = pub.timegrids.init["2001.04.01"] >>> model.calc_remotefailure_v1() >>> fluxes.remotefailure remotefailure(1.0)
Instead for May 31 there would have been an excess of 1 m³/s, which is interpreted to be a “negative failure”:
>>> model.idx_sim = pub.timegrids.init["2001.03.31"] >>> model.calc_remotefailure_v1() >>> fluxes.remotefailure remotefailure(-1.0)
- class hydpy.models.dam.dam_model.Calc_RequiredRemoteRelease_V1[source]¶
Bases:
Method
Guess the required release necessary to not fall below the threshold value at a cross section far downstream with a certain level of certainty.
- Requires the control parameter:
- Requires the derived parameters:
- Requires the flux sequences:
- Calculates the flux sequence:
- Used auxiliary method:
smooth_logistic1()
- Basic equation:
\(RequiredRemoteRelease = RemoteDemand + RemoteDischargeSafety \cdot smooth_{logistic1}(RemoteFailure, RemoteDischargeSmoothPar)\)
Examples:
As in the examples above, define a short simulation time period first:
>>> from hydpy import pub >>> pub.timegrids = "2001.03.30", "2001.04.03", "1d"
Prepare the dam model:
>>> from hydpy.models.dam import * >>> parameterstep() >>> derived.toy.update()
Define a safety factor of 0.5 m³/s for the summer months and no safety factor at all for the winter months:
>>> remotedischargesafety(_11_1_12=0.0, _03_31_12=0.0, ... _04_1_12=1.0, _10_31_12=1.0) >>> derived.remotedischargesmoothpar.update()
Assume the actual demand at the cross section downsstream has actually been estimated to be 2 m³/s:
>>> fluxes.remotedemand = 2.0
Prepare a test function, that calculates the required discharge based on the parameter values defined above and for a “remote failure” values ranging between -4 and 4 m³/s:
>>> from hydpy import UnitTest >>> test = UnitTest(model, model.calc_requiredremoterelease_v1, ... last_example=9, ... parseqs=(fluxes.remotefailure, ... fluxes.requiredremoterelease)) >>> test.nexts.remotefailure = range(-4, 5)
On May 31, the safety factor is 0 m³/s. Hence no discharge is added to the estimated remote demand of 2 m³/s:
>>> model.idx_sim = pub.timegrids.init["2001.03.31"] >>> test() | ex. | remotefailure | requiredremoterelease | ----------------------------------------------- | 1 | -4.0 | 2.0 | | 2 | -3.0 | 2.0 | | 3 | -2.0 | 2.0 | | 4 | -1.0 | 2.0 | | 5 | 0.0 | 2.0 | | 6 | 1.0 | 2.0 | | 7 | 2.0 | 2.0 | | 8 | 3.0 | 2.0 | | 9 | 4.0 | 2.0 |
On April 1, the safety factor is 1 m³/s. If the remote failure was exactly zero in the past, meaning the control of the dam was perfect, only 0.5 m³/s are added to the estimated remote demand of 2 m³/s. If the actual recharge did actually fall below the threshold value, up to 1 m³/s is added. If the the actual discharge exceeded the threshold value by 2 or 3 m³/s, virtually nothing is added:
>>> model.idx_sim = pub.timegrids.init["2001.04.01"] >>> test() | ex. | remotefailure | requiredremoterelease | ----------------------------------------------- | 1 | -4.0 | 2.0 | | 2 | -3.0 | 2.000001 | | 3 | -2.0 | 2.000102 | | 4 | -1.0 | 2.01 | | 5 | 0.0 | 2.5 | | 6 | 1.0 | 2.99 | | 7 | 2.0 | 2.999898 | | 8 | 3.0 | 2.999999 | | 9 | 4.0 | 3.0 |
- class hydpy.models.dam.dam_model.Calc_RequiredRemoteRelease_V2[source]¶
Bases:
Method
Get the required remote release of the last simulation step.
- Requires the log sequence:
- Calculates the flux sequence:
- Basic equation:
\(RequiredRemoteRelease = LoggedRequiredRemoteRelease\)
Example:
>>> from hydpy.models.dam import * >>> parameterstep() >>> logs.loggedrequiredremoterelease = 3.0 >>> model.calc_requiredremoterelease_v2() >>> fluxes.requiredremoterelease requiredremoterelease(3.0)
- class hydpy.models.dam.dam_model.Calc_AllowedRemoteRelief_V1[source]¶
Bases:
Method
Get the allowed remote relief of the last simulation step.
- Requires the log sequence:
- Calculates the flux sequence:
- Basic equation:
\(AllowedRemoteRelief = LoggedAllowedRemoteRelief\)
Example:
>>> from hydpy.models.dam import * >>> parameterstep() >>> logs.loggedallowedremoterelief = 2.0 >>> model.calc_allowedremoterelief_v1() >>> fluxes.allowedremoterelief allowedremoterelief(2.0)
- class hydpy.models.dam.dam_model.Calc_RequiredRelease_V1[source]¶
Bases:
Method
Calculate the total water release (immediately and far downstream) required for reducing drought events.
- Requires the control parameter:
- Requires the derived parameters:
- Requires the flux sequence:
- Calculates the flux sequence:
- Used auxiliary method:
smooth_logistic2()
- Basic equation:
\(RequiredRelease = RequiredRemoteRelease \cdot smooth_{logistic2}( RequiredRemoteRelease-NearDischargeMinimumThreshold, NearDischargeMinimumSmoothPar2)\)
Examples:
As in the examples above, define a short simulation time period first:
>>> from hydpy import pub >>> pub.timegrids = "2001.03.30", "2001.04.03", "1d"
Prepare the dam model:
>>> from hydpy.models.dam import * >>> parameterstep() >>> derived.toy.update()
Define a minimum discharge value for a cross section immediately downstream of 4 m³/s for the summer months and of 0 m³/s for the winter months:
>>> neardischargeminimumthreshold(_11_1_12=0.0, _03_31_12=0.0, ... _04_1_12=4.0, _10_31_12=4.0)
Also define related tolerance values that are 1 m³/s in summer and 0 m³/s in winter:
>>> neardischargeminimumtolerance(_11_1_12=0.0, _03_31_12=0.0, ... _04_1_12=1.0, _10_31_12=1.0) >>> derived.neardischargeminimumsmoothpar2.update()
Prepare a test function, that calculates the required total discharge based on the parameter values defined above and for a required value for a cross section far downstream ranging from 0 m³/s to 8 m³/s:
>>> from hydpy import UnitTest >>> test = UnitTest(model, model.calc_requiredrelease_v1, ... last_example=9, ... parseqs=(fluxes.requiredremoterelease, ... fluxes.requiredrelease)) >>> test.nexts.requiredremoterelease = range(9)
On May 31, both the threshold and the tolerance value are 0 m³/s. Hence the required total and the required remote release are equal:
>>> model.idx_sim = pub.timegrids.init["2001.03.31"] >>> test() | ex. | requiredremoterelease | requiredrelease | ------------------------------------------------- | 1 | 0.0 | 0.0 | | 2 | 1.0 | 1.0 | | 3 | 2.0 | 2.0 | | 4 | 3.0 | 3.0 | | 5 | 4.0 | 4.0 | | 6 | 5.0 | 5.0 | | 7 | 6.0 | 6.0 | | 8 | 7.0 | 7.0 | | 9 | 8.0 | 8.0 |
On April 1, the threshold value is 4 m³/s and the tolerance value is 1 m³/s. For low values of the required remote release, the required total release approximates the threshold value. For large values, it approximates the required remote release itself. Around the threshold value, due to the tolerance value of 1 m³/s, the required total release is a little larger than both the treshold value and the required remote release value:
>>> model.idx_sim = pub.timegrids.init["2001.04.01"] >>> test() | ex. | requiredremoterelease | requiredrelease | ------------------------------------------------- | 1 | 0.0 | 4.0 | | 2 | 1.0 | 4.000012 | | 3 | 2.0 | 4.000349 | | 4 | 3.0 | 4.01 | | 5 | 4.0 | 4.205524 | | 6 | 5.0 | 5.01 | | 7 | 6.0 | 6.000349 | | 8 | 7.0 | 7.000012 | | 9 | 8.0 | 8.0 |
- class hydpy.models.dam.dam_model.Calc_RequiredRelease_V2[source]¶
Bases:
Method
Calculate the water release (immediately downstream) required for reducing drought events.
- Requires the control parameter:
- Requires the derived parameter:
- Calculates the flux sequence:
- Basic equation:
\(RequiredRelease = NearDischargeMinimumThreshold\)
Examples:
As in the examples above, define a short simulation time period first:
>>> from hydpy import pub >>> pub.timegrids = "2001.03.30", "2001.04.03", "1d"
Prepare the dam model:
>>> from hydpy.models.dam import * >>> parameterstep() >>> derived.toy.update()
Define a minimum discharge value for a cross section immediately downstream of 4 m³/s for the summer months and of 0 m³/s for the winter months:
>>> neardischargeminimumthreshold(_11_1_12=0.0, _03_31_12=0.0, ... _04_1_12=4.0, _10_31_12=4.0)
As to be expected, the calculated required release is 0.0 m³/s on May 31 and 4.0 m³/s on April 1:
>>> model.idx_sim = pub.timegrids.init["2001.03.31"] >>> model.calc_requiredrelease_v2() >>> fluxes.requiredrelease requiredrelease(0.0) >>> model.idx_sim = pub.timegrids.init["2001.04.01"] >>> model.calc_requiredrelease_v2() >>> fluxes.requiredrelease requiredrelease(4.0)
- class hydpy.models.dam.dam_model.Calc_PossibleRemoteRelief_V1[source]¶
Bases:
Method
Calculate the highest possible water release that can be routed to a remote location based on an interpolation approach approximating the relationship between possible release and water stage.
- Requires the control parameter:
- Requires the factor sequence:
- Calculates the flux sequence:
Example:
For simplicity, the example of method
Calc_FloodDischarge_V1
is reused. See the documentation on the mentioned method for further information:>>> from hydpy.models.dam import * >>> parameterstep() >>> waterlevel2possibleremoterelief( ... ANN(nmb_inputs=1, ... nmb_neurons=(2,), ... nmb_outputs=1, ... weights_input=[[50.0, 4]], ... weights_output=[[2.0], [30]], ... intercepts_hidden=[[-13000, -1046]], ... intercepts_output=[0.0])) >>> from hydpy import UnitTest >>> test = UnitTest( ... model, model.calc_possibleremoterelief_v1, ... last_example=21, ... parseqs=(factors.waterlevel, fluxes.possibleremoterelief)) >>> test.nexts.waterlevel = numpy.arange(257, 261.1, 0.2) >>> test() | ex. | waterlevel | possibleremoterelief | ------------------------------------------- | 1 | 257.0 | 0.0 | | 2 | 257.2 | 0.000001 | | 3 | 257.4 | 0.000002 | | 4 | 257.6 | 0.000005 | | 5 | 257.8 | 0.000011 | | 6 | 258.0 | 0.000025 | | 7 | 258.2 | 0.000056 | | 8 | 258.4 | 0.000124 | | 9 | 258.6 | 0.000275 | | 10 | 258.8 | 0.000612 | | 11 | 259.0 | 0.001362 | | 12 | 259.2 | 0.003031 | | 13 | 259.4 | 0.006745 | | 14 | 259.6 | 0.015006 | | 15 | 259.8 | 0.033467 | | 16 | 260.0 | 1.074179 | | 17 | 260.2 | 2.164498 | | 18 | 260.4 | 2.363853 | | 19 | 260.6 | 2.79791 | | 20 | 260.8 | 3.719725 | | 21 | 261.0 | 5.576088 |
- class hydpy.models.dam.dam_model.Fix_Min1_V1[source]¶
Bases:
Method
Apply function
smooth_min1()
without risking negative results.- Used auxiliary methods:
smooth_min1()
smooth_max1()
When applying function
smooth_min1()
straight-forward (\(result = smooth_min1(input, threshold, smoothpar\)), it likely results in slightly negative result values for a positive threshold value and an input value of zero. Some methods of thedam
models rely onsmooth_min1()
but should never return negative values. Therefore, methodsFix_Min1_V1
modifiessmooth_min1()
for such cases.Method both supports “absolute” (where the smoothing parameter value is taken as is) and “relative” smoothers (where the actual smoothing parameter value depends on the current threshold value). Please see the detailed documentation on methods
Calc_ActualRemoteRelief_V1
(implementing a “relative” smoother approach), which explains the strategy behind methodFix_Min1_V1
in depths. The documentation on methodUpdate_ActualRemoteRelief_V1
provides test calculation results for the “aboslute” smoother approach.
- class hydpy.models.dam.dam_model.Calc_ActualRemoteRelief_V1[source]¶
Bases:
Method
Calculate the actual amount of water released to a remote location to relieve the dam during high flow conditions.
- Requires the control parameter:
- Requires the flux sequences:
- Calculates the flux sequence:
- Basic equation - discontinous:
\(ActualRemoteRelease = min(PossibleRemoteRelease, AllowedRemoteRelease)\)
- Used additional method:
- Basic equation - continous:
\(ActualRemoteRelease = smooth_min1(PossibleRemoteRelease, AllowedRemoteRelease, RemoteReliefTolerance)\)
Note that the given continous basic equation is a simplification of the complete algorithm to calculate
ActualRemoteRelief
, which also makes use ofsmooth_max1()
to prevent from gaining negative values in a smooth manner.Examples:
Prepare a dam model:
>>> from hydpy.models.dam import * >>> parameterstep()
Prepare a test function object that performs seven examples with
PossibleRemoteRelief
ranging from -1 to 5 m³/s:>>> from hydpy import UnitTest >>> test = UnitTest(model, model.calc_actualremoterelief_v1, ... last_example=7, ... parseqs=(fluxes.possibleremoterelief, ... fluxes.actualremoterelief)) >>> test.nexts.possibleremoterelief = range(-1, 6)
We begin with a
AllowedRemoteRelief
value of 3 m³/s:>>> fluxes.allowedremoterelief = 3.0
Through setting the value of
RemoteReliefTolerance
to the lowest possible value, there is no smoothing. Instead, the relationship betweenActualRemoteRelief
andPossibleRemoteRelief
follows the simple discontinous minimum function:>>> remoterelieftolerance(0.0) >>> test() | ex. | possibleremoterelief | actualremoterelief | --------------------------------------------------- | 1 | -1.0 | 0.0 | | 2 | 0.0 | 0.0 | | 3 | 1.0 | 1.0 | | 4 | 2.0 | 2.0 | | 5 | 3.0 | 3.0 | | 6 | 4.0 | 3.0 | | 7 | 5.0 | 3.0 |
Increasing the value of parameter
RemoteReliefTolerance
to a sensible value results in a moderate smoothing:>>> remoterelieftolerance(0.2) >>> test() | ex. | possibleremoterelief | actualremoterelief | --------------------------------------------------- | 1 | -1.0 | 0.0 | | 2 | 0.0 | 0.0 | | 3 | 1.0 | 0.970639 | | 4 | 2.0 | 1.89588 | | 5 | 3.0 | 2.584112 | | 6 | 4.0 | 2.896195 | | 7 | 5.0 | 2.978969 |
Even when setting a very large smoothing parameter value, the actual remote relief does not fall below 0 m³/s:
>>> remoterelieftolerance(1.0) >>> test() | ex. | possibleremoterelief | actualremoterelief | --------------------------------------------------- | 1 | -1.0 | 0.0 | | 2 | 0.0 | 0.0 | | 3 | 1.0 | 0.306192 | | 4 | 2.0 | 0.634882 | | 5 | 3.0 | 1.037708 | | 6 | 4.0 | 1.436494 | | 7 | 5.0 | 1.788158 |
Now we repeat the last example with an allowed remote relief of only 0.03 m³/s instead of 3 m³/s:
>>> fluxes.allowedremoterelief = 0.03 >>> test() | ex. | possibleremoterelief | actualremoterelief | --------------------------------------------------- | 1 | -1.0 | 0.0 | | 2 | 0.0 | 0.0 | | 3 | 1.0 | 0.03 | | 4 | 2.0 | 0.03 | | 5 | 3.0 | 0.03 | | 6 | 4.0 | 0.03 | | 7 | 5.0 | 0.03 |
The result above is as expected, but the smooth part of the relationship is not resolved. By increasing the resolution we see a relationship that corresponds to the one shown above for an allowed relief of 3 m³/s. This points out, that the degree of smoothing is releative to the allowed relief:
>>> import numpy >>> test.nexts.possibleremoterelief = numpy.arange(-0.01, 0.06, 0.01) >>> test() | ex. | possibleremoterelief | actualremoterelief | --------------------------------------------------- | 1 | -0.01 | 0.0 | | 2 | 0.0 | 0.0 | | 3 | 0.01 | 0.003062 | | 4 | 0.02 | 0.006349 | | 5 | 0.03 | 0.010377 | | 6 | 0.04 | 0.014365 | | 7 | 0.05 | 0.017882 |
One can reperform the shown experiments with an even higher resolution to see that the relationship between
ActualRemoteRelief
andPossibleRemoteRelief
is (at least in most cases) in fact very smooth. But a more analytical approach would possibly be favourable regarding the smoothness in some edge cases and computational efficiency.
- class hydpy.models.dam.dam_model.Calc_TargetedRelease_V1[source]¶
Bases:
Method
Calculate the targeted water release for reducing drought events, taking into account both the required water release and the actual inflow into the dam.
- Requires the control parameters:
- Requires the derived parameters:
- Requires the flux sequences:
- Calculates the flux sequence:
Some dams are supposed to maintain a certain degree of low flow variability downstream. In case parameter
RestrictTargetedRelease
is set to True, methodCalc_TargetedRelease_V1
simulates this by (approximately) passing inflow as outflow whenever inflow is below the value of the threshold parameterNearDischargeMinimumThreshold
. If parameterRestrictTargetedRelease
is set to False, does nothing except assigning the value of sequenceRequiredRelease
to sequenceTargetedRelease
.- Used auxiliary method:
smooth_logistic1()
- Basic equation:
\(TargetedRelease = w \cdot RequiredRelease + (1-w) \cdot Inflow\)
\(w = smooth_{logistic1}( Inflow-NearDischargeMinimumThreshold, NearDischargeMinimumSmoothPar1)\)
Examples:
As in the examples above, define a short simulation time period first:
>>> from hydpy import pub >>> pub.timegrids = "2001.03.30", "2001.04.03", "1d"
Prepare the dam model:
>>> from hydpy.models.dam import * >>> parameterstep() >>> derived.toy.update()
We start with enabling
RestrictTargetedRelease
:>>> restricttargetedrelease(True)
Define a minimum discharge value for a cross section immediately downstream of 6 m³/s for the summer months and of 4 m³/s for the winter months:
>>> neardischargeminimumthreshold(_11_1_12=6.0, _03_31_12=6.0, ... _04_1_12=4.0, _10_31_12=4.0)
Also define related tolerance values that are 1 m³/s in summer and 0 m³/s in winter:
>>> neardischargeminimumtolerance(_11_1_12=0.0, _03_31_12=0.0, ... _04_1_12=2.0, _10_31_12=2.0) >>> derived.neardischargeminimumsmoothpar1.update()
Prepare a test function that calculates the targeted water release based on the parameter values defined above and for inflows into the dam ranging from 0 m³/s to 10 m³/s:
>>> from hydpy import UnitTest >>> test = UnitTest(model, model.calc_targetedrelease_v1, ... last_example=21, ... parseqs=(fluxes.inflow, ... fluxes.targetedrelease)) >>> test.nexts.inflow = numpy.arange(0.0, 10.5, .5)
Firstly, assume the required release of water for reducing droughts has already been determined to be 10 m³/s:
>>> fluxes.requiredrelease = 10.
On May 31, the tolerance value is 0 m³/s. Hence the targeted release jumps from the inflow value to the required release when exceeding the threshold value of 6 m³/s:
>>> model.idx_sim = pub.timegrids.init["2001.03.31"] >>> test() | ex. | inflow | targetedrelease | ---------------------------------- | 1 | 0.0 | 0.0 | | 2 | 0.5 | 0.5 | | 3 | 1.0 | 1.0 | | 4 | 1.5 | 1.5 | | 5 | 2.0 | 2.0 | | 6 | 2.5 | 2.5 | | 7 | 3.0 | 3.0 | | 8 | 3.5 | 3.5 | | 9 | 4.0 | 4.0 | | 10 | 4.5 | 4.5 | | 11 | 5.0 | 5.0 | | 12 | 5.5 | 5.5 | | 13 | 6.0 | 8.0 | | 14 | 6.5 | 10.0 | | 15 | 7.0 | 10.0 | | 16 | 7.5 | 10.0 | | 17 | 8.0 | 10.0 | | 18 | 8.5 | 10.0 | | 19 | 9.0 | 10.0 | | 20 | 9.5 | 10.0 | | 21 | 10.0 | 10.0 |
On April 1, the threshold value is 4 m³/s and the tolerance value is 2 m³/s. Hence there is a smooth transition for inflows ranging between 2 m³/s and 6 m³/s:
>>> model.idx_sim = pub.timegrids.init["2001.04.01"] >>> test() | ex. | inflow | targetedrelease | ---------------------------------- | 1 | 0.0 | 0.00102 | | 2 | 0.5 | 0.503056 | | 3 | 1.0 | 1.009127 | | 4 | 1.5 | 1.527132 | | 5 | 2.0 | 2.08 | | 6 | 2.5 | 2.731586 | | 7 | 3.0 | 3.639277 | | 8 | 3.5 | 5.064628 | | 9 | 4.0 | 7.0 | | 10 | 4.5 | 8.676084 | | 11 | 5.0 | 9.543374 | | 12 | 5.5 | 9.861048 | | 13 | 6.0 | 9.96 | | 14 | 6.5 | 9.988828 | | 15 | 7.0 | 9.996958 | | 16 | 7.5 | 9.999196 | | 17 | 8.0 | 9.999796 | | 18 | 8.5 | 9.999951 | | 19 | 9.0 | 9.99999 | | 20 | 9.5 | 9.999998 | | 21 | 10.0 | 10.0 |
An required release substantially below the threshold value is a rather unlikely scenario, but is at least instructive regarding the functioning of the method (when plotting the results graphically…):
>>> fluxes.requiredrelease = 2.
On May 31, the relationship between targeted release and inflow is again highly discontinous:
>>> model.idx_sim = pub.timegrids.init["2001.03.31"] >>> test() | ex. | inflow | targetedrelease | ---------------------------------- | 1 | 0.0 | 0.0 | | 2 | 0.5 | 0.5 | | 3 | 1.0 | 1.0 | | 4 | 1.5 | 1.5 | | 5 | 2.0 | 2.0 | | 6 | 2.5 | 2.5 | | 7 | 3.0 | 3.0 | | 8 | 3.5 | 3.5 | | 9 | 4.0 | 4.0 | | 10 | 4.5 | 4.5 | | 11 | 5.0 | 5.0 | | 12 | 5.5 | 5.5 | | 13 | 6.0 | 4.0 | | 14 | 6.5 | 2.0 | | 15 | 7.0 | 2.0 | | 16 | 7.5 | 2.0 | | 17 | 8.0 | 2.0 | | 18 | 8.5 | 2.0 | | 19 | 9.0 | 2.0 | | 20 | 9.5 | 2.0 | | 21 | 10.0 | 2.0 |
And on April 1, it is again absolutely smooth:
>>> model.idx_sim = pub.timegrids.init["2001.04.01"] >>> test() | ex. | inflow | targetedrelease | ---------------------------------- | 1 | 0.0 | 0.000204 | | 2 | 0.5 | 0.500483 | | 3 | 1.0 | 1.001014 | | 4 | 1.5 | 1.501596 | | 5 | 2.0 | 2.0 | | 6 | 2.5 | 2.484561 | | 7 | 3.0 | 2.908675 | | 8 | 3.5 | 3.138932 | | 9 | 4.0 | 3.0 | | 10 | 4.5 | 2.60178 | | 11 | 5.0 | 2.273976 | | 12 | 5.5 | 2.108074 | | 13 | 6.0 | 2.04 | | 14 | 6.5 | 2.014364 | | 15 | 7.0 | 2.005071 | | 16 | 7.5 | 2.00177 | | 17 | 8.0 | 2.000612 | | 18 | 8.5 | 2.00021 | | 19 | 9.0 | 2.000072 | | 20 | 9.5 | 2.000024 | | 21 | 10.0 | 2.000008 |
For required releases equal with the threshold value, there is generally no jump in the relationship. But on May 31, there remains a discontinuity in the first derivative:
>>> fluxes.requiredrelease = 6. >>> model.idx_sim = pub.timegrids.init["2001.03.31"] >>> test() | ex. | inflow | targetedrelease | ---------------------------------- | 1 | 0.0 | 0.0 | | 2 | 0.5 | 0.5 | | 3 | 1.0 | 1.0 | | 4 | 1.5 | 1.5 | | 5 | 2.0 | 2.0 | | 6 | 2.5 | 2.5 | | 7 | 3.0 | 3.0 | | 8 | 3.5 | 3.5 | | 9 | 4.0 | 4.0 | | 10 | 4.5 | 4.5 | | 11 | 5.0 | 5.0 | | 12 | 5.5 | 5.5 | | 13 | 6.0 | 6.0 | | 14 | 6.5 | 6.0 | | 15 | 7.0 | 6.0 | | 16 | 7.5 | 6.0 | | 17 | 8.0 | 6.0 | | 18 | 8.5 | 6.0 | | 19 | 9.0 | 6.0 | | 20 | 9.5 | 6.0 | | 21 | 10.0 | 6.0 |
On April 1, this second order discontinuity is smoothed with the help of a little hump around the threshold:
>>> fluxes.requiredrelease = 4. >>> model.idx_sim = pub.timegrids.init["2001.04.01"] >>> test() | ex. | inflow | targetedrelease | ---------------------------------- | 1 | 0.0 | 0.000408 | | 2 | 0.5 | 0.501126 | | 3 | 1.0 | 1.003042 | | 4 | 1.5 | 1.50798 | | 5 | 2.0 | 2.02 | | 6 | 2.5 | 2.546317 | | 7 | 3.0 | 3.091325 | | 8 | 3.5 | 3.620356 | | 9 | 4.0 | 4.0 | | 10 | 4.5 | 4.120356 | | 11 | 5.0 | 4.091325 | | 12 | 5.5 | 4.046317 | | 13 | 6.0 | 4.02 | | 14 | 6.5 | 4.00798 | | 15 | 7.0 | 4.003042 | | 16 | 7.5 | 4.001126 | | 17 | 8.0 | 4.000408 | | 18 | 8.5 | 4.000146 | | 19 | 9.0 | 4.000051 | | 20 | 9.5 | 4.000018 | | 21 | 10.0 | 4.000006 |
Repeating the above example with the
RestrictTargetedRelease
flag disabled results in identical values for sequencesRequiredRelease
andTargetedRelease
:>>> restricttargetedrelease(False) >>> test() | ex. | inflow | targetedrelease | ---------------------------------- | 1 | 0.0 | 4.0 | | 2 | 0.5 | 4.0 | | 3 | 1.0 | 4.0 | | 4 | 1.5 | 4.0 | | 5 | 2.0 | 4.0 | | 6 | 2.5 | 4.0 | | 7 | 3.0 | 4.0 | | 8 | 3.5 | 4.0 | | 9 | 4.0 | 4.0 | | 10 | 4.5 | 4.0 | | 11 | 5.0 | 4.0 | | 12 | 5.5 | 4.0 | | 13 | 6.0 | 4.0 | | 14 | 6.5 | 4.0 | | 15 | 7.0 | 4.0 | | 16 | 7.5 | 4.0 | | 17 | 8.0 | 4.0 | | 18 | 8.5 | 4.0 | | 19 | 9.0 | 4.0 | | 20 | 9.5 | 4.0 | | 21 | 10.0 | 4.0 |
- class hydpy.models.dam.dam_model.Calc_ActualRelease_V1[source]¶
Bases:
Method
Calculate the actual water release that can be supplied by the dam considering the targeted release and the given water level.
- Requires the control parameter:
- Requires the derived parameter:
- Requires the factor sequence:
- Requires the flux sequence:
- Calculates the flux sequence:
- Used auxiliary method:
smooth_logistic1()
- Basic equation:
\(ActualRelease = TargetedRelease \cdot smooth_{logistic1}(WaterLevelMinimumThreshold - WaterLevel, WaterLevelMinimumSmoothPar)\)
Examples:
Prepare the dam model:
>>> from hydpy.models.dam import * >>> parameterstep()
Assume the required release has previously been estimated to be 2 m³/s:
>>> fluxes.targetedrelease = 2.0
Prepare a test function, that calculates the targeted water release for water levels ranging between -1 and 5 m:
>>> from hydpy import UnitTest >>> test = UnitTest(model, model.calc_actualrelease_v1, ... last_example=7, ... parseqs=(factors.waterlevel, ... fluxes.actualrelease)) >>> test.nexts.waterlevel = range(-1, 6)
Example 1
Firstly, we define a sharp minimum water level tolerance of 0 m:
>>> waterlevelminimumthreshold(0.0) >>> waterlevelminimumtolerance(0.0) >>> derived.waterlevelminimumsmoothpar.update()
The following test results show that the water release is reduced to 0 m³/s for water levels (even slightly) lower than 0 m and is identical with the required value of 2 m³/s (even slighlty) above 0 m:
>>> test() | ex. | waterlevel | actualrelease | ------------------------------------ | 1 | -1.0 | 0.0 | | 2 | 0.0 | 1.0 | | 3 | 1.0 | 2.0 | | 4 | 2.0 | 2.0 | | 5 | 3.0 | 2.0 | | 6 | 4.0 | 2.0 | | 7 | 5.0 | 2.0 |
One may have noted that in the above example the calculated water release is 1 m³/s (which is exactly the half of the targeted release) at a water level of 1 m. This looks suspiciously lake a flaw but is not of any importance considering the fact, that numerical integration algorithms will approximate the analytical solution of a complete emptying of a dam emtying (which is a water level of 0 m), only with a certain accuracy.
Example 2
Nonetheless, it can (besides some other possible advantages) dramatically increase the speed of numerical integration algorithms to define a smooth transition area instead of sharp threshold value, like in the following example:
>>> waterlevelminimumthreshold(4.0) >>> waterlevelminimumtolerance(1.0) >>> derived.waterlevelminimumsmoothpar.update()
Now, 98 % of the variation of the total range from 0 m³/s to 2 m³/s occurs between a water level of 3 m and 5 m:
>>> test() | ex. | waterlevel | actualrelease | ------------------------------------ | 1 | -1.0 | 0.0 | | 2 | 0.0 | 0.0 | | 3 | 1.0 | 0.000002 | | 4 | 2.0 | 0.000204 | | 5 | 3.0 | 0.02 | | 6 | 4.0 | 1.0 | | 7 | 5.0 | 1.98 |
Example 3
Note that it is possible to set both parameters in a manner that might result in negative water stages beyond numerical inaccuracy:
>>> waterlevelminimumthreshold(1.0) >>> waterlevelminimumtolerance(2.0) >>> derived.waterlevelminimumsmoothpar.update()
Here, the actual water release is 0.18 m³/s for a water level of 0 m. Hence water stages in the range of 0 m to -1 m or even -2 m might occur during the simulation of long drought events:
>>> test() | ex. | waterlevel | actualrelease | ------------------------------------ | 1 | -1.0 | 0.02 | | 2 | 0.0 | 0.18265 | | 3 | 1.0 | 1.0 | | 4 | 2.0 | 1.81735 | | 5 | 3.0 | 1.98 | | 6 | 4.0 | 1.997972 | | 7 | 5.0 | 1.999796 |
- class hydpy.models.dam.dam_model.Calc_ActualRelease_V2[source]¶
Bases:
Method
Calculate the actual water release in aggrement with the allowed release not causing harm downstream and the actual water volume.
- Requires the control parameters:
- Requires the derived parameters:
- Requires the factor sequence:
- Calculates the flux sequence:
- Used auxiliary method:
smooth_logistic1()
- Basic equation:
\(ActualRelease = AllowedRelease \cdot smooth_{logistic1}(WaterLevel, WaterLevelMinimumSmoothPar)\)
Examples:
We assume a short simulation period spanning the last and first two days of March and April, respectively:
>>> from hydpy import pub >>> pub.timegrids = "2001-03-30", "2001-04-03", "1d"
We prepare the dam model and set the allowed release to 2 m³/s and to 4 m³/s for March and February, respectively, and set the water level threshold to 0.5 m:
>>> from hydpy.models.dam import * >>> parameterstep() >>> allowedrelease(_11_1_12=2.0, _03_31_12=2.0, ... _04_1_12=4.0, _10_31_12=4.0) >>> waterlevelminimumthreshold(0.5) >>> derived.toy.update()
Next, wrepare a test function, that calculates the actual water release for water levels ranging between 0.1 and 0.9 m:
>>> from hydpy import UnitTest >>> test = UnitTest(model, model.calc_actualrelease_v2, ... last_example=9, ... parseqs=(factors.waterlevel, ... fluxes.actualrelease)) >>> test.nexts.waterlevel = 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9
First, we define a sharp minimum water level tolerance of 0 m, resulting in a sharp transition from 0 to 2 m³/s around the a water level threshold of 0.5 m, shown for the 31st March:
>>> model.idx_sim = pub.timegrids.init["2001-03-31"] >>> waterlevelminimumtolerance(0.0) >>> derived.waterlevelminimumsmoothpar.update() >>> test() | ex. | waterlevel | actualrelease | ------------------------------------ | 1 | 0.1 | 0.0 | | 2 | 0.2 | 0.0 | | 3 | 0.3 | 0.0 | | 4 | 0.4 | 0.0 | | 5 | 0.5 | 1.0 | | 6 | 0.6 | 2.0 | | 7 | 0.7 | 2.0 | | 8 | 0.8 | 2.0 | | 9 | 0.9 | 2.0 |
Second, we define a numerically more sensible tolerance value of 0.1 m, causing 98 % of the variation of the actual release to occur between water levels of 0.4 m and 0.6 m, shown for the 1th April:
>>> model.idx_sim = pub.timegrids.init["2001-04-01"] >>> waterlevelminimumtolerance(0.1) >>> derived.waterlevelminimumsmoothpar.update() >>> test() | ex. | waterlevel | actualrelease | ------------------------------------ | 1 | 0.1 | 0.0 | | 2 | 0.2 | 0.000004 | | 3 | 0.3 | 0.000408 | | 4 | 0.4 | 0.04 | | 5 | 0.5 | 2.0 | | 6 | 0.6 | 3.96 | | 7 | 0.7 | 3.999592 | | 8 | 0.8 | 3.999996 | | 9 | 0.9 | 4.0 |
- class hydpy.models.dam.dam_model.Calc_ActualRelease_V3[source]¶
Bases:
Method
Calculate an actual water release that tries to change the water storage into the direction of the actual target volume without violating the required minimum and the allowed maximum flow.
- Requires the control parameters:
TargetVolume
TargetRangeAbsolute
TargetRangeRelative
NearDischargeMinimumThreshold
WaterVolumeMinimumThreshold
- Requires the derived parameters:
TOY
VolumeSmoothParLog1
VolumeSmoothParLog2
DischargeSmoothPar
- Requires the flux sequence:
- Requires the state sequence:
- Requires the aide sequence:
- Calculates the flux sequence:
- Used auxiliary methods:
smooth_logistic1()
smooth_logistic2()
smooth_min1()
smooth_max1()
Examples:
Method
Calc_ActualRelease_V3
is quite complex. As it is the key component of application modeldam_v008
, we advise to read its documentation including some introductory examples first, and to inspect the following detailled examples afterwards, which hopefully cover all of the mentioned corner cases.>>> from hydpy import pub >>> pub.timegrids = "2001-03-30", "2001-04-03", "1d"
>>> from hydpy.models.dam import * >>> parameterstep() >>> targetvolume(_11_1_12=5.0, _03_31_12=5.0, ... _04_1_12=0.0, _10_31_12=0.0) >>> neardischargeminimumthreshold(_11_1_12=3.0, _03_31_12=3.0, ... _04_1_12=0.0, _10_31_12=0.0) >>> watervolumeminimumthreshold(0.0) >>> derived.toy.update()
>>> from hydpy import UnitTest >>> test = UnitTest(model, model.calc_actualrelease_v3, ... last_example=31, ... parseqs=(states.watervolume, ... fluxes.actualrelease)) >>> import numpy >>> test.nexts.watervolume = numpy.arange(3.5, 6.6, 0.1)
>>> model.idx_sim = pub.timegrids.init["2001-03-31"] >>> aides.alloweddischarge = 6.0
>>> def set_tolerances(value): ... volumetolerance(value) ... dischargetolerance(value) ... derived.volumesmoothparlog1.update() ... derived.volumesmoothparlog2.update() ... derived.dischargesmoothpar.update()
>>> def apply_targetrange(flag): ... if flag: ... targetrangeabsolute(0.1) ... targetrangerelative(0.2) ... else: ... targetrangeabsolute(0.0) ... targetrangerelative(0.0)
Standard case, without smoothing, without interpolation:
>>> fluxes.inflow = 4.0 >>> set_tolerances(0.0) >>> apply_targetrange(False) >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | 3.5 | 3.0 | | 2 | 3.6 | 3.0 | | 3 | 3.7 | 3.0 | | 4 | 3.8 | 3.0 | | 5 | 3.9 | 3.0 | | 6 | 4.0 | 3.0 | | 7 | 4.1 | 3.0 | | 8 | 4.2 | 3.0 | | 9 | 4.3 | 3.0 | | 10 | 4.4 | 3.0 | | 11 | 4.5 | 3.0 | | 12 | 4.6 | 3.0 | | 13 | 4.7 | 3.0 | | 14 | 4.8 | 3.0 | | 15 | 4.9 | 3.0 | | 16 | 5.0 | 4.0 | | 17 | 5.1 | 6.0 | | 18 | 5.2 | 6.0 | | 19 | 5.3 | 6.0 | | 20 | 5.4 | 6.0 | | 21 | 5.5 | 6.0 | | 22 | 5.6 | 6.0 | | 23 | 5.7 | 6.0 | | 24 | 5.8 | 6.0 | | 25 | 5.9 | 6.0 | | 26 | 6.0 | 6.0 | | 27 | 6.1 | 6.0 | | 28 | 6.2 | 6.0 | | 29 | 6.3 | 6.0 | | 30 | 6.4 | 6.0 | | 31 | 6.5 | 6.0 |
Standard case, without smoothing, with interpolation:
>>> fluxes.inflow = 4.0 >>> set_tolerances(0.0) >>> apply_targetrange(True) >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | 3.5 | 3.0 | | 2 | 3.6 | 3.0 | | 3 | 3.7 | 3.0 | | 4 | 3.8 | 3.0 | | 5 | 3.9 | 3.0 | | 6 | 4.0 | 3.0 | | 7 | 4.1 | 3.1 | | 8 | 4.2 | 3.2 | | 9 | 4.3 | 3.3 | | 10 | 4.4 | 3.4 | | 11 | 4.5 | 3.5 | | 12 | 4.6 | 3.6 | | 13 | 4.7 | 3.7 | | 14 | 4.8 | 3.8 | | 15 | 4.9 | 3.9 | | 16 | 5.0 | 4.0 | | 17 | 5.1 | 4.2 | | 18 | 5.2 | 4.4 | | 19 | 5.3 | 4.6 | | 20 | 5.4 | 4.8 | | 21 | 5.5 | 5.0 | | 22 | 5.6 | 5.2 | | 23 | 5.7 | 5.4 | | 24 | 5.8 | 5.6 | | 25 | 5.9 | 5.8 | | 26 | 6.0 | 6.0 | | 27 | 6.1 | 6.0 | | 28 | 6.2 | 6.0 | | 29 | 6.3 | 6.0 | | 30 | 6.4 | 6.0 | | 31 | 6.5 | 6.0 |
Standard case, moderate smoothing, without interpolation:
>>> fluxes.inflow = 4.0 >>> set_tolerances(0.1) >>> apply_targetrange(False) >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | 3.5 | 3.0 | | 2 | 3.6 | 3.0 | | 3 | 3.7 | 3.0 | | 4 | 3.8 | 3.0 | | 5 | 3.9 | 3.0 | | 6 | 4.0 | 3.0 | | 7 | 4.1 | 3.0 | | 8 | 4.2 | 3.0 | | 9 | 4.3 | 3.0 | | 10 | 4.4 | 3.0 | | 11 | 4.5 | 3.0 | | 12 | 4.6 | 3.0 | | 13 | 4.7 | 3.000001 | | 14 | 4.8 | 3.000102 | | 15 | 4.9 | 3.01 | | 16 | 5.0 | 4.0 | | 17 | 5.1 | 5.98 | | 18 | 5.2 | 5.999796 | | 19 | 5.3 | 5.999998 | | 20 | 5.4 | 6.0 | | 21 | 5.5 | 6.0 | | 22 | 5.6 | 6.0 | | 23 | 5.7 | 6.0 | | 24 | 5.8 | 6.0 | | 25 | 5.9 | 6.0 | | 26 | 6.0 | 6.0 | | 27 | 6.1 | 6.0 | | 28 | 6.2 | 6.0 | | 29 | 6.3 | 6.0 | | 30 | 6.4 | 6.0 | | 31 | 6.5 | 6.0 |
Standard case, moderate smoothing, with interpolation:
>>> fluxes.inflow = 4.0 >>> set_tolerances(0.1) >>> apply_targetrange(True) >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | 3.5 | 3.000013 | | 2 | 3.6 | 3.000068 | | 3 | 3.7 | 3.000369 | | 4 | 3.8 | 3.001974 | | 5 | 3.9 | 3.01 | | 6 | 4.0 | 3.040983 | | 7 | 4.1 | 3.11 | | 8 | 4.2 | 3.201974 | | 9 | 4.3 | 3.300369 | | 10 | 4.4 | 3.400067 | | 11 | 4.5 | 3.5 | | 12 | 4.6 | 3.599933 | | 13 | 4.7 | 3.699632 | | 14 | 4.8 | 3.798047 | | 15 | 4.9 | 3.8913 | | 16 | 5.0 | 4.0 | | 17 | 5.1 | 4.2177 | | 18 | 5.2 | 4.403907 | | 19 | 5.3 | 4.600737 | | 20 | 5.4 | 4.800134 | | 21 | 5.5 | 5.0 | | 22 | 5.6 | 5.199866 | | 23 | 5.7 | 5.399263 | | 24 | 5.8 | 5.596051 | | 25 | 5.9 | 5.78 | | 26 | 6.0 | 5.918035 | | 27 | 6.1 | 5.98 | | 28 | 6.2 | 5.996051 | | 29 | 6.3 | 5.999262 | | 30 | 6.4 | 5.999864 | | 31 | 6.5 | 5.999975 |
Inflow smaller than minimum release, without smoothing, without interpolation:
>>> fluxes.inflow = 2.0 >>> set_tolerances(0.0) >>> apply_targetrange(False) >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | 3.5 | 3.0 | | 2 | 3.6 | 3.0 | | 3 | 3.7 | 3.0 | | 4 | 3.8 | 3.0 | | 5 | 3.9 | 3.0 | | 6 | 4.0 | 3.0 | | 7 | 4.1 | 3.0 | | 8 | 4.2 | 3.0 | | 9 | 4.3 | 3.0 | | 10 | 4.4 | 3.0 | | 11 | 4.5 | 3.0 | | 12 | 4.6 | 3.0 | | 13 | 4.7 | 3.0 | | 14 | 4.8 | 3.0 | | 15 | 4.9 | 3.0 | | 16 | 5.0 | 3.0 | | 17 | 5.1 | 6.0 | | 18 | 5.2 | 6.0 | | 19 | 5.3 | 6.0 | | 20 | 5.4 | 6.0 | | 21 | 5.5 | 6.0 | | 22 | 5.6 | 6.0 | | 23 | 5.7 | 6.0 | | 24 | 5.8 | 6.0 | | 25 | 5.9 | 6.0 | | 26 | 6.0 | 6.0 | | 27 | 6.1 | 6.0 | | 28 | 6.2 | 6.0 | | 29 | 6.3 | 6.0 | | 30 | 6.4 | 6.0 | | 31 | 6.5 | 6.0 |
Inflow smaller than minimum release, without smoothing, with interpolation:
>>> fluxes.inflow = 2.0 >>> set_tolerances(0.0) >>> apply_targetrange(True) >>> fluxes.inflow = 2.0 >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | 3.5 | 3.0 | | 2 | 3.6 | 3.0 | | 3 | 3.7 | 3.0 | | 4 | 3.8 | 3.0 | | 5 | 3.9 | 3.0 | | 6 | 4.0 | 3.0 | | 7 | 4.1 | 3.0 | | 8 | 4.2 | 3.0 | | 9 | 4.3 | 3.0 | | 10 | 4.4 | 3.0 | | 11 | 4.5 | 3.0 | | 12 | 4.6 | 3.0 | | 13 | 4.7 | 3.0 | | 14 | 4.8 | 3.0 | | 15 | 4.9 | 3.0 | | 16 | 5.0 | 3.0 | | 17 | 5.1 | 3.3 | | 18 | 5.2 | 3.6 | | 19 | 5.3 | 3.9 | | 20 | 5.4 | 4.2 | | 21 | 5.5 | 4.5 | | 22 | 5.6 | 4.8 | | 23 | 5.7 | 5.1 | | 24 | 5.8 | 5.4 | | 25 | 5.9 | 5.7 | | 26 | 6.0 | 6.0 | | 27 | 6.1 | 6.0 | | 28 | 6.2 | 6.0 | | 29 | 6.3 | 6.0 | | 30 | 6.4 | 6.0 | | 31 | 6.5 | 6.0 |
Inflow smaller than minimum release, moderate smoothing, without interpolation:
>>> fluxes.inflow = 2.0 >>> set_tolerances(0.1) >>> apply_targetrange(False) >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | 3.5 | 3.0 | | 2 | 3.6 | 3.0 | | 3 | 3.7 | 3.0 | | 4 | 3.8 | 3.0 | | 5 | 3.9 | 3.0 | | 6 | 4.0 | 3.0 | | 7 | 4.1 | 3.0 | | 8 | 4.2 | 3.0 | | 9 | 4.3 | 3.0 | | 10 | 4.4 | 3.0 | | 11 | 4.5 | 3.0 | | 12 | 4.6 | 3.0 | | 13 | 4.7 | 3.0 | | 14 | 4.8 | 3.0 | | 15 | 4.9 | 3.0 | | 16 | 5.0 | 3.0 | | 17 | 5.1 | 5.97 | | 18 | 5.2 | 5.999694 | | 19 | 5.3 | 5.999997 | | 20 | 5.4 | 6.0 | | 21 | 5.5 | 6.0 | | 22 | 5.6 | 6.0 | | 23 | 5.7 | 6.0 | | 24 | 5.8 | 6.0 | | 25 | 5.9 | 6.0 | | 26 | 6.0 | 6.0 | | 27 | 6.1 | 6.0 | | 28 | 6.2 | 6.0 | | 29 | 6.3 | 6.0 | | 30 | 6.4 | 6.0 | | 31 | 6.5 | 6.0 |
Inflow smaller than minimum release, moderate smoothing, with interpolation:
>>> fluxes.inflow = 2.0 >>> set_tolerances(0.1) >>> apply_targetrange(True) >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | 3.5 | 3.0 | | 2 | 3.6 | 3.0 | | 3 | 3.7 | 3.0 | | 4 | 3.8 | 3.0 | | 5 | 3.9 | 3.0 | | 6 | 4.0 | 3.0 | | 7 | 4.1 | 3.0 | | 8 | 4.2 | 3.0 | | 9 | 4.3 | 3.0 | | 10 | 4.4 | 3.0 | | 11 | 4.5 | 3.0 | | 12 | 4.6 | 3.0 | | 13 | 4.7 | 3.0 | | 14 | 4.8 | 3.000001 | | 15 | 4.9 | 3.0003 | | 16 | 5.0 | 3.0 | | 17 | 5.1 | 3.3267 | | 18 | 5.2 | 3.605861 | | 19 | 5.3 | 3.901105 | | 20 | 5.4 | 4.200201 | | 21 | 5.5 | 4.5 | | 22 | 5.6 | 4.799799 | | 23 | 5.7 | 5.098894 | | 24 | 5.8 | 5.394077 | | 25 | 5.9 | 5.67 | | 26 | 6.0 | 5.877052 | | 27 | 6.1 | 5.97 | | 28 | 6.2 | 5.994077 | | 29 | 6.3 | 5.998894 | | 30 | 6.4 | 5.999796 | | 31 | 6.5 | 5.999962 |
Inflow larger than maximum release, without smoothing, without interpolation:
>>> fluxes.inflow = 7.0 >>> set_tolerances(0.0) >>> apply_targetrange(False) >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | 3.5 | 3.0 | | 2 | 3.6 | 3.0 | | 3 | 3.7 | 3.0 | | 4 | 3.8 | 3.0 | | 5 | 3.9 | 3.0 | | 6 | 4.0 | 3.0 | | 7 | 4.1 | 3.0 | | 8 | 4.2 | 3.0 | | 9 | 4.3 | 3.0 | | 10 | 4.4 | 3.0 | | 11 | 4.5 | 3.0 | | 12 | 4.6 | 3.0 | | 13 | 4.7 | 3.0 | | 14 | 4.8 | 3.0 | | 15 | 4.9 | 3.0 | | 16 | 5.0 | 6.0 | | 17 | 5.1 | 6.0 | | 18 | 5.2 | 6.0 | | 19 | 5.3 | 6.0 | | 20 | 5.4 | 6.0 | | 21 | 5.5 | 6.0 | | 22 | 5.6 | 6.0 | | 23 | 5.7 | 6.0 | | 24 | 5.8 | 6.0 | | 25 | 5.9 | 6.0 | | 26 | 6.0 | 6.0 | | 27 | 6.1 | 6.0 | | 28 | 6.2 | 6.0 | | 29 | 6.3 | 6.0 | | 30 | 6.4 | 6.0 | | 31 | 6.5 | 6.0 |
Inflow larger than maximum release, without smoothing, with interpolation:
>>> fluxes.inflow = 7.0 >>> set_tolerances(0.0) >>> apply_targetrange(True) >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | 3.5 | 3.0 | | 2 | 3.6 | 3.0 | | 3 | 3.7 | 3.0 | | 4 | 3.8 | 3.0 | | 5 | 3.9 | 3.0 | | 6 | 4.0 | 3.0 | | 7 | 4.1 | 3.3 | | 8 | 4.2 | 3.6 | | 9 | 4.3 | 3.9 | | 10 | 4.4 | 4.2 | | 11 | 4.5 | 4.5 | | 12 | 4.6 | 4.8 | | 13 | 4.7 | 5.1 | | 14 | 4.8 | 5.4 | | 15 | 4.9 | 5.7 | | 16 | 5.0 | 6.0 | | 17 | 5.1 | 6.0 | | 18 | 5.2 | 6.0 | | 19 | 5.3 | 6.0 | | 20 | 5.4 | 6.0 | | 21 | 5.5 | 6.0 | | 22 | 5.6 | 6.0 | | 23 | 5.7 | 6.0 | | 24 | 5.8 | 6.0 | | 25 | 5.9 | 6.0 | | 26 | 6.0 | 6.0 | | 27 | 6.1 | 6.0 | | 28 | 6.2 | 6.0 | | 29 | 6.3 | 6.0 | | 30 | 6.4 | 6.0 | | 31 | 6.5 | 6.0 |
Inflow larger than maximum release, moderate smoothing, without interpolation:
>>> fluxes.inflow = 7.0 >>> apply_targetrange(False) >>> set_tolerances(0.1) >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | 3.5 | 3.0 | | 2 | 3.6 | 3.0 | | 3 | 3.7 | 3.0 | | 4 | 3.8 | 3.0 | | 5 | 3.9 | 3.0 | | 6 | 4.0 | 3.0 | | 7 | 4.1 | 3.0 | | 8 | 4.2 | 3.0 | | 9 | 4.3 | 3.0 | | 10 | 4.4 | 3.0 | | 11 | 4.5 | 3.0 | | 12 | 4.6 | 3.0 | | 13 | 4.7 | 3.000003 | | 14 | 4.8 | 3.000306 | | 15 | 4.9 | 3.03 | | 16 | 5.0 | 6.0 | | 17 | 5.1 | 6.0 | | 18 | 5.2 | 6.0 | | 19 | 5.3 | 6.0 | | 20 | 5.4 | 6.0 | | 21 | 5.5 | 6.0 | | 22 | 5.6 | 6.0 | | 23 | 5.7 | 6.0 | | 24 | 5.8 | 6.0 | | 25 | 5.9 | 6.0 | | 26 | 6.0 | 6.0 | | 27 | 6.1 | 6.0 | | 28 | 6.2 | 6.0 | | 29 | 6.3 | 6.0 | | 30 | 6.4 | 6.0 | | 31 | 6.5 | 6.0 |
Inflow larger than maximum release, moderate smoothing, with interpolation:
>>> fluxes.inflow = 7.0 >>> apply_targetrange(True) >>> set_tolerances(0.1) >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | 3.5 | 3.000038 | | 2 | 3.6 | 3.000204 | | 3 | 3.7 | 3.001106 | | 4 | 3.8 | 3.005923 | | 5 | 3.9 | 3.03 | | 6 | 4.0 | 3.122948 | | 7 | 4.1 | 3.33 | | 8 | 4.2 | 3.605923 | | 9 | 4.3 | 3.901106 | | 10 | 4.4 | 4.200201 | | 11 | 4.5 | 4.5 | | 12 | 4.6 | 4.799799 | | 13 | 4.7 | 5.098895 | | 14 | 4.8 | 5.394139 | | 15 | 4.9 | 5.6733 | | 16 | 5.0 | 6.0 | | 17 | 5.1 | 5.9997 | | 18 | 5.2 | 5.999999 | | 19 | 5.3 | 6.0 | | 20 | 5.4 | 6.0 | | 21 | 5.5 | 6.0 | | 22 | 5.6 | 6.0 | | 23 | 5.7 | 6.0 | | 24 | 5.8 | 6.0 | | 25 | 5.9 | 6.0 | | 26 | 6.0 | 6.0 | | 27 | 6.1 | 6.0 | | 28 | 6.2 | 6.0 | | 29 | 6.3 | 6.0 | | 30 | 6.4 | 6.0 | | 31 | 6.5 | 6.0 |
Maximum release smaller than minimum release, without smoothing, with interpolation:
>>> aides.alloweddischarge = 1.0 >>> set_tolerances(0.0) >>> apply_targetrange(True) >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | 3.5 | 3.0 | | 2 | 3.6 | 3.0 | | 3 | 3.7 | 3.0 | | 4 | 3.8 | 3.0 | | 5 | 3.9 | 3.0 | | 6 | 4.0 | 3.0 | | 7 | 4.1 | 3.0 | | 8 | 4.2 | 3.0 | | 9 | 4.3 | 3.0 | | 10 | 4.4 | 3.0 | | 11 | 4.5 | 3.0 | | 12 | 4.6 | 3.0 | | 13 | 4.7 | 3.0 | | 14 | 4.8 | 3.0 | | 15 | 4.9 | 3.0 | | 16 | 5.0 | 3.0 | | 17 | 5.1 | 3.0 | | 18 | 5.2 | 3.0 | | 19 | 5.3 | 3.0 | | 20 | 5.4 | 3.0 | | 21 | 5.5 | 3.0 | | 22 | 5.6 | 3.0 | | 23 | 5.7 | 3.0 | | 24 | 5.8 | 3.0 | | 25 | 5.9 | 3.0 | | 26 | 6.0 | 3.0 | | 27 | 6.1 | 3.0 | | 28 | 6.2 | 3.0 | | 29 | 6.3 | 3.0 | | 30 | 6.4 | 3.0 | | 31 | 6.5 | 3.0 |
Maximum release smaller than minimum release, moderate smoothing, with interpolation:
>>> aides.alloweddischarge = 1.0 >>> set_tolerances(0.1) >>> apply_targetrange(True) >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | 3.5 | 3.000001 | | 2 | 3.6 | 3.000003 | | 3 | 3.7 | 3.000015 | | 4 | 3.8 | 3.000081 | | 5 | 3.9 | 3.00041 | | 6 | 4.0 | 3.00168 | | 7 | 4.1 | 3.004508 | | 8 | 4.2 | 3.008277 | | 9 | 4.3 | 3.01231 | | 10 | 4.4 | 3.016396 | | 11 | 4.5 | 3.020491 | | 12 | 4.6 | 3.024587 | | 13 | 4.7 | 3.028673 | | 14 | 4.8 | 3.032702 | | 15 | 4.9 | 3.03611 | | 16 | 5.0 | 3.040983 | | 17 | 5.1 | 3.000406 | | 18 | 5.2 | 3.000004 | | 19 | 5.3 | 3.0 | | 20 | 5.4 | 3.0 | | 21 | 5.5 | 3.0 | | 22 | 5.6 | 3.0 | | 23 | 5.7 | 3.0 | | 24 | 5.8 | 3.0 | | 25 | 5.9 | 3.0 | | 26 | 6.0 | 3.0 | | 27 | 6.1 | 3.0 | | 28 | 6.2 | 3.0 | | 29 | 6.3 | 3.0 | | 30 | 6.4 | 3.0 | | 31 | 6.5 | 3.0 |
>>> from hydpy import UnitTest >>> test = UnitTest(model, model.calc_actualrelease_v3, ... last_example=21, ... parseqs=(states.watervolume, ... fluxes.actualrelease)) >>> test.nexts.watervolume = numpy.arange(-0.5, 1.6, 0.1) >>> model.idx_sim = pub.timegrids.init["2001-04-01"] >>> fluxes.inflow = 0.0
Zero values, without smoothing, with interpolation:
>>> set_tolerances(0.0) >>> apply_targetrange(True) >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | -0.5 | 0.0 | | 2 | -0.4 | 0.0 | | 3 | -0.3 | 0.0 | | 4 | -0.2 | 0.0 | | 5 | -0.1 | 0.0 | | 6 | 0.0 | 0.0 | | 7 | 0.1 | 1.0 | | 8 | 0.2 | 1.0 | | 9 | 0.3 | 1.0 | | 10 | 0.4 | 1.0 | | 11 | 0.5 | 1.0 | | 12 | 0.6 | 1.0 | | 13 | 0.7 | 1.0 | | 14 | 0.8 | 1.0 | | 15 | 0.9 | 1.0 | | 16 | 1.0 | 1.0 | | 17 | 1.1 | 1.0 | | 18 | 1.2 | 1.0 | | 19 | 1.3 | 1.0 | | 20 | 1.4 | 1.0 | | 21 | 1.5 | 1.0 |
Zero values, moderate smoothing, with interpolation:
>>> set_tolerances(0.1) >>> apply_targetrange(True) >>> test() | ex. | watervolume | actualrelease | ------------------------------------- | 1 | -0.5 | 0.0 | | 2 | -0.4 | 0.0 | | 3 | -0.3 | 0.0 | | 4 | -0.2 | 0.000004 | | 5 | -0.1 | 0.00042 | | 6 | 0.0 | 0.032478 | | 7 | 0.1 | 0.941985 | | 8 | 0.2 | 0.9998 | | 9 | 0.3 | 0.999998 | | 10 | 0.4 | 1.0 | | 11 | 0.5 | 1.0 | | 12 | 0.6 | 1.0 | | 13 | 0.7 | 1.0 | | 14 | 0.8 | 1.0 | | 15 | 0.9 | 1.0 | | 16 | 1.0 | 1.0 | | 17 | 1.1 | 1.0 | | 18 | 1.2 | 1.0 | | 19 | 1.3 | 1.0 | | 20 | 1.4 | 1.0 | | 21 | 1.5 | 1.0 |
- class hydpy.models.dam.dam_model.Calc_MissingRemoteRelease_V1[source]¶
Bases:
Method
Calculate the portion of the required remote demand that could not be met by the actual discharge release.
- Requires the flux sequences:
- Calculates the flux sequence:
- Basic equation:
\(MissingRemoteRelease = max( RequiredRemoteRelease-ActualRelease, 0)\)
Example:
>>> from hydpy.models.dam import * >>> parameterstep() >>> fluxes.requiredremoterelease = 2.0 >>> fluxes.actualrelease = 1.0 >>> model.calc_missingremoterelease_v1() >>> fluxes.missingremoterelease missingremoterelease(1.0) >>> fluxes.actualrelease = 3.0 >>> model.calc_missingremoterelease_v1() >>> fluxes.missingremoterelease missingremoterelease(0.0)
- class hydpy.models.dam.dam_model.Calc_ActualRemoteRelease_V1[source]¶
Bases:
Method
Calculate the actual remote water release that can be supplied by the dam considering the required remote release and the given water level.
- Requires the control parameter:
- Requires the derived parameter:
- Requires the factor sequence:
- Requires the flux sequence:
- Calculates the flux sequence:
- Used auxiliary method:
smooth_logistic1()
- Basic equation:
\(ActualRemoteRelease = RequiredRemoteRelease \cdot smooth_{logistic1}(WaterLevelMinimumRemoteThreshold-WaterLevel, WaterLevelMinimumRemoteSmoothPar)\)
Examples:
Note that method
Calc_ActualRemoteRelease_V1
is functionally identical with methodCalc_ActualRelease_V1
. This is why we omit to explain the following examples, as they are just repetitions of the ones of methodCalc_ActualRemoteRelease_V1
with partly different variable names. Please follow the links to read the corresponding explanations.>>> from hydpy.models.dam import * >>> parameterstep() >>> fluxes.requiredremoterelease = 2.0 >>> from hydpy import UnitTest >>> test = UnitTest(model, model.calc_actualremoterelease_v1, ... last_example=7, ... parseqs=(factors.waterlevel, ... fluxes.actualremoterelease)) >>> test.nexts.waterlevel = range(-1, 6)
>>> waterlevelminimumremotethreshold(0.) >>> waterlevelminimumremotetolerance(0.) >>> derived.waterlevelminimumremotesmoothpar.update() >>> test() | ex. | waterlevel | actualremoterelease | ------------------------------------------ | 1 | -1.0 | 0.0 | | 2 | 0.0 | 1.0 | | 3 | 1.0 | 2.0 | | 4 | 2.0 | 2.0 | | 5 | 3.0 | 2.0 | | 6 | 4.0 | 2.0 | | 7 | 5.0 | 2.0 |
>>> waterlevelminimumremotethreshold(4.) >>> waterlevelminimumremotetolerance(1.) >>> derived.waterlevelminimumremotesmoothpar.update() >>> test() | ex. | waterlevel | actualremoterelease | ------------------------------------------ | 1 | -1.0 | 0.0 | | 2 | 0.0 | 0.0 | | 3 | 1.0 | 0.000002 | | 4 | 2.0 | 0.000204 | | 5 | 3.0 | 0.02 | | 6 | 4.0 | 1.0 | | 7 | 5.0 | 1.98 |
>>> waterlevelminimumremotethreshold(1.) >>> waterlevelminimumremotetolerance(2.) >>> derived.waterlevelminimumremotesmoothpar.update() >>> test() | ex. | waterlevel | actualremoterelease | ------------------------------------------ | 1 | -1.0 | 0.02 | | 2 | 0.0 | 0.18265 | | 3 | 1.0 | 1.0 | | 4 | 2.0 | 1.81735 | | 5 | 3.0 | 1.98 | | 6 | 4.0 | 1.997972 | | 7 | 5.0 | 1.999796 |
- class hydpy.models.dam.dam_model.Update_ActualRemoteRelief_V1[source]¶
Bases:
Method
Constrain the actual relief discharge to a remote location.
- Requires the control parameter:
- Requires the derived parameter:
- Updates the flux sequence:
- Used additional method:
- Basic equation - discontinous:
\(ActualRemoteRelief = min(ActualRemoteRelease, HighestRemoteDischarge)\)
- Basic equation - continous:
\(ActualRemoteRelief = smooth_min1(ActualRemoteRelief, HighestRemoteDischarge, HighestRemoteSmoothPar)\)
Examples:
Prepare a dam model:
>>> from hydpy.models.dam import * >>> parameterstep()
Prepare a test function object that performs eight examples with
ActualRemoteRelief
ranging from 0 to 8 m³/s and a fixed initial value of parameterHighestRemoteDischarge
of 4 m³/s:>>> highestremotedischarge(4.0) >>> from hydpy import UnitTest >>> test = UnitTest(model, ... model.update_actualremoterelief_v1, ... last_example=8, ... parseqs=(fluxes.actualremoterelief,)) >>> test.nexts.actualremoterelief = range(8)
Through setting the value of
HighestRemoteTolerance
to the lowest possible value, there is no smoothing. Instead, the shown relationship agrees with a combination of the discontinuous minimum and maximum function:>>> highestremotetolerance(0.0) >>> derived.highestremotesmoothpar.update() >>> test() | ex. | actualremoterelief | ---------------------------- | 1 | 0.0 | | 2 | 1.0 | | 3 | 2.0 | | 4 | 3.0 | | 5 | 4.0 | | 6 | 4.0 | | 7 | 4.0 | | 8 | 4.0 |
Setting a sensible
HighestRemoteTolerance
value results in a moderate smoothing:>>> highestremotetolerance(0.1) >>> derived.highestremotesmoothpar.update() >>> test() | ex. | actualremoterelief | ---------------------------- | 1 | 0.0 | | 2 | 0.999999 | | 3 | 1.99995 | | 4 | 2.996577 | | 5 | 3.836069 | | 6 | 3.991578 | | 7 | 3.993418 | | 8 | 3.993442 |
- class hydpy.models.dam.dam_model.Update_ActualRemoteRelease_V1[source]¶
Bases:
Method
Constrain the actual release (supply discharge) to a remote location.
- Requires the control parameter:
- Requires the derived parameter:
- Requires the flux sequence:
- Updates the flux sequence:
- Used additional method:
- Basic equation - discontinous:
\(ActualRemoteRelease = min(ActualRemoteRelease, HighestRemoteDischarge - ActualRemoteRelief)\)
- Basic equation - continous:
\(ActualRemoteRelease = smooth_min1(ActualRemoteRelease, HighestRemoteDischarge - ActualRemoteRelief, HighestRemoteSmoothPar)\)
Examples:
Prepare a dam model:
>>> from hydpy.models.dam import * >>> parameterstep()
Prepare a test function object that performs eight examples with
ActualRemoteRelief
ranging from 0 to 8 m³/s and a fixed initial value of parameterActualRemoteRelease
of 2 m³/s:>>> from hydpy import UnitTest >>> test = UnitTest(model, ... model.update_actualremoterelease_v1, ... last_example=8, ... parseqs=(fluxes.actualremoterelief, ... fluxes.actualremoterelease)) >>> test.nexts.actualremoterelief = range(8) >>> test.inits.actualremoterelease = 2.0
Through setting the value of
HighestRemoteTolerance
to the lowest possible value, there is no smoothing. Instead, the shown relationship agrees with a combination of the discontinuous minimum and maximum function:>>> highestremotedischarge(6.0) >>> highestremotetolerance(0.0) >>> derived.highestremotesmoothpar.update() >>> test() | ex. | actualremoterelief | actualremoterelease | -------------------------------------------------- | 1 | 0.0 | 2.0 | | 2 | 1.0 | 2.0 | | 3 | 2.0 | 2.0 | | 4 | 3.0 | 2.0 | | 5 | 4.0 | 2.0 | | 6 | 5.0 | 1.0 | | 7 | 6.0 | 0.0 | | 8 | 7.0 | 0.0 |
Setting a sensible
HighestRemoteTolerance
value results in a moderate smoothing. But note that this is only true for the minimum function (restricting the largerActualRemoteRelease
values). Instead of smoothing the maximum function as well,ActualRemoteRelease
is exactly 0 m³/s for aActualRemoteRelief
value of 6 m³/s (within the shown precision). The remaining discontinuity does not pose a problem, as longActualRemoteRelief
does not exceed the value ofHighestRemoteDischarge
. (Application models using methodUpdate_ActualRemoteRelease_V1
should generally enforce this restriction). In case of exceedance, extended computation times might occur:>>> highestremotetolerance(0.1) >>> derived.highestremotesmoothpar.update() >>> test() | ex. | actualremoterelief | actualremoterelease | -------------------------------------------------- | 1 | 0.0 | 1.999996 | | 2 | 1.0 | 1.999925 | | 3 | 2.0 | 1.998739 | | 4 | 3.0 | 1.979438 | | 5 | 4.0 | 1.754104 | | 6 | 5.0 | 0.976445 | | 7 | 6.0 | 0.0 | | 8 | 7.0 | 0.0 |
- class hydpy.models.dam.dam_model.Calc_FloodDischarge_V1[source]¶
Bases:
Method
Calculate the discharge during and after a flood event based on seasonally varying interpolation approaches approximating the relationship(s) between discharge and water stage.
- Requires the control parameter:
- Requires the derived parameter:
- Requires the factor sequence:
- Calculates the flux sequence:
Example:
The control parameter
WaterLevel2FloodDischarge
is derived fromSeasonalInterpolator
. This allows to simulate different seasonal dam control schemes. To show that the seasonal selection mechanism is implemented properly, we define a short simulation period of three days:>>> from hydpy import pub >>> pub.timegrids = "2001.01.01", "2001.01.04", "1d"
Now we prepare a dam model and define two different relationships between water level and flood discharge using artificial neural networks as interpolators. The first relatively simple relationship (for January 2) is based on two neurons contained in a single hidden layer and is used in the following example. The second neural network (for January 3) is not applied at all, which is why we do not need to assign any parameter values to it:
>>> from hydpy.models.dam import * >>> parameterstep() >>> waterlevel2flooddischarge( ... _01_02_12 = ANN(nmb_inputs=1, ... nmb_neurons=(2,), ... nmb_outputs=1, ... weights_input=[[50.0, 4]], ... weights_output=[[2.0], [30]], ... intercepts_hidden=[[-13000, -1046]], ... intercepts_output=[0.0]), ... _01_03_12 = ANN(nmb_inputs=1, ... nmb_neurons=(2,), ... nmb_outputs=1)) >>> derived.toy.update() >>> model.idx_sim = pub.timegrids.sim["2001.01.02"]
The following example shows two distinct effects of both neurons in the first network. One neuron describes a relatively sharp increase between 259.8 and 260.2 meters from about 0 to 2 m³/s. This could describe a release of water through a bottom outlet controlled by a valve. The add something like an exponential increase between 260 and 261 meters, which could describe the uncontrolled flow over a spillway:
>>> from hydpy import UnitTest >>> test = UnitTest(model, ... model.calc_flooddischarge_v1, ... last_example=21, ... parseqs=(factors.waterlevel, ... fluxes.flooddischarge)) >>> test.nexts.waterlevel = numpy.arange(257, 261.1, 0.2) >>> test() | ex. | waterlevel | flooddischarge | ------------------------------------- | 1 | 257.0 | 0.0 | | 2 | 257.2 | 0.000001 | | 3 | 257.4 | 0.000002 | | 4 | 257.6 | 0.000005 | | 5 | 257.8 | 0.000011 | | 6 | 258.0 | 0.000025 | | 7 | 258.2 | 0.000056 | | 8 | 258.4 | 0.000124 | | 9 | 258.6 | 0.000275 | | 10 | 258.8 | 0.000612 | | 11 | 259.0 | 0.001362 | | 12 | 259.2 | 0.003031 | | 13 | 259.4 | 0.006745 | | 14 | 259.6 | 0.015006 | | 15 | 259.8 | 0.033467 | | 16 | 260.0 | 1.074179 | | 17 | 260.2 | 2.164498 | | 18 | 260.4 | 2.363853 | | 19 | 260.6 | 2.79791 | | 20 | 260.8 | 3.719725 | | 21 | 261.0 | 5.576088 |
- class hydpy.models.dam.dam_model.Calc_Outflow_V1[source]¶
Bases:
Method
Calculate the total outflow of the dam.
- Requires the flux sequences:
- Calculates the flux sequence:
Note that the maximum function is used to prevent from negative outflow values, which could otherwise occur within the required level of numerical accuracy.
- Basic equation:
\(Outflow = max(ActualRelease + FloodDischarge, 0.)\)
Example:
>>> from hydpy.models.dam import * >>> parameterstep() >>> fluxes.actualrelease = 2.0 >>> fluxes.flooddischarge = 3.0 >>> model.calc_outflow_v1() >>> fluxes.outflow outflow(5.0) >>> fluxes.flooddischarge = -3.0 >>> model.calc_outflow_v1() >>> fluxes.outflow outflow(0.0)
- class hydpy.models.dam.dam_model.Calc_AllowedDischarge_V1[source]¶
Bases:
Method
Calculate the maximum discharge not leading to exceedance of the allowed water level drop.
- Requires the control parameter:
- Requires the derived parameter:
- Requires the flux sequences:
- Requires the aide sequence:
- Calculates the aide sequence:
- Basic equation:
\(Outflow = AllowedWaterLevelDrop \cdot SurfaceArea + Inflow + AdjustedPrecipitation - AdjustedEvaporation + Exchange\)
Example:
>>> from hydpy.models.dam import * >>> parameterstep("1d") >>> simulationstep("1h") >>> allowedwaterleveldrop(0.1) >>> derived.seconds.update() >>> fluxes.adjustedprecipitation = 1.0 >>> fluxes.inflow = 3.0 >>> fluxes.actualevaporation = 2.0 >>> fluxes.exchange = 4.0 >>> aides.surfacearea = 0.864 >>> model.calc_alloweddischarge_v1() >>> aides.alloweddischarge alloweddischarge(7.0)
- class hydpy.models.dam.dam_model.Calc_AllowedDischarge_V2[source]¶
Bases:
Method
Calculate the maximum discharge not leading to exceedance of the allowed water level drop.
- Requires the control parameters:
- Requires the derived parameters:
- Requires the flux sequence:
- Requires the aide sequence:
- Calculates the aide sequence:
- Used additional methods:
smooth_min1()
- Basic (discontinuous) equation:
\(Outflow = min(AllowedRelease, AllowedWaterLevelDrop \cdot SurfaceArea + Inflow\)
Example:
>>> from hydpy import pub >>> pub.timegrids = "2001.03.30", "2001.04.03", "1h"
>>> from hydpy.models.dam import * >>> parameterstep("1d")
>>> allowedwaterleveldrop(0.1) >>> allowedrelease(_11_01_12=1.0, _03_31_12=1.0, ... _04_01_00=3.0, _04_02_00=3.0, ... _04_02_12=5.0, _10_31_12=5.0)
>>> derived.seconds.update() >>> derived.toy.update()
>>> aides.surfacearea = 0.864 >>> from hydpy import UnitTest >>> test = UnitTest(model, ... model.calc_alloweddischarge_v2, ... last_example=7, ... parseqs=(fluxes.inflow, ... aides.alloweddischarge)) >>> import numpy >>> test.nexts.inflow = 1.0, 1.5, 1.9, 2.0, 2.1, 2.5, 3.0
>>> model.idx_sim = pub.timegrids.init["2001-04-01"]
>>> dischargetolerance(0.0) >>> derived.dischargesmoothpar.update() >>> test() | ex. | inflow | alloweddischarge | ----------------------------------- | 1 | 1.0 | 2.0 | | 2 | 1.5 | 2.5 | | 3 | 1.9 | 2.9 | | 4 | 2.0 | 3.0 | | 5 | 2.1 | 3.0 | | 6 | 2.5 | 3.0 | | 7 | 3.0 | 3.0 |
>>> dischargetolerance(0.1) >>> derived.dischargesmoothpar.update() >>> test() | ex. | inflow | alloweddischarge | ----------------------------------- | 1 | 1.0 | 2.0 | | 2 | 1.5 | 2.499987 | | 3 | 1.9 | 2.89 | | 4 | 2.0 | 2.959017 | | 5 | 2.1 | 2.99 | | 6 | 2.5 | 2.999987 | | 7 | 3.0 | 3.0 |
- class hydpy.models.dam.dam_model.Calc_Outflow_V2[source]¶
Bases:
Method
Calculate the total outflow of the dam, taking the allowed water discharge into account.
- Requires the derived parameter:
- Requires the flux sequence:
- Requires the aide sequence:
- Calculates the flux sequence:
- Used additional method:
- Basic (discontinuous) equation:
\(Outflow = min(FloodDischarge, AllowedDischarge)\)
Examples:
>>> from hydpy.models.dam import * >>> parameterstep() >>> from hydpy import UnitTest >>> test = UnitTest(model, ... model.calc_outflow_v2, ... last_example=8, ... parseqs=(fluxes.flooddischarge, ... fluxes.outflow)) >>> test.nexts.flooddischarge = range(8)
>>> aides.alloweddischarge = 3.0
>>> dischargetolerance(0.0) >>> derived.dischargesmoothpar.update() >>> test() | ex. | flooddischarge | outflow | ---------------------------------- | 1 | 0.0 | 0.0 | | 2 | 1.0 | 1.0 | | 3 | 2.0 | 2.0 | | 4 | 3.0 | 3.0 | | 5 | 4.0 | 3.0 | | 6 | 5.0 | 3.0 | | 7 | 6.0 | 3.0 | | 8 | 7.0 | 3.0 |
>>> dischargetolerance(1.0) >>> derived.dischargesmoothpar.update() >>> test() | ex. | flooddischarge | outflow | ----------------------------------- | 1 | 0.0 | 0.0 | | 2 | 1.0 | 0.999651 | | 3 | 2.0 | 1.99 | | 4 | 3.0 | 2.794476 | | 5 | 4.0 | 2.985755 | | 6 | 5.0 | 2.991603 | | 7 | 6.0 | 2.991773 | | 8 | 7.0 | 2.991779 |
>>> aides.alloweddischarge = 0.0 >>> test() | ex. | flooddischarge | outflow | ---------------------------------- | 1 | 0.0 | 0.0 | | 2 | 1.0 | 0.0 | | 3 | 2.0 | 0.0 | | 4 | 3.0 | 0.0 | | 5 | 4.0 | 0.0 | | 6 | 5.0 | 0.0 | | 7 | 6.0 | 0.0 | | 8 | 7.0 | 0.0 |
- class hydpy.models.dam.dam_model.Update_WaterVolume_V1[source]¶
Bases:
Method
Update the actual water volume.
- Requires the derived parameter:
- Requires the flux sequences:
- Updates the state sequence:
- Basic equation:
\(\frac{d}{dt}WaterVolume = 1e-6 \cdot (AdjustedPrecipitation - AdjustedEvaporation - Inflow - Outflow)\)
Example:
>>> from hydpy.models.dam import * >>> parameterstep() >>> derived.seconds = 2e6 >>> states.watervolume.old = 5.0 >>> fluxes.adjustedprecipitation = 1.0 >>> fluxes.actualevaporation = 2.0 >>> fluxes.inflow = 3.0 >>> fluxes.outflow = 4.0 >>> model.update_watervolume_v1() >>> states.watervolume watervolume(1.0)
- class hydpy.models.dam.dam_model.Update_WaterVolume_V2[source]¶
Bases:
Method
Update the actual water volume.
- Requires the derived parameter:
- Requires the flux sequences:
AdjustedPrecipitation
ActualEvaporation
Inflow
Outflow
ActualRemoteRelease
- Updates the state sequence:
- Basic equation:
\(\frac{d}{dt}WaterVolume = 10^{-6} \cdot (AdjustedPrecipitation - AdjustedEvaporation - Inflow - Outflow - ActualRemoteRelease)\)
Example:
>>> from hydpy.models.dam import * >>> parameterstep() >>> derived.seconds = 2e6 >>> states.watervolume.old = 9.0 >>> fluxes.adjustedprecipitation = 2.0 >>> fluxes.actualevaporation = 1.0 >>> fluxes.inflow = 4.0 >>> fluxes.outflow = 3.0 >>> fluxes.actualremoterelease = 6.0 >>> model.update_watervolume_v2() >>> states.watervolume watervolume(1.0)
- class hydpy.models.dam.dam_model.Update_WaterVolume_V3[source]¶
Bases:
Method
Update the actual water volume.
- Requires the derived parameter:
- Requires the flux sequences:
AdjustedPrecipitation
ActualEvaporation
Inflow
Outflow
ActualRemoteRelease
ActualRemoteRelief
- Updates the state sequence:
- Basic equation:
\(\frac{d}{dt}WaterVolume = 10^{-6} \cdot (AdjustedPrecipitation - AdjustedEvaporation + Inflow - Outflow - ActualRemoteRelease - ActualRemoteRelief)\)
Example:
>>> from hydpy.models.dam import * >>> parameterstep() >>> derived.seconds = 2e6 >>> states.watervolume.old = 6.0 >>> fluxes.adjustedprecipitation = 5.0 >>> fluxes.actualevaporation = 4.0 >>> fluxes.inflow = 2.0 >>> fluxes.outflow = 3.0 >>> fluxes.actualremoterelease = 1.0 >>> fluxes.actualremoterelief = 0.5 >>> model.update_watervolume_v3() >>> states.watervolume watervolume(3.0)
- class hydpy.models.dam.dam_model.Update_WaterVolume_V4[source]¶
Bases:
Method
Update the actual water volume.
- Requires the derived parameter:
- Requires the flux sequences:
AdjustedPrecipitation
ActualEvaporation
Inflow
Outflow
Exchange
- Updates the state sequence:
- Basic equation:
\(\frac{d}{dt}WaterVolume = 1e-6 \cdot (AdjustedPrecipitation - AdjustedEvaporation - Inflow - Outflow + Exchange)\)
Example:
>>> from hydpy.models.dam import * >>> parameterstep() >>> derived.seconds = 2e6 >>> states.watervolume.old = 5.0 >>> fluxes.adjustedprecipitation = 1.0 >>> fluxes.actualevaporation = 2.0 >>> fluxes.inflow = 3.0 >>> fluxes.outflow = 4.0 >>> fluxes.exchange = 5.0 >>> model.update_watervolume_v4() >>> states.watervolume watervolume(11.0)
- class hydpy.models.dam.dam_model.Pass_Outflow_V1[source]¶
Bases:
Method
Update the outlet link sequence
Q
.
- class hydpy.models.dam.dam_model.Pass_ActualRemoteRelease_V1[source]¶
Bases:
Method
Update the outlet link sequence
S
.- Requires the flux sequence:
- Calculates the outlet sequence:
- Basic equation:
\(S = ActualRemoteRelease\)
- class hydpy.models.dam.dam_model.Pass_ActualRemoteRelief_V1[source]¶
Bases:
Method
Update the outlet link sequence
R
.- Requires the flux sequence:
- Calculates the outlet sequence:
- Basic equation:
\(R = ActualRemoteRelief\)
- class hydpy.models.dam.dam_model.Pass_MissingRemoteRelease_V1[source]¶
Bases:
Method
Update the outlet link sequence
D
.- Requires the flux sequence:
- Calculates the sender sequence:
- Basic equation:
\(D = MissingRemoteRelease\)
- class hydpy.models.dam.dam_model.Pass_AllowedRemoteRelief_V1[source]¶
Bases:
Method
Update the outlet link sequence
R
.- Requires the flux sequence:
- Calculates the sender sequence:
- Basic equation:
\(R = AllowedRemoteRelief\)
- class hydpy.models.dam.dam_model.Pass_RequiredRemoteSupply_V1[source]¶
Bases:
Method
Update the outlet link sequence
S
.- Requires the flux sequence:
- Calculates the sender sequence:
- Basic equation:
\(S = RequiredRemoteSupply\)
- class hydpy.models.dam.dam_model.Update_LoggedOutflow_V1[source]¶
Bases:
Method
Log a new entry of discharge at a cross section far downstream.
- Requires the control parameter:
- Requires the flux sequence:
- Updates the log sequence:
Example:
The following example shows that, with each new method call, the three memorized values are successively moved to the right and the respective new value is stored on the bare left position:
>>> from hydpy.models.dam import * >>> parameterstep() >>> nmblogentries(3) >>> logs.loggedoutflow = 0.0 >>> from hydpy import UnitTest >>> test = UnitTest(model, ... model.update_loggedoutflow_v1, ... last_example=4, ... parseqs=(fluxes.outflow, ... logs.loggedoutflow)) >>> test.nexts.outflow = [1.0, 3.0, 2.0, 4.0] >>> del test.inits.loggedoutflow >>> test() | ex. | outflow | loggedoutflow | ------------------------------------------- | 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 |
Parameter Features¶
Control parameters¶
- class hydpy.models.dam.ControlParameters(master: Parameters, cls_fastaccess: Type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)
Bases:
SubParameters
Control parameters of model dam.
- The following classes are selected:
SurfaceArea()
Average size of the water surface [km²].CatchmentArea()
Size of the catchment draining into the dam [km²].NmbLogEntries()
Number of log entries for certain variables [-].CorrectionPrecipitation()
Precipitation correction factor [-].CorrectionEvaporation()
Evaporation correction factor [-].WeightEvaporation()
Time weighting factor for evaporation [-].RemoteDischargeMinimum()
Discharge threshold of a cross-section far downstream not to be undercut by the actual discharge [m³/s].RemoteDischargeSafety()
Safety factor for reducing the risk to release not enough water [m³/s].WaterLevel2PossibleRemoteRelief()
Artificial neural network describing the relationship between water level and the highest possible water release used to relieve the dam during high flow conditions [-].RemoteReliefTolerance()
A tolerance value forPossibleRemoteRelief
[m³/s].NearDischargeMinimumThreshold()
Discharge threshold of a cross-section near the dam not to be undercut by the actual discharge [m³/s].NearDischargeMinimumTolerance()
A tolerance value for the “near discharge minimum” [m³/s].RestrictTargetedRelease()
A flag indicating whether low flow variability has to be preserved or not [-].WaterVolumeMinimumThreshold()
The minimum operating water volume of the dam [million m³].WaterLevelMinimumThreshold()
The minimum operating water level of the dam [m].WaterLevelMinimumTolerance()
A tolerance value for the minimum operating water level [m].ThresholdEvaporation()
The water level at which actual evaporation is 50 % of potential evaporation [m].ToleranceEvaporation()
A tolerance value defining the steepness of the transition of actual evaporation between zero and potential evaporation [m].WaterLevelMinimumRemoteThreshold()
The minimum operating water level of the dam regarding remote water supply [m].WaterLevelMinimumRemoteTolerance()
A tolerance value for the minimum operating water level regarding remote water supply [m].HighestRemoteRelief()
The highest possible relief discharge from another location [m³/s].WaterLevelReliefThreshold()
The threshold water level of the dam regarding the allowed relief discharge from another location [m].WaterLevelReliefTolerance()
A tolerance value for parameterWaterLevelReliefThreshold
[m].HighestRemoteSupply()
The highest possible supply discharge from another location [m³/s].WaterLevelSupplyThreshold()
The threshold water level of the dam regarding the required supply discharge from another location [m].WaterLevelSupplyTolerance()
A tolerance value for parameterWaterLevelSupplyThreshold
[m].HighestRemoteDischarge()
The highest possible discharge between two remote locations [m³/s].HighestRemoteTolerance()
Smoothing parameter associated withHighestRemoteDischarge
[m³/s].WaterVolume2WaterLevel()
Artificial neural network describing the relationship between water level and water volume [-].WaterLevel2FloodDischarge()
Artificial neural network describing the relationship between flood discharge and water volume [-].AllowedWaterLevelDrop()
The highest allowed water level decrease [m/T].AllowedRelease()
The maximum water release not causing any harm downstream [m³/s].TargetVolume()
The desired volume of water required within the dam at specific times of the year [Mio. m³].TargetRangeAbsolute()
The absolute interpolation range related to parameterTargetVolume
[Mio. m³].TargetRangeRelative()
The relative interpolation range related to parameterTargetVolume
[-].VolumeTolerance()
Smoothing parameter for volume related smoothing operations [Mio. m³].DischargeTolerance()
Smoothing parameter for discharge related smoothing operations [m³/s].
- class hydpy.models.dam.dam_control.SurfaceArea(subvars: SubParameters)[source]¶
Bases:
Parameter
Average size of the water surface [km²].
- class hydpy.models.dam.dam_control.CatchmentArea(subvars: SubParameters)[source]¶
Bases:
Parameter
Size of the catchment draining into the dam [km²].
- class hydpy.models.dam.dam_control.NmbLogEntries(subvars: SubParameters)[source]¶
Bases:
Parameter
Number of log entries for certain variables [-].
- Required by the methods:
Calc_NaturalRemoteDischarge_V1
Calc_RemoteFailure_V1
Update_LoggedOutflow_V1
Update_LoggedTotalRemoteDischarge_V1
Note that setting a new value by calling the parameter object sets the shapes of all associated log sequences automatically, except those with a predefined default shape:
>>> from hydpy.models.dam import * >>> parameterstep() >>> nmblogentries(3) >>> for seq in logs: ... print(seq) loggedtotalremotedischarge(nan, nan, nan) loggedoutflow(nan, nan, nan) loggedadjustedevaporation(nan) loggedrequiredremoterelease(nan) loggedallowedremoterelief(nan)
To prevent losing information, updating parameter
NmbLogEntries
resets the shape of the relevant log sequences only when necessary:>>> logs.loggedtotalremotedischarge = 1.0 >>> nmblogentries(3) >>> logs.loggedtotalremotedischarge loggedtotalremotedischarge(1.0, 1.0, 1.0)
- class hydpy.models.dam.dam_control.CorrectionPrecipitation(subvars: SubParameters)[source]¶
Bases:
Parameter
Precipitation correction factor [-].
- Required by the method:
- class hydpy.models.dam.dam_control.CorrectionEvaporation(subvars: SubParameters)[source]¶
Bases:
Parameter
Evaporation correction factor [-].
- Required by the method:
- class hydpy.models.dam.dam_control.WeightEvaporation(subvars: SubParameters)[source]¶
Bases:
Parameter
Time weighting factor for evaporation [-].
- Required by the method:
- class hydpy.models.dam.dam_control.RemoteDischargeMinimum(subvars)[source]¶
Bases:
SeasonalParameter
Discharge threshold of a cross-section far downstream not to be undercut by the actual discharge [m³/s].
- Required by the methods:
- class hydpy.models.dam.dam_control.RemoteDischargeSafety(subvars)[source]¶
Bases:
SeasonalParameter
Safety factor for reducing the risk to release not enough water [m³/s].
- Required by the method:
- class hydpy.models.dam.dam_control.WaterLevel2PossibleRemoteRelief(subvars: SubParameters)[source]¶
Bases:
SimpleInterpolator
Artificial neural network describing the relationship between water level and the highest possible water release used to relieve the dam during high flow conditions [-].
- Required by the method:
- XLABEL = 'water level [m]'¶
- YLABEL = 'possible remote relieve [m³/s]'¶
- class hydpy.models.dam.dam_control.RemoteReliefTolerance(subvars: SubParameters)[source]¶
Bases:
Parameter
A tolerance value for
PossibleRemoteRelief
[m³/s].- Required by the method:
- class hydpy.models.dam.dam_control.NearDischargeMinimumThreshold(subvars)[source]¶
Bases:
SeasonalParameter
Discharge threshold of a cross-section near the dam not to be undercut by the actual discharge [m³/s].
- Required by the methods:
Calc_ActualRelease_V3
Calc_RequiredRelease_V1
Calc_RequiredRelease_V2
Calc_TargetedRelease_V1
- class hydpy.models.dam.dam_control.NearDischargeMinimumTolerance(subvars)[source]¶
Bases:
SeasonalParameter
A tolerance value for the “near discharge minimum” [m³/s].
- class hydpy.models.dam.dam_control.RestrictTargetedRelease(subvars: SubParameters)[source]¶
Bases:
Parameter
A flag indicating whether low flow variability has to be preserved or not [-].
- Required by the method:
- class hydpy.models.dam.dam_control.WaterVolumeMinimumThreshold(subvars)[source]¶
Bases:
SeasonalParameter
The minimum operating water volume of the dam [million m³].
- Required by the method:
- class hydpy.models.dam.dam_control.WaterLevelMinimumThreshold(subvars: SubParameters)[source]¶
Bases:
Parameter
The minimum operating water level of the dam [m].
- Required by the methods:
- class hydpy.models.dam.dam_control.WaterLevelMinimumTolerance(subvars: SubParameters)[source]¶
Bases:
Parameter
A tolerance value for the minimum operating water level [m].
- class hydpy.models.dam.dam_control.ThresholdEvaporation(subvars: SubParameters)[source]¶
Bases:
Parameter
The water level at which actual evaporation is 50 % of potential evaporation [m].
- Required by the method:
- class hydpy.models.dam.dam_control.ToleranceEvaporation(subvars: SubParameters)[source]¶
Bases:
Parameter
A tolerance value defining the steepness of the transition of actual evaporation between zero and potential evaporation [m].
- class hydpy.models.dam.dam_control.WaterLevelMinimumRemoteThreshold(subvars: SubParameters)[source]¶
Bases:
Parameter
The minimum operating water level of the dam regarding remote water supply [m].
- Required by the method:
- class hydpy.models.dam.dam_control.WaterLevelMinimumRemoteTolerance(subvars: SubParameters)[source]¶
Bases:
Parameter
A tolerance value for the minimum operating water level regarding remote water supply [m].
- class hydpy.models.dam.dam_control.HighestRemoteRelief(subvars)[source]¶
Bases:
SeasonalParameter
The highest possible relief discharge from another location [m³/s].
- Required by the method:
- class hydpy.models.dam.dam_control.WaterLevelReliefThreshold(subvars)[source]¶
Bases:
SeasonalParameter
The threshold water level of the dam regarding the allowed relief discharge from another location [m].
- Required by the method:
- class hydpy.models.dam.dam_control.WaterLevelReliefTolerance(subvars)[source]¶
Bases:
SeasonalParameter
A tolerance value for parameter
WaterLevelReliefThreshold
[m].
- class hydpy.models.dam.dam_control.HighestRemoteSupply(subvars)[source]¶
Bases:
SeasonalParameter
The highest possible supply discharge from another location [m³/s].
- Required by the method:
- class hydpy.models.dam.dam_control.WaterLevelSupplyThreshold(subvars)[source]¶
Bases:
SeasonalParameter
The threshold water level of the dam regarding the required supply discharge from another location [m].
- Required by the method:
- class hydpy.models.dam.dam_control.WaterLevelSupplyTolerance(subvars)[source]¶
Bases:
SeasonalParameter
A tolerance value for parameter
WaterLevelSupplyThreshold
[m].
- class hydpy.models.dam.dam_control.HighestRemoteDischarge(subvars: SubParameters)[source]¶
Bases:
Parameter
The highest possible discharge between two remote locations [m³/s].
- Required by the methods:
- class hydpy.models.dam.dam_control.HighestRemoteTolerance(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter associated with
HighestRemoteDischarge
[m³/s].
- class hydpy.models.dam.dam_control.WaterVolume2WaterLevel(subvars: SubParameters)[source]¶
Bases:
SimpleInterpolator
Artificial neural network describing the relationship between water level and water volume [-].
- Required by the methods:
- XLABEL = 'water volume [million m³]'¶
- YLABEL = 'water level [m]'¶
- class hydpy.models.dam.dam_control.WaterLevel2FloodDischarge(subvars: SubParameters)[source]¶
Bases:
SeasonalInterpolator
Artificial neural network describing the relationship between flood discharge and water volume [-].
- Required by the method:
- XLABEL = 'water level [m]'¶
- YLABEL = 'flood discharge [m³/s]'¶
- class hydpy.models.dam.dam_control.AllowedWaterLevelDrop(subvars: SubParameters)[source]¶
Bases:
Parameter
The highest allowed water level decrease [m/T].
- Required by the methods:
- class hydpy.models.dam.dam_control.AllowedDischargeTolerance(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter eventually associated with
AllowedWaterLevelDrop
[m³/s].
- class hydpy.models.dam.dam_control.AllowedRelease(subvars)[source]¶
Bases:
SeasonalParameter
The maximum water release not causing any harm downstream [m³/s].
- Required by the methods:
- class hydpy.models.dam.dam_control.TargetVolume(subvars)[source]¶
Bases:
SeasonalParameter
The desired volume of water required within the dam at specific times of the year [Mio. m³].
- Required by the method:
- class hydpy.models.dam.dam_control.TargetRangeAbsolute(subvars: SubParameters)[source]¶
Bases:
Parameter
The absolute interpolation range related to parameter
TargetVolume
[Mio. m³].- Required by the method:
- class hydpy.models.dam.dam_control.TargetRangeRelative(subvars: SubParameters)[source]¶
Bases:
Parameter
The relative interpolation range related to parameter
TargetVolume
[-].- Required by the method:
- class hydpy.models.dam.dam_control.VolumeTolerance(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter for volume related smoothing operations [Mio. m³].
- class hydpy.models.dam.dam_control.DischargeTolerance(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter for discharge related smoothing operations [m³/s].
Derived parameters¶
- class hydpy.models.dam.DerivedParameters(master: Parameters, cls_fastaccess: Type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)
Bases:
SubParameters
Derived parameters of model dam.
- The following classes are selected:
TOY()
References thetimeofyear
index array provided by the instance of classIndexer
available in modulepub
[-].Seconds()
Length of the actual simulation step size [s].InputFactor()
Factor for converting meteorological input from mm/T to million m³/s.RemoteDischargeSmoothPar()
Smoothing parameter to be derived fromRemoteDischargeSafety
[m³/s].NearDischargeMinimumSmoothPar1()
Smoothing parameter to be derived fromNearDischargeMinimumThreshold
for smoothing kernelsmooth_logistic1()
[m³/s].NearDischargeMinimumSmoothPar2()
Smoothing parameter to be derived fromNearDischargeMinimumThreshold
for smoothing kernelsmooth_logistic2()
[m³/s].WaterLevelMinimumSmoothPar()
Smoothing parameter to be derived fromWaterLevelMinimumTolerance
for smoothing kernelsmooth_logistic1()
[m].SmoothParEvaporation()
Smoothing parameter to be derived fromToleranceEvaporation
for smoothing kernelsmooth_logistic1()
[m].WaterLevelMinimumRemoteSmoothPar()
Smoothing parameter to be derived fromWaterLevelMinimumRemoteTolerance
[m].WaterLevelReliefSmoothPar()
Smoothing parameter to be derived fromWaterLevelReliefTolerance
for smoothing kernelsmooth_logistic1()
[m³/s].WaterLevelSupplySmoothPar()
Smoothing parameter to be derived fromWaterLevelSupplyTolerance
for smoothing kernelsmooth_logistic1()
[m³/s].HighestRemoteSmoothPar()
Smoothing parameter to be derived fromHighestRemoteTolerance
for smoothing kernelsmooth_min1()
[m³/s].VolumeSmoothParLog1()
Smoothing parameter to be derived fromVolumeTolerance
for smoothing kernelsmooth_logistic1()
[Mio. m³].VolumeSmoothParLog2()
Smoothing parameter to be derived fromVolumeTolerance
for smoothing kernelsmooth_logistic2()
[Mio. m³].DischargeSmoothPar()
Smoothing parameter to be derived fromDischargeTolerance
for smoothing kernelssmooth_min1()
andsmooth_max1()
[m³/s].
- class hydpy.models.dam.dam_derived.TOY(subvars: SubParameters)[source]¶
Bases:
TOYParameter
References the
timeofyear
index array provided by the instance of classIndexer
available in modulepub
[-].- Required by the methods:
Calc_ActualRelease_V2
Calc_ActualRelease_V3
Calc_AllowedDischarge_V2
Calc_AllowedRemoteRelief_V2
Calc_FloodDischarge_V1
Calc_RemoteDemand_V1
Calc_RemoteFailure_V1
Calc_RequiredRelease_V1
Calc_RequiredRelease_V2
Calc_RequiredRemoteRelease_V1
Calc_RequiredRemoteSupply_V1
Calc_TargetedRelease_V1
- class hydpy.models.dam.dam_derived.Seconds(subvars: SubParameters)[source]¶
Bases:
SecondsParameter
Length of the actual simulation step size [s].
- class hydpy.models.dam.dam_derived.InputFactor(subvars: SubParameters)[source]¶
Bases:
Parameter
Factor for converting meteorological input from mm/T to million m³/s.
- Required by the methods:
- update()[source]¶
Update
InputFactor
based on the control parameterSurfaceArea
and the derived parameterSeconds
:>>> from hydpy.models.dam import * >>> parameterstep() >>> surfacearea(36.0) >>> derived.seconds(3600.0) >>> derived.inputfactor.update() >>> derived.inputfactor inputfactor(10.0)
- class hydpy.models.dam.dam_derived.RemoteDischargeSmoothPar(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter to be derived from
RemoteDischargeSafety
[m³/s].- Required by the method:
- update()[source]¶
Calculate the smoothing parameter values.
The documentation on module
smoothtools
explains the following example in some detail:>>> from hydpy import pub >>> pub.timegrids = "2000.01.01", "2000.01.03", "1d" >>> from hydpy.models.dam import * >>> parameterstep() >>> remotedischargesafety(0.0) >>> remotedischargesafety.values[1] = 2.5 >>> derived.remotedischargesmoothpar.update() >>> from hydpy.cythons.smoothutils import smooth_logistic1 >>> from hydpy import round_ >>> round_(smooth_logistic1(0.1, derived.remotedischargesmoothpar[0])) 1.0 >>> round_(smooth_logistic1(2.5, derived.remotedischargesmoothpar[1])) 0.99
- class hydpy.models.dam.dam_derived.NearDischargeMinimumSmoothPar1(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter to be derived from
NearDischargeMinimumThreshold
for smoothing kernelsmooth_logistic1()
[m³/s].- Required by the method:
- update()[source]¶
Calculate the smoothing parameter values.
The documentation on module
smoothtools
explains the following example in some detail:>>> from hydpy import pub >>> pub.timegrids = "2000.01.01", "2000.01.03", "1d" >>> from hydpy.models.dam import * >>> parameterstep() >>> neardischargeminimumtolerance(0.0) >>> neardischargeminimumtolerance.values[1] = 2.5 >>> derived.neardischargeminimumsmoothpar1.update() >>> from hydpy.cythons.smoothutils import smooth_logistic1 >>> from hydpy import round_ >>> round_(smooth_logistic1(1.0, derived.neardischargeminimumsmoothpar1[0])) 1.0 >>> round_(smooth_logistic1(2.5, derived.neardischargeminimumsmoothpar1[1])) 0.99
- class hydpy.models.dam.dam_derived.NearDischargeMinimumSmoothPar2(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter to be derived from
NearDischargeMinimumThreshold
for smoothing kernelsmooth_logistic2()
[m³/s].- Required by the method:
- update()[source]¶
Calculate the smoothing parameter values.
The documentation on module
smoothtools
explains the following example in some detail:>>> from hydpy import pub >>> pub.timegrids = "2000.01.01", "2000.01.03", "1d" >>> from hydpy.models.dam import * >>> parameterstep() >>> neardischargeminimumtolerance(0.0) >>> neardischargeminimumtolerance.values[1] = 2.5 >>> derived.neardischargeminimumsmoothpar2.update() >>> from hydpy.cythons.smoothutils import smooth_logistic2 >>> from hydpy import round_ >>> round_(smooth_logistic2(0.0, derived.neardischargeminimumsmoothpar2[0])) 0.0 >>> round_(smooth_logistic2(2.5, derived.neardischargeminimumsmoothpar2[1])) 2.51
- class hydpy.models.dam.dam_derived.WaterLevelMinimumSmoothPar(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter to be derived from
WaterLevelMinimumTolerance
for smoothing kernelsmooth_logistic1()
[m].- Required by the methods:
- update()[source]¶
Calculate the smoothing parameter value.
The documentation on module
smoothtools
explains the following example in some detail:>>> from hydpy.models.dam import * >>> parameterstep() >>> waterlevelminimumtolerance(0.0) >>> derived.waterlevelminimumsmoothpar.update() >>> from hydpy.cythons.smoothutils import smooth_logistic1 >>> from hydpy import round_ >>> round_(smooth_logistic1(0.1, derived.waterlevelminimumsmoothpar)) 1.0 >>> waterlevelminimumtolerance(2.5) >>> derived.waterlevelminimumsmoothpar.update() >>> round_(smooth_logistic1(2.5, derived.waterlevelminimumsmoothpar)) 0.99
- class hydpy.models.dam.dam_derived.SmoothParEvaporation(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter to be derived from
ToleranceEvaporation
for smoothing kernelsmooth_logistic1()
[m].- Required by the method:
- update()[source]¶
Calculate the smoothing parameter value.
The documentation on module
smoothtools
explains the following example in some detail:>>> from hydpy.models.dam import * >>> parameterstep() >>> toleranceevaporation(0.0) >>> derived.smoothparevaporation.update() >>> from hydpy.cythons.smoothutils import smooth_logistic1 >>> from hydpy import round_ >>> round_(smooth_logistic1(0.1, derived.smoothparevaporation)) 1.0 >>> toleranceevaporation(2.5) >>> derived.smoothparevaporation.update() >>> round_(smooth_logistic1(2.5, derived.smoothparevaporation)) 0.99
- class hydpy.models.dam.dam_derived.WaterLevelMinimumRemoteSmoothPar(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter to be derived from
WaterLevelMinimumRemoteTolerance
[m].- Required by the method:
- update()[source]¶
Calculate the smoothing parameter value.
The documentation on module
smoothtools
explains the following example in some detail:>>> from hydpy.models.dam import * >>> parameterstep() >>> waterlevelminimumremotetolerance(0.0) >>> derived.waterlevelminimumremotesmoothpar.update() >>> from hydpy.cythons.smoothutils import smooth_logistic1 >>> from hydpy import round_ >>> round_(smooth_logistic1(0.1, ... derived.waterlevelminimumremotesmoothpar)) 1.0 >>> waterlevelminimumremotetolerance(2.5) >>> derived.waterlevelminimumremotesmoothpar.update() >>> round_(smooth_logistic1(2.5, derived.waterlevelminimumremotesmoothpar)) 0.99
- class hydpy.models.dam.dam_derived.WaterLevelReliefSmoothPar(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter to be derived from
WaterLevelReliefTolerance
for smoothing kernelsmooth_logistic1()
[m³/s].- Required by the method:
- update()[source]¶
Calculate the smoothing parameter values.
The documentation on module
smoothtools
explains the following example in some detail:>>> from hydpy import pub >>> pub.timegrids = "2000.01.01", "2000.01.03", "1d" >>> from hydpy.models.dam import * >>> parameterstep() >>> waterlevelrelieftolerance(0.0) >>> waterlevelrelieftolerance.values[1] = 2.5 >>> derived.waterlevelreliefsmoothpar.update() >>> from hydpy.cythons.smoothutils import smooth_logistic1 >>> from hydpy import round_ >>> round_(smooth_logistic1(1.0, derived.waterlevelreliefsmoothpar[0])) 1.0 >>> round_(smooth_logistic1(2.5, derived.waterlevelreliefsmoothpar[1])) 0.99
- class hydpy.models.dam.dam_derived.WaterLevelSupplySmoothPar(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter to be derived from
WaterLevelSupplyTolerance
for smoothing kernelsmooth_logistic1()
[m³/s].- Required by the method:
- update()[source]¶
Calculate the smoothing parameter values.
The documentation on module
smoothtools
explains the following example in some detail:>>> from hydpy import pub >>> pub.timegrids = "2000.01.01", "2000.01.03", "1d" >>> from hydpy.models.dam import * >>> parameterstep() >>> waterlevelsupplytolerance(0.0) >>> waterlevelsupplytolerance.values[1] = 2.5 >>> derived.waterlevelsupplysmoothpar.update() >>> from hydpy.cythons.smoothutils import smooth_logistic1 >>> from hydpy import round_ >>> round_(smooth_logistic1(1.0, derived.waterlevelsupplysmoothpar[0])) 1.0 >>> round_(smooth_logistic1(2.5, derived.waterlevelsupplysmoothpar[1])) 0.99
- class hydpy.models.dam.dam_derived.HighestRemoteSmoothPar(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter to be derived from
HighestRemoteTolerance
for smoothing kernelsmooth_min1()
[m³/s].- Required by the methods:
- update()[source]¶
Calculate the smoothing parameter value.
The documentation on module
smoothtools
explains the following example in some detail:>>> from hydpy.models.dam import * >>> parameterstep() >>> highestremotedischarge(1.0) >>> highestremotetolerance(0.0) >>> derived.highestremotesmoothpar.update() >>> from hydpy.cythons.smoothutils import smooth_min1 >>> from hydpy import round_ >>> round_(smooth_min1(-4.0, 1.5, derived.highestremotesmoothpar)) -4.0 >>> highestremotetolerance(2.5) >>> derived.highestremotesmoothpar.update() >>> round_(smooth_min1(-4.0, -1.5, derived.highestremotesmoothpar)) -4.01
Note that the example above corresponds to the one on function
calc_smoothpar_min1()
due to the value of parameterHighestRemoteDischarge
being 1 m³/s. DoublingHighestRemoteDischarge
also doublesHighestRemoteSmoothPar
, leading to the following result:>>> highestremotedischarge(2.0) >>> derived.highestremotesmoothpar.update() >>> round_(smooth_min1(-4.0, 1.0, derived.highestremotesmoothpar)) -4.02
This relationship between
HighestRemoteDischarge
andHighestRemoteSmoothPar
prevents any smoothing when the value ofHighestRemoteDischarge
is zero:>>> highestremotedischarge(0.0) >>> derived.highestremotesmoothpar.update() >>> round_(smooth_min1(1.0, 1.0, derived.highestremotesmoothpar)) 1.0
In addition, method
update()
sets the value of parameterHighestRemoteSmoothPar
to zero ifHighestRemoteDischarge
isinf
(no actual value will ever reach vicinity of infinity, hence smoothing would never apply anyway):>>> highestremotedischarge(inf) >>> derived.highestremotesmoothpar.update() >>> round_(smooth_min1(1.0, 1.0, derived.highestremotesmoothpar)) 1.0
- class hydpy.models.dam.dam_derived.VolumeSmoothParLog1(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter to be derived from
VolumeTolerance
for smoothing kernelsmooth_logistic1()
[Mio. m³].- Required by the method:
- update()[source]¶
Calculate the smoothing parameter value.
The documentation on module
smoothtools
explains the following example in some detail:>>> from hydpy.models.dam import * >>> parameterstep() >>> volumetolerance(0.0) >>> derived.volumesmoothparlog1.update() >>> from hydpy.cythons.smoothutils import smooth_logistic1 >>> from hydpy import round_ >>> round_(smooth_logistic1(0.1, derived.volumesmoothparlog1)) 1.0 >>> volumetolerance(2.5) >>> derived.volumesmoothparlog1.update() >>> round_(smooth_logistic1(2.5, derived.volumesmoothparlog1)) 0.99
- class hydpy.models.dam.dam_derived.VolumeSmoothParLog2(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter to be derived from
VolumeTolerance
for smoothing kernelsmooth_logistic2()
[Mio. m³].- Required by the method:
- update()[source]¶
Calculate the smoothing parameter value.
The documentation on module
smoothtools
explains the following example in some detail:>>> from hydpy.models.dam import * >>> parameterstep() >>> from hydpy.cythons.smoothutils import smooth_logistic2 >>> from hydpy import round_ >>> volumetolerance(0.0) >>> derived.volumesmoothparlog2.update() >>> round_(smooth_logistic2(0.0, derived.volumesmoothparlog2)) 0.0 >>> volumetolerance(2.5) >>> derived.volumesmoothparlog2.update() >>> round_(smooth_logistic2(2.5, derived.volumesmoothparlog2)) 2.51
- class hydpy.models.dam.dam_derived.DischargeSmoothPar(subvars: SubParameters)[source]¶
Bases:
Parameter
Smoothing parameter to be derived from
DischargeTolerance
for smoothing kernelssmooth_min1()
andsmooth_max1()
[m³/s].- Required by the methods:
Calc_ActualRelease_V3
Calc_AllowedDischarge_V2
Calc_Outflow_V2
- update()[source]¶
Calculate the smoothing parameter value.
The documentation on module
smoothtools
explains the following example in some detail:>>> from hydpy.models.dam import * >>> parameterstep() >>> dischargetolerance(0.0) >>> derived.dischargesmoothpar.update() >>> from hydpy.cythons.smoothutils import smooth_max1, smooth_min1 >>> from hydpy import round_ >>> round_(smooth_max1(4.0, 1.5, derived.dischargesmoothpar)) 4.0 >>> round_(smooth_min1(4.0, 1.5, derived.dischargesmoothpar)) 1.5 >>> dischargetolerance(2.5) >>> derived.dischargesmoothpar.update() >>> round_(smooth_max1(4.0, 1.5, derived.dischargesmoothpar)) 4.01 >>> round_(smooth_min1(4.0, 1.5, derived.dischargesmoothpar)) 1.49
Solver parameters¶
- class hydpy.models.dam.SolverParameters(master: Parameters, cls_fastaccess: Type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)
Bases:
SubParameters
Solver parameters of model dam.
- The following classes are selected:
AbsErrorMax()
Absolute numerical error tolerance [m³/s].RelErrorMax()
Relative numerical error tolerance [1/T].RelDTMin()
Smallest relative integration time step size allowed [-].RelDTMax()
Largest relative integration time step size allowed [-].
- class hydpy.models.dam.dam_solver.AbsErrorMax(subvars)[source]¶
Bases:
SolverParameter
Absolute numerical error tolerance [m³/s].
- modify_init() None [source]¶
Adjust and return the value of class constant INIT.
Note that the default initial value 0.01 refers to mm/T. Hence the actual default initial value in m³/s is:
\(AbsErrorMax = 0.01 \cdot CatchmentArea \cdot 1000 / Seconds\)
>>> from hydpy.models.dam import * >>> simulationstep("1h") >>> parameterstep("1d") >>> solver.abserrormax.INIT 0.01 >>> catchmentarea(2.0) >>> derived.seconds.update() >>> from hydpy import round_ >>> round_(solver.abserrormax.modify_init()) 0.005556
- class hydpy.models.dam.dam_solver.RelErrorMax(subvars)[source]¶
Bases:
SolverParameter
Relative numerical error tolerance [1/T].
- class hydpy.models.dam.dam_solver.RelDTMin(subvars)[source]¶
Bases:
SolverParameter
Smallest relative integration time step size allowed [-].
- class hydpy.models.dam.dam_solver.RelDTMax(subvars)[source]¶
Bases:
SolverParameter
Largest relative integration time step size allowed [-].
Sequence Features¶
Input sequences¶
- class hydpy.models.dam.InputSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)
Bases:
InputSequences
Input sequences of model dam.
- The following classes are selected:
Precipitation()
Precipitation [mm].Evaporation()
Potential evaporation [mm].
- class hydpy.models.dam.dam_inputs.Precipitation(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
InputSequence
Precipitation [mm].
- Required by the method:
- class hydpy.models.dam.dam_inputs.Evaporation(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
InputSequence
Potential evaporation [mm].
- Required by the method:
Factor sequences¶
- class hydpy.models.dam.FactorSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)
Bases:
FactorSequences
Factor sequences of model dam.
- The following classes are selected:
WaterLevel()
Water level [m].
- class hydpy.models.dam.dam_factors.WaterLevel(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FactorSequence
Water level [m].
- Calculated by the method:
- Required by the methods:
Calc_ActualEvaporation_V1
Calc_ActualRelease_V1
Calc_ActualRelease_V2
Calc_ActualRemoteRelease_V1
Calc_AllowedRemoteRelief_V2
Calc_FloodDischarge_V1
Calc_PossibleRemoteRelief_V1
Calc_RequiredRemoteSupply_V1
After each simulation step, the value of
WaterLevel
corresponds to the value of the state sequenceWaterVolume
for the end of the simulation step.
Flux sequences¶
- class hydpy.models.dam.FluxSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)
Bases:
FluxSequences
Flux sequences of model dam.
- The following classes are selected:
AdjustedPrecipitation()
Adjusted precipitation [m³/s].AdjustedEvaporation()
Adjusted evaporation [m³/s].ActualEvaporation()
Actual evaporation [m³/s].Inflow()
Total inflow [m³/s].Exchange()
Water exchange with another location [m³/s].TotalRemoteDischarge()
Total discharge at a cross-section far downstream [m³/s].NaturalRemoteDischarge()
Natural discharge at a cross-section far downstream [m³/s].RemoteDemand()
Discharge demand at a cross-section far downstream [m³/s].RemoteFailure()
Difference between the actual and the required discharge at a cross-section far downstream [m³/s].RequiredRemoteRelease()
Water release considered appropriate to reduce drought events at cross-sections far downstream [m³/s].AllowedRemoteRelief()
Allowed discharge to relieve a dam during high flow conditions [m³/s].RequiredRemoteSupply()
Required water supply, for example, to fill a dam during low water conditions [m³/s].PossibleRemoteRelief()
Maximum possible water release to a remote location to relieve the dam during high flow conditions [m³/s].ActualRemoteRelief()
Actual water release to a remote location to relieve the dam during high flow conditions [m³/s].RequiredRelease()
Required water release for reducing drought events downstream [m³/s].TargetedRelease()
The targeted water release for reducing drought events downstream after taking both the required release and additional low flow regulations into account [m³/s].ActualRelease()
Actual water release thought for reducing drought events downstream [m³/s].MissingRemoteRelease()
Amount of the required remote demand not met by the actual release [m³/s].ActualRemoteRelease()
Actual water release thought for arbitrary “remote” purposes [m³/s].FloodDischarge()
Water release associated with flood events [m³/s].Outflow()
Total outflow [m³/s].
- class hydpy.models.dam.dam_fluxes.AdjustedPrecipitation(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Adjusted precipitation [m³/s].
- Calculated by the method:
- Required by the methods:
Calc_AllowedDischarge_V1
Update_WaterVolume_V1
Update_WaterVolume_V2
Update_WaterVolume_V3
Update_WaterVolume_V4
- class hydpy.models.dam.dam_fluxes.AdjustedEvaporation(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Adjusted evaporation [m³/s].
- Calculated by the method:
- Required by the method:
- class hydpy.models.dam.dam_fluxes.ActualEvaporation(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Actual evaporation [m³/s].
- Calculated by the method:
- Required by the methods:
Calc_AllowedDischarge_V1
Update_WaterVolume_V1
Update_WaterVolume_V2
Update_WaterVolume_V3
Update_WaterVolume_V4
- class hydpy.models.dam.dam_fluxes.Inflow(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Total inflow [m³/s].
- Calculated by the methods:
- Required by the methods:
Calc_ActualRelease_V3
Calc_AllowedDischarge_V1
Calc_AllowedDischarge_V2
Calc_TargetedRelease_V1
Update_WaterVolume_V1
Update_WaterVolume_V2
Update_WaterVolume_V3
Update_WaterVolume_V4
- class hydpy.models.dam.dam_fluxes.Exchange(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Water exchange with another location [m³/s].
- Required by the methods:
- class hydpy.models.dam.dam_fluxes.TotalRemoteDischarge(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Total discharge at a cross-section far downstream [m³/s].
- Calculated by the method:
- Required by the method:
- class hydpy.models.dam.dam_fluxes.NaturalRemoteDischarge(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Natural discharge at a cross-section far downstream [m³/s].
- Calculated by the method:
- Required by the method:
Natural means: without the water released by the dam.
- class hydpy.models.dam.dam_fluxes.RemoteDemand(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Discharge demand at a cross-section far downstream [m³/s].
- Calculated by the method:
- Required by the method:
- class hydpy.models.dam.dam_fluxes.RemoteFailure(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Difference between the actual and the required discharge at a cross-section far downstream [m³/s].
- Calculated by the method:
- Required by the method:
- class hydpy.models.dam.dam_fluxes.RequiredRemoteRelease(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Water release considered appropriate to reduce drought events at cross-sections far downstream [m³/s].
- Calculated by the methods:
- Required by the methods:
Calc_ActualRemoteRelease_V1
Calc_MissingRemoteRelease_V1
Calc_RequiredRelease_V1
- class hydpy.models.dam.dam_fluxes.AllowedRemoteRelief(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Allowed discharge to relieve a dam during high flow conditions [m³/s].
- Calculated by the methods:
- Required by the methods:
- class hydpy.models.dam.dam_fluxes.RequiredRemoteSupply(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Required water supply, for example, to fill a dam during low water conditions [m³/s].
- Calculated by the method:
- Required by the method:
- class hydpy.models.dam.dam_fluxes.PossibleRemoteRelief(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Maximum possible water release to a remote location to relieve the dam during high flow conditions [m³/s].
- Calculated by the method:
- Required by the method:
- class hydpy.models.dam.dam_fluxes.ActualRemoteRelief(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Actual water release to a remote location to relieve the dam during high flow conditions [m³/s].
- Calculated by the method:
- Updated by the method:
- Required by the methods:
Pass_ActualRemoteRelief_V1
Update_ActualRemoteRelease_V1
Update_WaterVolume_V3
- class hydpy.models.dam.dam_fluxes.RequiredRelease(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Required water release for reducing drought events downstream [m³/s].
- Calculated by the methods:
- Required by the method:
- class hydpy.models.dam.dam_fluxes.TargetedRelease(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
The targeted water release for reducing drought events downstream after taking both the required release and additional low flow regulations into account [m³/s].
- Calculated by the method:
- Required by the method:
- class hydpy.models.dam.dam_fluxes.ActualRelease(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Actual water release thought for reducing drought events downstream [m³/s].
- Calculated by the methods:
Calc_ActualRelease_V1
Calc_ActualRelease_V2
Calc_ActualRelease_V3
- Required by the methods:
- class hydpy.models.dam.dam_fluxes.MissingRemoteRelease(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Amount of the required remote demand not met by the actual release [m³/s].
- Calculated by the method:
- Required by the method:
- class hydpy.models.dam.dam_fluxes.ActualRemoteRelease(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Actual water release thought for arbitrary “remote” purposes [m³/s].
- Calculated by the method:
- Updated by the method:
- Required by the methods:
Pass_ActualRemoteRelease_V1
Update_WaterVolume_V2
Update_WaterVolume_V3
- class hydpy.models.dam.dam_fluxes.FloodDischarge(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Water release associated with flood events [m³/s].
- Calculated by the method:
- Required by the methods:
- class hydpy.models.dam.dam_fluxes.Outflow(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
FluxSequence
Total outflow [m³/s].
- Calculated by the methods:
- Required by the methods:
Pass_Outflow_V1
Update_LoggedOutflow_V1
Update_WaterVolume_V1
Update_WaterVolume_V2
Update_WaterVolume_V3
Update_WaterVolume_V4
State sequences¶
- class hydpy.models.dam.StateSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)
Bases:
StateSequences
State sequences of model dam.
- The following classes are selected:
WaterVolume()
Water volume [million m³].
- class hydpy.models.dam.dam_states.WaterVolume(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
StateSequence
Water volume [million m³].
- Updated by the methods:
Update_WaterVolume_V1
Update_WaterVolume_V2
Update_WaterVolume_V3
Update_WaterVolume_V4
- Required by the methods:
Calc_ActualRelease_V3
Calc_SurfaceArea_V1
Calc_WaterLevel_V1
Log sequences¶
- class hydpy.models.dam.LogSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)
Bases:
LogSequences
Log sequences of model dam.
- The following classes are selected:
LoggedTotalRemoteDischarge()
Logged discharge values from somewhere else [m3/s].LoggedOutflow()
Logged discharge values from the dam itself [m3/s].LoggedAdjustedEvaporation()
Logged adjusted evaporation [m3/s].LoggedRequiredRemoteRelease()
Logged required discharge values computed by another model [m3/s].LoggedAllowedRemoteRelief()
Logged allowed discharge values computed by another model [m3/s].
- class hydpy.models.dam.dam_logs.LoggedTotalRemoteDischarge(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
LogSequence
Logged discharge values from somewhere else [m3/s].
- Updated by the method:
- Required by the methods:
- class hydpy.models.dam.dam_logs.LoggedOutflow(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
LogSequence
Logged discharge values from the dam itself [m3/s].
- Updated by the method:
- Required by the method:
- class hydpy.models.dam.dam_logs.LoggedAdjustedEvaporation(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
LogSequenceFixed
Logged adjusted evaporation [m3/s].
- Updated by the method:
- class hydpy.models.dam.dam_logs.LoggedRequiredRemoteRelease(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
LogSequenceFixed
Logged required discharge values computed by another model [m3/s].
- Calculated by the methods:
Pic_LoggedRequiredRemoteRelease_V1
Pic_LoggedRequiredRemoteRelease_V2
- Required by the method:
- class hydpy.models.dam.dam_logs.LoggedAllowedRemoteRelief(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
LogSequenceFixed
Logged allowed discharge values computed by another model [m3/s].
- Calculated by the method:
- Required by the method:
Inlet sequences¶
- class hydpy.models.dam.InletSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)
Bases:
InletSequences
Inlet sequences of model dam.
- class hydpy.models.dam.dam_inlets.Q(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
InletSequence
Inflow [m³/s].
- Required by the methods:
- class hydpy.models.dam.dam_inlets.S(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
InletSequence
Actual water supply [m³/s].
- Required by the method:
- class hydpy.models.dam.dam_inlets.R(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
InletSequence
Actual water relief [m³/s].
- Required by the method:
- class hydpy.models.dam.dam_inlets.E(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
InletSequence
Bidirectional water exchange [m³/s].
Outlet sequences¶
- class hydpy.models.dam.OutletSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)
Bases:
OutletSequences
Outlet sequences of model dam.
- class hydpy.models.dam.dam_outlets.Q(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
OutletSequence
Outflow [m³/s].
- Calculated by the method:
- class hydpy.models.dam.dam_outlets.S(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
OutletSequence
Actual water supply [m³/s].
- Calculated by the method:
- class hydpy.models.dam.dam_outlets.R(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
OutletSequence
Actual water relief [m³/s].
- Calculated by the method:
Receiver sequences¶
- class hydpy.models.dam.ReceiverSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)
Bases:
ReceiverSequences
Receiver sequences of model dam.
- class hydpy.models.dam.dam_receivers.Q(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
ReceiverSequence
Remote discharge [m³/s].
- Required by the method:
- class hydpy.models.dam.dam_receivers.D(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
ReceiverSequence
Water demand [m³/s].
- Required by the method:
- class hydpy.models.dam.dam_receivers.S(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
ReceiverSequence
Required water supply [m³/s].
- Required by the method:
- class hydpy.models.dam.dam_receivers.R(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
ReceiverSequence
Allowed water relief [m³/s].
- Required by the method:
Sender sequences¶
- class hydpy.models.dam.SenderSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)
Bases:
SenderSequences
Sender sequences of model dam.
- class hydpy.models.dam.dam_senders.D(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
SenderSequence
Water demand [m³/s].
- Calculated by the method:
- class hydpy.models.dam.dam_senders.S(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
SenderSequence
Required water supply [m³/s].
- Calculated by the method:
- class hydpy.models.dam.dam_senders.R(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
SenderSequence
Required water relief [m³/s].
- Calculated by the method:
Aide sequences¶
- class hydpy.models.dam.AideSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)
Bases:
AideSequences
Aide sequences of model dam.
- The following classes are selected:
SurfaceArea()
Surface area [km²].AllowedDischarge()
Discharge threshold not to be overcut by the actual discharge [m³/s].
- class hydpy.models.dam.dam_aides.SurfaceArea(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
AideSequence
Surface area [km²].
- Calculated by the method:
- Required by the methods:
- class hydpy.models.dam.dam_aides.AllowedDischarge(subvars: ModelSequences[ModelSequence, FastAccess])[source]¶
Bases:
AideSequence
Discharge threshold not to be overcut by the actual discharge [m³/s].
- Calculated by the methods:
- Required by the methods:
- class hydpy.models.dam.AideSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)¶
Bases:
AideSequences
Aide sequences of model dam.
- The following classes are selected:
SurfaceArea()
Surface area [km²].AllowedDischarge()
Discharge threshold not to be overcut by the actual discharge [m³/s].
- class hydpy.models.dam.ControlParameters(master: Parameters, cls_fastaccess: Type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)¶
Bases:
SubParameters
Control parameters of model dam.
- The following classes are selected:
SurfaceArea()
Average size of the water surface [km²].CatchmentArea()
Size of the catchment draining into the dam [km²].NmbLogEntries()
Number of log entries for certain variables [-].CorrectionPrecipitation()
Precipitation correction factor [-].CorrectionEvaporation()
Evaporation correction factor [-].WeightEvaporation()
Time weighting factor for evaporation [-].RemoteDischargeMinimum()
Discharge threshold of a cross-section far downstream not to be undercut by the actual discharge [m³/s].RemoteDischargeSafety()
Safety factor for reducing the risk to release not enough water [m³/s].WaterLevel2PossibleRemoteRelief()
Artificial neural network describing the relationship between water level and the highest possible water release used to relieve the dam during high flow conditions [-].RemoteReliefTolerance()
A tolerance value forPossibleRemoteRelief
[m³/s].NearDischargeMinimumThreshold()
Discharge threshold of a cross-section near the dam not to be undercut by the actual discharge [m³/s].NearDischargeMinimumTolerance()
A tolerance value for the “near discharge minimum” [m³/s].RestrictTargetedRelease()
A flag indicating whether low flow variability has to be preserved or not [-].WaterVolumeMinimumThreshold()
The minimum operating water volume of the dam [million m³].WaterLevelMinimumThreshold()
The minimum operating water level of the dam [m].WaterLevelMinimumTolerance()
A tolerance value for the minimum operating water level [m].ThresholdEvaporation()
The water level at which actual evaporation is 50 % of potential evaporation [m].ToleranceEvaporation()
A tolerance value defining the steepness of the transition of actual evaporation between zero and potential evaporation [m].WaterLevelMinimumRemoteThreshold()
The minimum operating water level of the dam regarding remote water supply [m].WaterLevelMinimumRemoteTolerance()
A tolerance value for the minimum operating water level regarding remote water supply [m].HighestRemoteRelief()
The highest possible relief discharge from another location [m³/s].WaterLevelReliefThreshold()
The threshold water level of the dam regarding the allowed relief discharge from another location [m].WaterLevelReliefTolerance()
A tolerance value for parameterWaterLevelReliefThreshold
[m].HighestRemoteSupply()
The highest possible supply discharge from another location [m³/s].WaterLevelSupplyThreshold()
The threshold water level of the dam regarding the required supply discharge from another location [m].WaterLevelSupplyTolerance()
A tolerance value for parameterWaterLevelSupplyThreshold
[m].HighestRemoteDischarge()
The highest possible discharge between two remote locations [m³/s].HighestRemoteTolerance()
Smoothing parameter associated withHighestRemoteDischarge
[m³/s].WaterVolume2WaterLevel()
Artificial neural network describing the relationship between water level and water volume [-].WaterLevel2FloodDischarge()
Artificial neural network describing the relationship between flood discharge and water volume [-].AllowedWaterLevelDrop()
The highest allowed water level decrease [m/T].AllowedRelease()
The maximum water release not causing any harm downstream [m³/s].TargetVolume()
The desired volume of water required within the dam at specific times of the year [Mio. m³].TargetRangeAbsolute()
The absolute interpolation range related to parameterTargetVolume
[Mio. m³].TargetRangeRelative()
The relative interpolation range related to parameterTargetVolume
[-].VolumeTolerance()
Smoothing parameter for volume related smoothing operations [Mio. m³].DischargeTolerance()
Smoothing parameter for discharge related smoothing operations [m³/s].
- class hydpy.models.dam.DerivedParameters(master: Parameters, cls_fastaccess: Type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)¶
Bases:
SubParameters
Derived parameters of model dam.
- The following classes are selected:
TOY()
References thetimeofyear
index array provided by the instance of classIndexer
available in modulepub
[-].Seconds()
Length of the actual simulation step size [s].InputFactor()
Factor for converting meteorological input from mm/T to million m³/s.RemoteDischargeSmoothPar()
Smoothing parameter to be derived fromRemoteDischargeSafety
[m³/s].NearDischargeMinimumSmoothPar1()
Smoothing parameter to be derived fromNearDischargeMinimumThreshold
for smoothing kernelsmooth_logistic1()
[m³/s].NearDischargeMinimumSmoothPar2()
Smoothing parameter to be derived fromNearDischargeMinimumThreshold
for smoothing kernelsmooth_logistic2()
[m³/s].WaterLevelMinimumSmoothPar()
Smoothing parameter to be derived fromWaterLevelMinimumTolerance
for smoothing kernelsmooth_logistic1()
[m].SmoothParEvaporation()
Smoothing parameter to be derived fromToleranceEvaporation
for smoothing kernelsmooth_logistic1()
[m].WaterLevelMinimumRemoteSmoothPar()
Smoothing parameter to be derived fromWaterLevelMinimumRemoteTolerance
[m].WaterLevelReliefSmoothPar()
Smoothing parameter to be derived fromWaterLevelReliefTolerance
for smoothing kernelsmooth_logistic1()
[m³/s].WaterLevelSupplySmoothPar()
Smoothing parameter to be derived fromWaterLevelSupplyTolerance
for smoothing kernelsmooth_logistic1()
[m³/s].HighestRemoteSmoothPar()
Smoothing parameter to be derived fromHighestRemoteTolerance
for smoothing kernelsmooth_min1()
[m³/s].VolumeSmoothParLog1()
Smoothing parameter to be derived fromVolumeTolerance
for smoothing kernelsmooth_logistic1()
[Mio. m³].VolumeSmoothParLog2()
Smoothing parameter to be derived fromVolumeTolerance
for smoothing kernelsmooth_logistic2()
[Mio. m³].DischargeSmoothPar()
Smoothing parameter to be derived fromDischargeTolerance
for smoothing kernelssmooth_min1()
andsmooth_max1()
[m³/s].
- class hydpy.models.dam.FactorSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)¶
Bases:
FactorSequences
Factor sequences of model dam.
- The following classes are selected:
WaterLevel()
Water level [m].
- class hydpy.models.dam.FluxSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)¶
Bases:
FluxSequences
Flux sequences of model dam.
- The following classes are selected:
AdjustedPrecipitation()
Adjusted precipitation [m³/s].AdjustedEvaporation()
Adjusted evaporation [m³/s].ActualEvaporation()
Actual evaporation [m³/s].Inflow()
Total inflow [m³/s].Exchange()
Water exchange with another location [m³/s].TotalRemoteDischarge()
Total discharge at a cross-section far downstream [m³/s].NaturalRemoteDischarge()
Natural discharge at a cross-section far downstream [m³/s].RemoteDemand()
Discharge demand at a cross-section far downstream [m³/s].RemoteFailure()
Difference between the actual and the required discharge at a cross-section far downstream [m³/s].RequiredRemoteRelease()
Water release considered appropriate to reduce drought events at cross-sections far downstream [m³/s].AllowedRemoteRelief()
Allowed discharge to relieve a dam during high flow conditions [m³/s].RequiredRemoteSupply()
Required water supply, for example, to fill a dam during low water conditions [m³/s].PossibleRemoteRelief()
Maximum possible water release to a remote location to relieve the dam during high flow conditions [m³/s].ActualRemoteRelief()
Actual water release to a remote location to relieve the dam during high flow conditions [m³/s].RequiredRelease()
Required water release for reducing drought events downstream [m³/s].TargetedRelease()
The targeted water release for reducing drought events downstream after taking both the required release and additional low flow regulations into account [m³/s].ActualRelease()
Actual water release thought for reducing drought events downstream [m³/s].MissingRemoteRelease()
Amount of the required remote demand not met by the actual release [m³/s].ActualRemoteRelease()
Actual water release thought for arbitrary “remote” purposes [m³/s].FloodDischarge()
Water release associated with flood events [m³/s].Outflow()
Total outflow [m³/s].
- class hydpy.models.dam.InletSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)¶
Bases:
InletSequences
Inlet sequences of model dam.
- class hydpy.models.dam.InputSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)¶
Bases:
InputSequences
Input sequences of model dam.
- The following classes are selected:
Precipitation()
Precipitation [mm].Evaporation()
Potential evaporation [mm].
- class hydpy.models.dam.LogSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)¶
Bases:
LogSequences
Log sequences of model dam.
- The following classes are selected:
LoggedTotalRemoteDischarge()
Logged discharge values from somewhere else [m3/s].LoggedOutflow()
Logged discharge values from the dam itself [m3/s].LoggedAdjustedEvaporation()
Logged adjusted evaporation [m3/s].LoggedRequiredRemoteRelease()
Logged required discharge values computed by another model [m3/s].LoggedAllowedRemoteRelief()
Logged allowed discharge values computed by another model [m3/s].
- class hydpy.models.dam.OutletSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)¶
Bases:
OutletSequences
Outlet sequences of model dam.
- class hydpy.models.dam.ReceiverSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)¶
Bases:
ReceiverSequences
Receiver sequences of model dam.
- class hydpy.models.dam.SenderSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)¶
Bases:
SenderSequences
Sender sequences of model dam.
- class hydpy.models.dam.SolverParameters(master: Parameters, cls_fastaccess: Type[FastAccessParameter] | None = None, cymodel: CyModelProtocol | None = None)¶
Bases:
SubParameters
Solver parameters of model dam.
- The following classes are selected:
AbsErrorMax()
Absolute numerical error tolerance [m³/s].RelErrorMax()
Relative numerical error tolerance [1/T].RelDTMin()
Smallest relative integration time step size allowed [-].RelDTMax()
Largest relative integration time step size allowed [-].
- class hydpy.models.dam.StateSequences(master: Sequences, cls_fastaccess: Type[TypeFastAccess_co] | None = None, cymodel: CyModelProtocol | None = None)¶
Bases:
StateSequences
State sequences of model dam.
- The following classes are selected:
WaterVolume()
Water volume [million m³].