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: hydpy.core.modeltools.ELSModel

Dam base model.

The following “receiver update methods” are called in the given sequence before performing a simulation step:
The following “inlet update methods” are called in the given sequence at the beginning of each simulation step:
  • Pic_Inflow_V1 Update the inlet link sequence.

  • Pic_Inflow_V2 Update the inlet link sequences.

  • Calc_NaturalRemoteDischarge_V1 Try to 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 link sequence.

  • Calc_WaterLevel_V1 Determine the water level based on an artificial neural network describing the relationship between water level and water stage.

  • Calc_SurfaceArea_V1 Determine the surface area based on an artificial neural network describing the relationship between water level and water stage.

  • 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_PossibleRemoteRelieve_V1 Calculate the highest possible water release that can be routed to a remote location based on an artificial neural network describing the relationship between possible release and water stage.

  • Calc_ActualRemoteRelieve_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_ActualRemoteRelieve_V1 Constrain the actual relieve 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 an SeasonalANN describing 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):
The following “outlet update methods” are called in the given sequence at the end of each simulation step:
The following “sender update methods” are called in the given sequence after performing a simulation step:
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 function smooth_min1() without risking negative results.

numconsts: hydpy.core.modeltools.NumConstsELS
numvars: hydpy.core.modeltools.NumVarsELS
class hydpy.models.dam.dam_model.Pic_Inflow_V1[source]

Bases: hydpy.core.modeltools.Method

Update the inlet link sequence.

Requires the inlet sequence:

Q

Calculates the flux sequence:

Inflow

Requires the inlet sequence:

Q

Calculates the flux sequence:

Inflow

Basic equation:

\(Inflow = Q\)

class hydpy.models.dam.dam_model.Pic_Inflow_V2[source]

Bases: hydpy.core.modeltools.Method

Update the inlet link sequences.

Requires the inlet sequences:

Q S R

Calculates the flux sequence:

Inflow

Basic equation:

\(Inflow = Q + S + R\)

class hydpy.models.dam.dam_model.Pic_TotalRemoteDischarge_V1[source]

Bases: hydpy.core.modeltools.Method

Update the receiver link sequence.

Requires the receiver sequence:

Q

Calculates the flux sequence:

TotalRemoteDischarge

Basic equation:

\(TotalRemoteDischarge = Q\)

class hydpy.models.dam.dam_model.Pic_LoggedRequiredRemoteRelease_V1[source]

Bases: hydpy.core.modeltools.Method

Update the receiver link sequence.

Requires the receiver sequence:

D

Calculates the log sequence:

LoggedRequiredRemoteRelease

Basic equation:

\(LoggedRequiredRemoteRelease = D\)

class hydpy.models.dam.dam_model.Pic_LoggedRequiredRemoteRelease_V2[source]

Bases: hydpy.core.modeltools.Method

Update the receiver link sequence.

Requires the receiver sequence:

S

Calculates the log sequence:

LoggedRequiredRemoteRelease

Basic equation:

\(LoggedRequiredRemoteRelease = S\)

class hydpy.models.dam.dam_model.Pic_LoggedAllowedRemoteRelieve_V1[source]

Bases: hydpy.core.modeltools.Method

Update the receiver link sequence.

Requires the receiver sequence:

R

Calculates the log sequence:

LoggedAllowedRemoteRelieve

Basic equation:

\(LoggedAllowedRemoteRelieve = R\)

class hydpy.models.dam.dam_model.Update_LoggedTotalRemoteDischarge_V1[source]

Bases: hydpy.core.modeltools.Method

Log a new entry of discharge at a cross section far downstream.

Requires the control parameter:

NmbLogEntries

Requires the flux sequence:

TotalRemoteDischarge

Updates the log sequence:

LoggedTotalRemoteDischarge

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.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., 3., 2., 4]
>>> 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: hydpy.core.modeltools.Method

Determine the water level based on an artificial neural network describing the relationship between water level and water stage.

Requires the control parameter:

WaterVolume2WaterLevel

Requires the state sequence:

WaterVolume

Calculates the aide sequence:

WaterLevel

Example:

Prepare a dam model:

>>> from hydpy.models.dam import *
>>> parameterstep()

Prepare a very simple relationship based on one single neuron:

>>> watervolume2waterlevel(
...         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, aides.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 |

For more realistic approximations of measured relationships between water level and volume, larger neural networks are required.

class hydpy.models.dam.dam_model.Calc_SurfaceArea_V1[source]

Bases: hydpy.core.modeltools.Method

Determine the surface area based on an artificial neural network describing the relationship between water level and water stage.

Requires the control parameter:

WaterVolume2WaterLevel

Requires the state sequence:

WaterVolume

Calculates the aide sequence:

SurfaceArea

Basic equation:

\(SurfaceArea = \frac{dWaterVolume}{WaterLevel}\)

Example:

Method Calc_SurfaceArea_V1 relies on the identical neural network as method Calc_WaterLevel_V1. Therefore, we reuse the same network configuration as in the documentation on method Calc_WaterLevel_V1, but calculate SurfaceArea instead of WaterLevel:

>>> from hydpy.models.dam import *
>>> parameterstep()
>>> watervolume2waterlevel(
...         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 Mio. m³:

>>> from hydpy import NumericalDifferentiator, round_
>>> numdiff = NumericalDifferentiator(
...     xsequence=states.watervolume,
...     ysequences=[aides.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_AllowedRemoteRelieve_V2[source]

Bases: hydpy.core.modeltools.Method

Calculate the allowed maximum relieve another location is allowed to discharge into the dam.

Requires the control parameters:

HighestRemoteRelieve WaterLevelRelieveThreshold

Requires the derived parameters:

TOY WaterLevelRelieveSmoothPar

Requires the aide sequence:

WaterLevel

Calculates the flux sequence:

AllowedRemoteRelieve

Used auxiliary method:

smooth_logistic1()

Basic equation:

\(ActualRemoteRelieve = HighestRemoteRelieve \cdot smooth_{logistic1}(WaterLevelRelieveThreshold-WaterLevel, WaterLevelRelieveSmoothPar)\)

Examples:

All control parameters that are involved in the calculation of AllowedRemoteRelieve are derived from SeasonalParameter. This allows to simulate seasonal dam control schemes. To show how this works, we first define a short simulation time period of only two days:

>>> from hydpy import pub
>>> pub.timegrids = "2001.03.30", "2001.04.03", "1d"

Now 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()
>>> highestremoterelieve(_11_1_12=1.0, _03_31_12=1.0,
...                      _04_1_12=2.0, _10_31_12=2.0)
>>> waterlevelrelievethreshold(_11_1_12=3.0, _03_31_12=2.0,
...                            _04_1_12=4.0, _10_31_12=4.0)
>>> waterlevelrelievetolerance(_11_1_12=0.0, _03_31_12=0.0,
...                            _04_1_12=1.0, _10_31_12=1.0)
>>> derived.waterlevelrelievesmoothpar.update()
>>> derived.toy.update()

The following test function is supposed to calculate AllowedRemoteRelieve for values of WaterLevel ranging from 0 and 8 m:

>>> from hydpy import UnitTest
>>> test = UnitTest(model,
...                 model.calc_allowedremoterelieve_v2,
...                 last_example=9,
...                 parseqs=(aides.waterlevel,
...                          fluxes.allowedremoterelieve))
>>> 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 WaterLevelRelieveSmoothPar is zero. Hence, AllowedRemoteRelieve drops abruptly from 1 m³/s (the value of HighestRemoteRelieve) to 0 m³/s, as soon as WaterLevel reaches 3 m (the value of WaterLevelRelieveThreshold):

>>> model.idx_sim = pub.timegrids.init["2001.03.30"]
>>> test(first_example=2, last_example=6)
| ex. | waterlevel | allowedremoterelieve |
-------------------------------------------
|   3 |        1.0 |                  1.0 |
|   4 |        2.0 |                  1.0 |
|   5 |        3.0 |                  0.0 |
|   6 |        4.0 |                  0.0 |

On April 1 (which is the first day of the sommer month and the last day of the simulation period), all parameter values are increased. The value of parameter WaterLevelRelieveSmoothPar is 1 m. Hence, loosely speaking, AllowedRemoteRelieve approaches the “discontinuous extremes (2 m³/s – which is the value of HighestRemoteRelieve – and 0 m³/s) to 99 % within a span of 2 m³/s around the original threshold value of 4 m³/s defined by WaterLevelRelieveThreshold:

>>> model.idx_sim = pub.timegrids.init["2001.04.01"]
>>> test()
| ex. | waterlevel | allowedremoterelieve |
-------------------------------------------
|   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: hydpy.core.modeltools.Method

Calculate the required maximum supply from another location that can be discharged into the dam.

Requires the control parameters:

HighestRemoteSupply WaterLevelSupplyThreshold

Requires the derived parameters:

TOY WaterLevelSupplySmoothPar

Requires the aide sequence:

WaterLevel

Calculates the flux sequence:

RequiredRemoteSupply

Used auxiliary method:

smooth_logistic1()

Basic equation:

\(RequiredRemoteSupply = HighestRemoteSupply \cdot smooth_{logistic1}(WaterLevelSupplyThreshold-WaterLevel, WaterLevelSupplySmoothPar)\)

Examples:

Method Calc_RequiredRemoteSupply_V1 is functionally identical with method Calc_AllowedRemoteRelieve_V2. Hence the following examples serve for testing purposes only (see the documentation on function Calc_AllowedRemoteRelieve_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=(aides.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: hydpy.core.modeltools.Method

Try to estimate the natural discharge of a cross section far downstream based on the last few simulation steps.

Requires the control parameter:

NmbLogEntries

Requires the log sequences:

LoggedTotalRemoteDischarge LoggedOutflow

Calculates the flux sequence:

NaturalRemoteDischarge

Basic equation:

\(RemoteDemand = max(\frac{\Sigma(LoggedTotalRemoteDischarge - LoggedOutflow)} {NmbLogEntries}), 0)\)

Examples:

Usually, the mean total remote flow should be larger than the mean dam outflows. Then the estimated natural remote discharge is simply the difference of both mean values:

>>> 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 mights sometimes be negative. To avoid negative estimates of natural discharge, it its value is set 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: hydpy.core.modeltools.Method

Estimate the discharge demand of a cross section far downstream.

Requires the control parameter:

RemoteDischargeMinimum

Requires the derived parameter:

TOY

Requires the flux sequence:

NaturalRemoteDischarge

Calculates the flux sequence:

RemoteDemand

Basic equation:

\(RemoteDemand = max(RemoteDischargeMinimum - NaturalRemoteDischarge, 0\)

Examples:

Low water elevation is often restricted to specific month of the year. Sometimes the pursued lowest discharge value varies over the year to allow for a low flow variability that is in some agreement with the natural flow regime. The HydPy-Dam model supports such variations. Hence we define a short simulation time period first. This enables us to show how the related parameters values can be defined and how the calculation of the remote water demand throughout the year actually 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: hydpy.core.modeltools.Method

Estimate the shortfall of actual discharge under the required discharge of a cross section far downstream.

Requires the control parameters:

NmbLogEntries RemoteDischargeMinimum

Requires the derived parameter:

TOY

Requires the log sequence:

LoggedTotalRemoteDischarge

Calculates the flux sequence:

RemoteFailure

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: hydpy.core.modeltools.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:

RemoteDischargeSafety

Requires the derived parameters:

TOY RemoteDischargeSmoothPar

Requires the flux sequences:

RemoteDemand RemoteFailure

Calculates the flux sequence:

RequiredRemoteRelease

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: hydpy.core.modeltools.Method

Get the required remote release of the last simulation step.

Requires the log sequence:

LoggedRequiredRemoteRelease

Calculates the flux sequence:

RequiredRemoteRelease

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_AllowedRemoteRelieve_V1[source]

Bases: hydpy.core.modeltools.Method

Get the allowed remote relieve of the last simulation step.

Requires the log sequence:

LoggedAllowedRemoteRelieve

Calculates the flux sequence:

AllowedRemoteRelieve

Basic equation:

\(AllowedRemoteRelieve = LoggedAllowedRemoteRelieve\)

Example:

>>> from hydpy.models.dam import *
>>> parameterstep()
>>> logs.loggedallowedremoterelieve = 2.0
>>> model.calc_allowedremoterelieve_v1()
>>> fluxes.allowedremoterelieve
allowedremoterelieve(2.0)
class hydpy.models.dam.dam_model.Calc_RequiredRelease_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the total water release (immediately and far downstream) required for reducing drought events.

Requires the control parameter:

NearDischargeMinimumThreshold

Requires the derived parameters:

TOY NearDischargeMinimumSmoothPar2

Requires the flux sequence:

RequiredRemoteRelease

Calculates the flux sequence:

RequiredRelease

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: hydpy.core.modeltools.Method

Calculate the water release (immediately downstream) required for reducing drought events.

Requires the control parameter:

NearDischargeMinimumThreshold

Requires the derived parameter:

TOY

Calculates the flux sequence:

RequiredRelease

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_PossibleRemoteRelieve_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the highest possible water release that can be routed to a remote location based on an artificial neural network describing the relationship between possible release and water stage.

Requires the control parameter:

WaterLevel2PossibleRemoteRelieve

Requires the aide sequence:

WaterLevel

Calculates the flux sequence:

PossibleRemoteRelieve

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()
>>> waterlevel2possibleremoterelieve(
...     nmb_inputs=1,
...     nmb_neurons=(2,),
...     nmb_outputs=1,
...     weights_input=[[50., 4]],
...     weights_output=[[2.], [30]],
...     intercepts_hidden=[[-13000, -1046]],
...     intercepts_output=[0.])
>>> from hydpy import UnitTest
>>> test = UnitTest(
...     model, model.calc_possibleremoterelieve_v1,
...     last_example=21,
...     parseqs=(aides.waterlevel, fluxes.possibleremoterelieve))
>>> test.nexts.waterlevel = numpy.arange(257, 261.1, 0.2)
>>> test()
| ex. | waterlevel | possibleremoterelieve |
--------------------------------------------
|   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: hydpy.core.modeltools.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 the dam models rely on smooth_min1() but should never return negative values. Therefore, methods Fix_Min1_V1 modifies smooth_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_ActualRemoteRelieve_V1 (implementing a “relative” smoother approach), which explains the strategy behind method Fix_Min1_V1 in depths. The documentation on method Update_ActualRemoteRelieve_V1 provides test calculation results for the “aboslute” smoother approach.

class hydpy.models.dam.dam_model.Calc_ActualRemoteRelieve_V1[source]

Bases: hydpy.core.modeltools.Method

Calculate the actual amount of water released to a remote location to relieve the dam during high flow conditions.

Requires the control parameter:

RemoteRelieveTolerance

Requires the flux sequences:

AllowedRemoteRelieve PossibleRemoteRelieve

Calculates the flux sequence:

ActualRemoteRelieve

Basic equation - discontinous:

\(ActualRemoteRelease = min(PossibleRemoteRelease, AllowedRemoteRelease)\)

Used additional method:

Fix_Min1_V1

Basic equation - continous:

\(ActualRemoteRelease = smooth_min1(PossibleRemoteRelease, AllowedRemoteRelease, RemoteRelieveTolerance)\)

Note that the given continous basic equation is a simplification of the complete algorithm to calculate ActualRemoteRelieve, which also makes use of smooth_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 PossibleRemoteRelieve ranging from -1 to 5 m³/s:

>>> from hydpy import UnitTest
>>> test = UnitTest(model, model.calc_actualremoterelieve_v1,
...                 last_example=7,
...                 parseqs=(fluxes.possibleremoterelieve,
...                          fluxes.actualremoterelieve))
>>> test.nexts.possibleremoterelieve = range(-1, 6)

We begin with a AllowedRemoteRelieve value of 3 m³/s:

>>> fluxes.allowedremoterelieve = 3.0

Through setting the value of RemoteRelieveTolerance to the lowest possible value, there is no smoothing. Instead, the relationship between ActualRemoteRelieve and PossibleRemoteRelieve follows the simple discontinous minimum function:

>>> remoterelievetolerance(0.0)
>>> test()
| ex. | possibleremoterelieve | actualremoterelieve |
-----------------------------------------------------
|   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 RemoteRelieveTolerance to a sensible value results in a moderate smoothing:

>>> remoterelievetolerance(0.2)
>>> test()
| ex. | possibleremoterelieve | actualremoterelieve |
-----------------------------------------------------
|   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 relieve does not fall below 0 m³/s:

>>> remoterelievetolerance(1.0)
>>> test()
| ex. | possibleremoterelieve | actualremoterelieve |
-----------------------------------------------------
|   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 relieve of only 0.03 m³/s instead of 3 m³/s:

>>> fluxes.allowedremoterelieve = 0.03
>>> test()
| ex. | possibleremoterelieve | actualremoterelieve |
-----------------------------------------------------
|   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 relieve of 3 m³/s. This points out, that the degree of smoothing is releative to the allowed relieve:

>>> import numpy
>>> test.nexts.possibleremoterelieve = numpy.arange(-0.01, 0.06, 0.01)
>>> test()
| ex. | possibleremoterelieve | actualremoterelieve |
-----------------------------------------------------
|   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 ActualRemoteRelieve and PossibleRemoteRelieve 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: hydpy.core.modeltools.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:

RestrictTargetedRelease NearDischargeMinimumThreshold

Requires the derived parameters:

NearDischargeMinimumSmoothPar1 TOY

Requires the flux sequences:

Inflow RequiredRelease

Calculates the flux sequence:

TargetedRelease

Some dams are supposed to maintain a certain degree of low flow variability downstream. In case parameter RestrictTargetedRelease is set to True, method Calc_TargetedRelease_V1 simulates this by (approximately) passing inflow as outflow whenever inflow is below the value of the threshold parameter NearDischargeMinimumThreshold. If parameter RestrictTargetedRelease is set to False, does nothing except assigning the value of sequence RequiredRelease to sequence TargetedRelease.

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 sequences RequiredRelease and TargetedRelease:

>>> 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: hydpy.core.modeltools.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:

WaterLevelMinimumThreshold

Requires the derived parameter:

WaterLevelMinimumSmoothPar

Requires the flux sequence:

TargetedRelease

Requires the aide sequence:

WaterLevel

Calculates the flux sequence:

ActualRelease

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=(aides.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.)
>>> waterlevelminimumtolerance(1.)
>>> 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.)
>>> waterlevelminimumtolerance(2.)
>>> 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: hydpy.core.modeltools.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:

AllowedRelease WaterLevelMinimumThreshold

Requires the derived parameters:

TOY WaterLevelMinimumSmoothPar

Requires the aide sequence:

WaterLevel

Calculates the flux sequence:

ActualRelease

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=(aides.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: hydpy.core.modeltools.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:

Inflow

Requires the state sequence:

WaterVolume

Requires the aide sequence:

AllowedDischarge

Calculates the flux sequence:

ActualRelease

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 model dam_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: hydpy.core.modeltools.Method

Calculate the portion of the required remote demand that could not be met by the actual discharge release.

Requires the flux sequences:

ActualRelease RequiredRemoteRelease

Calculates the flux sequence:

MissingRemoteRelease

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: hydpy.core.modeltools.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:

WaterLevelMinimumRemoteThreshold

Requires the derived parameter:

WaterLevelMinimumRemoteSmoothPar

Requires the flux sequence:

RequiredRemoteRelease

Requires the aide sequence:

WaterLevel

Calculates the flux sequence:

ActualRemoteRelease

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 method Calc_ActualRelease_V1. This is why we omit to explain the following examples, as they are just repetitions of the ones of method Calc_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=(aides.waterlevel,
...                          fluxes.actualremoterelease))
>>> test.nexts.waterlevel = range(-1, 6)

Recalculation of example 1

>>> 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 |

Recalculation of example 2

>>> 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 |

Recalculation of example 3

>>> 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_ActualRemoteRelieve_V1[source]

Bases: hydpy.core.modeltools.Method

Constrain the actual relieve discharge to a remote location.

Requires the control parameter:

HighestRemoteDischarge

Requires the derived parameter:

HighestRemoteSmoothPar

Updates the flux sequence:

ActualRemoteRelieve

Used additional method:

Fix_Min1_V1

Basic equation - discontinous:

\(ActualRemoteRelieve = min(ActualRemoteRelease, HighestRemoteDischarge)\)

Basic equation - continous:

\(ActualRemoteRelieve = smooth_min1(ActualRemoteRelieve, HighestRemoteDischarge, HighestRemoteSmoothPar)\)

Examples:

Prepare a dam model:

>>> from hydpy.models.dam import *
>>> parameterstep()

Prepare a test function object that performs eight examples with ActualRemoteRelieve ranging from 0 to 8 m³/s and a fixed initial value of parameter HighestRemoteDischarge of 4 m³/s:

>>> highestremotedischarge(4.0)
>>> from hydpy import UnitTest
>>> test = UnitTest(model,
...                 model.update_actualremoterelieve_v1,
...                 last_example=8,
...                 parseqs=(fluxes.actualremoterelieve,))
>>> test.nexts.actualremoterelieve = 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. | actualremoterelieve |
-----------------------------
|   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. | actualremoterelieve |
-----------------------------
|   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: hydpy.core.modeltools.Method

Constrain the actual release (supply discharge) to a remote location.

Requires the control parameter:

HighestRemoteDischarge

Requires the derived parameter:

HighestRemoteSmoothPar

Requires the flux sequence:

ActualRemoteRelieve

Updates the flux sequence:

ActualRemoteRelease

Used additional method:

Fix_Min1_V1

Basic equation - discontinous:

\(ActualRemoteRelease = min(ActualRemoteRelease, HighestRemoteDischarge-ActualRemoteRelieve)\)

Basic equation - continous:

\(ActualRemoteRelease = smooth_min1(ActualRemoteRelease, HighestRemoteDischarge-ActualRemoteRelieve, HighestRemoteSmoothPar)\)

Examples:

Prepare a dam model:

>>> from hydpy.models.dam import *
>>> parameterstep()

Prepare a test function object that performs eight examples with ActualRemoteRelieve ranging from 0 to 8 m³/s and a fixed initial value of parameter ActualRemoteRelease of 2 m³/s:

>>> from hydpy import UnitTest
>>> test = UnitTest(model,
...                 model.update_actualremoterelease_v1,
...                 last_example=8,
...                 parseqs=(fluxes.actualremoterelieve,
...                          fluxes.actualremoterelease))
>>> test.nexts.actualremoterelieve = 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. | actualremoterelieve | 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 larger ActualRemoteRelease values). Instead of smoothing the maximum function as well, ActualRemoteRelease is exactly 0 m³/s for a ActualRemoteRelieve value of 6 m³/s (within the shown precision). The remaining discontinuity does not pose a problem, as long ActualRemoteRelieve does not exceed the value of HighestRemoteDischarge. (Application models using method Update_ActualRemoteRelease_V1 should generally enforce this restriction). In case of exceedance, extended computation times might occur:

>>> highestremotetolerance(0.1)
>>> derived.highestremotesmoothpar.update()
>>> test()
| ex. | actualremoterelieve | 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: hydpy.core.modeltools.Method

Calculate the discharge during and after a flood event based on an SeasonalANN describing the relationship(s) between discharge and water stage.

Requires the control parameter:

WaterLevel2FloodDischarge

Requires the derived parameter:

TOY

Requires the aide sequence:

WaterLevel

Calculates the flux sequence:

FloodDischarge

Example:

The control parameter WaterLevel2FloodDischarge is derived from SeasonalParameter. 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. 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., 4]],
...                     weights_output=[[2.], [30]],
...                     intercepts_hidden=[[-13000, -1046]],
...                     intercepts_output=[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=(aides.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: hydpy.core.modeltools.Method

Calculate the total outflow of the dam.

Requires the flux sequences:

ActualRelease FloodDischarge

Calculates the flux sequence:

Outflow

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: hydpy.core.modeltools.Method

Calculate the maximum discharge not leading to exceedance of the allowed water level drop.

Requires the control parameter:

AllowedWaterLevelDrop

Requires the derived parameter:

Seconds

Requires the flux sequence:

Inflow

Requires the aide sequence:

SurfaceArea

Calculates the aide sequence:

AllowedDischarge

Basic (discontinuous) equation:

\(Outflow = AllowedWaterLevelDrop \cdot SurfaceArea + Inflow\)

Example:

>>> from hydpy.models.dam import *
>>> parameterstep("1d")
>>> simulationstep("1h")
>>> allowedwaterleveldrop(0.1)
>>> derived.seconds.update()
>>> fluxes.inflow = 2.0
>>> aides.surfacearea = 0.864
>>> model.calc_alloweddischarge_v1()
>>> aides.alloweddischarge
alloweddischarge(3.0)
class hydpy.models.dam.dam_model.Calc_AllowedDischarge_V2[source]

Bases: hydpy.core.modeltools.Method

Calculate the maximum discharge not leading to exceedance of the allowed water level drop.

Requires the control parameters:

AllowedRelease AllowedWaterLevelDrop

Requires the derived parameters:

TOY Seconds DischargeSmoothPar

Requires the flux sequence:

Inflow

Requires the aide sequence:

SurfaceArea

Calculates the aide sequence:

AllowedDischarge

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: hydpy.core.modeltools.Method

Calculate the total outflow of the dam, taking the allowed water discharge into account.

Requires the derived parameter:

DischargeSmoothPar

Requires the flux sequence:

FloodDischarge

Requires the aide sequence:

AllowedDischarge

Calculates the flux sequence:

Outflow

Used additional method:

Fix_Min1_V1

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: hydpy.core.modeltools.Method

Update the actual water volume.

Requires the derived parameter:

Seconds

Requires the flux sequences:

Inflow Outflow

Updates the state sequence:

WaterVolume

Basic equation:

\(\frac{d}{dt}WaterVolume = 1e-6 \cdot (Inflow-Outflow)\)

Example:

>>> from hydpy.models.dam import *
>>> parameterstep()
>>> derived.seconds = 2e6
>>> states.watervolume.old = 5.0
>>> fluxes.inflow = 2.0
>>> fluxes.outflow = 3.0
>>> model.update_watervolume_v1()
>>> states.watervolume
watervolume(3.0)
class hydpy.models.dam.dam_model.Update_WaterVolume_V2[source]

Bases: hydpy.core.modeltools.Method

Update the actual water volume.

Requires the derived parameter:

Seconds

Requires the flux sequences:

Inflow Outflow ActualRemoteRelease

Updates the state sequence:

WaterVolume

Basic equation:

\(\frac{d}{dt}WaterVolume = 10^{-6} \cdot (Inflow-Outflow-ActualRemoteRelease)\)

Example:

>>> from hydpy.models.dam import *
>>> parameterstep()
>>> derived.seconds = 2e6
>>> states.watervolume.old = 5.0
>>> fluxes.inflow = 2.0
>>> fluxes.outflow = 3.0
>>> fluxes.actualremoterelease = 1.0
>>> model.update_watervolume_v2()
>>> states.watervolume
watervolume(1.0)
class hydpy.models.dam.dam_model.Update_WaterVolume_V3[source]

Bases: hydpy.core.modeltools.Method

Update the actual water volume.

Requires the derived parameter:

Seconds

Requires the flux sequences:

Inflow Outflow ActualRemoteRelease ActualRemoteRelieve

Updates the state sequence:

WaterVolume

Basic equation:

\(\frac{d}{dt}WaterVolume = 10^{-6} \cdot (Inflow-Outflow-ActualRemoteRelease-ActualRemoteRelieve)\)

Example:

>>> from hydpy.models.dam import *
>>> parameterstep()
>>> derived.seconds = 2e6
>>> states.watervolume.old = 5.0
>>> fluxes.inflow = 2.0
>>> fluxes.outflow = 3.0
>>> fluxes.actualremoterelease = 1.0
>>> fluxes.actualremoterelieve = 0.5
>>> model.update_watervolume_v3()
>>> states.watervolume
watervolume(0.0)
class hydpy.models.dam.dam_model.Pass_Outflow_V1[source]

Bases: hydpy.core.modeltools.Method

Update the outlet link sequence Q.

Requires the flux sequence:

Outflow

Calculates the outlet sequence:

Q

Basic equation:

\(Q = Outflow\)

class hydpy.models.dam.dam_model.Pass_ActualRemoteRelease_V1[source]

Bases: hydpy.core.modeltools.Method

Update the outlet link sequence S.

Requires the flux sequence:

ActualRemoteRelease

Calculates the outlet sequence:

S

Basic equation:

\(S = ActualRemoteRelease\)

class hydpy.models.dam.dam_model.Pass_ActualRemoteRelieve_V1[source]

Bases: hydpy.core.modeltools.Method

Update the outlet link sequence R.

Requires the flux sequence:

ActualRemoteRelieve

Calculates the outlet sequence:

R

Basic equation:

\(R = ActualRemoteRelieve\)

class hydpy.models.dam.dam_model.Pass_MissingRemoteRelease_V1[source]

Bases: hydpy.core.modeltools.Method

Update the outlet link sequence D.

Requires the flux sequence:

MissingRemoteRelease

Calculates the sender sequence:

D

Basic equation:

\(D = MissingRemoteRelease\)

class hydpy.models.dam.dam_model.Pass_AllowedRemoteRelieve_V1[source]

Bases: hydpy.core.modeltools.Method

Update the outlet link sequence R.

Requires the flux sequence:

AllowedRemoteRelieve

Calculates the sender sequence:

R

Basic equation:

\(R = AllowedRemoteRelieve\)

class hydpy.models.dam.dam_model.Pass_RequiredRemoteSupply_V1[source]

Bases: hydpy.core.modeltools.Method

Update the outlet link sequence S.

Requires the flux sequence:

RequiredRemoteSupply

Calculates the sender sequence:

S

Basic equation:

\(S = RequiredRemoteSupply\)

class hydpy.models.dam.dam_model.Update_LoggedOutflow_V1[source]

Bases: hydpy.core.modeltools.Method

Log a new entry of discharge at a cross section far downstream.

Requires the control parameter:

NmbLogEntries

Requires the flux sequence:

Outflow

Updates the log sequence:

LoggedOutflow

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: hydpy.core.parametertools.Parameters, cls_fastaccess: Optional[Type[hydpy.core.parametertools.FastAccessParameter]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

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

Control parameters of model dam.

The following classes are selected:
class hydpy.models.dam.dam_control.CatchmentArea(subvars: SubVariablesType)[source]

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

Size of the catchment draining into the dam [km²].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'catchmentarea'
unit: str = 'km²'
class hydpy.models.dam.dam_control.NmbLogEntries(subvars: SubVariablesType)[source]

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

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)
loggedrequiredremoterelease(nan)
loggedallowedremoterelieve(nan)
NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (1, None)
name: str = 'nmblogentries'
unit: str = '-'
class hydpy.models.dam.dam_control.RemoteDischargeMinimum(subvars)[source]

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

Discharge threshold of a cross section far downstream that should not be undercut by the actual discharge [m³/s].

Required by the methods:

Calc_RemoteDemand_V1 Calc_RemoteFailure_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'remotedischargeminimum'
unit: str = 'm³/s'
class hydpy.models.dam.dam_control.RemoteDischargeSafety(subvars)[source]

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

Safety factor to reduce the risk to release not enough water [m³/s].

Required by the method:

Calc_RequiredRemoteRelease_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'remotedischargesafety'
unit: str = 'm³/s'
class hydpy.models.dam.dam_control.WaterLevel2PossibleRemoteRelieve(subvars: hydpy.core.parametertools.SubParameters)[source]

Bases: hydpy.auxs.anntools.ANN

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:

Calc_PossibleRemoteRelieve_V1

XLABEL: str = 'water level [m]'
YLABEL: str = 'possible remote relieve [m³/s]'
name = 'waterlevel2possibleremoterelieve'
class hydpy.models.dam.dam_control.RemoteRelieveTolerance(subvars: SubVariablesType)[source]

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

A tolerance value for the “possible remote relieve” [m³/s].

Required by the method:

Calc_ActualRemoteRelieve_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'remoterelievetolerance'
unit: str = 'm³/s'
class hydpy.models.dam.dam_control.NearDischargeMinimumThreshold(subvars)[source]

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

Discharge threshold of a cross section in the near of the dam that not be undercut by the actual discharge [m³/s].

Required by the methods:

Calc_ActualRelease_V3 Calc_RequiredRelease_V1 Calc_RequiredRelease_V2 Calc_TargetedRelease_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'neardischargeminimumthreshold'
unit: str = 'm³/s'
class hydpy.models.dam.dam_control.NearDischargeMinimumTolerance(subvars)[source]

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

A tolerance value for the “near discharge minimum” [m³/s].

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'neardischargeminimumtolerance'
unit: str = 'm³/s'
class hydpy.models.dam.dam_control.RestrictTargetedRelease(subvars: SubVariablesType)[source]

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

A flag indicating whether low flow variability has to be preserved or not [-].

Required by the method:

Calc_TargetedRelease_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'restricttargetedrelease'
unit: str = '-'
class hydpy.models.dam.dam_control.WaterVolumeMinimumThreshold(subvars)[source]

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

The minimum operating water volume of the dam [million m³].

Required by the method:

Calc_ActualRelease_V3

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0, None)
name: str = 'watervolumeminimumthreshold'
unit: str = 'million m³'
class hydpy.models.dam.dam_control.WaterLevelMinimumThreshold(subvars: SubVariablesType)[source]

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

The minimum operating water level of the dam [m].

Required by the methods:

Calc_ActualRelease_V1 Calc_ActualRelease_V2

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0, None)
name: str = 'waterlevelminimumthreshold'
unit: str = 'm'
class hydpy.models.dam.dam_control.WaterLevelMinimumTolerance(subvars: SubVariablesType)[source]

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

A tolarance value for the minimum operating water level [m].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0, None)
name: str = 'waterlevelminimumtolerance'
unit: str = 'm'
class hydpy.models.dam.dam_control.WaterLevelMinimumRemoteThreshold(subvars: SubVariablesType)[source]

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

The minimum operating water level of the dam regarding remote water supply [m].

Required by the method:

Calc_ActualRemoteRelease_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0, None)
name: str = 'waterlevelminimumremotethreshold'
unit: str = 'm'
class hydpy.models.dam.dam_control.WaterLevelMinimumRemoteTolerance(subvars: SubVariablesType)[source]

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

A tolarance value for the minimum operating water level regarding remote water supply [m].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0, None)
name: str = 'waterlevelminimumremotetolerance'
unit: str = 'm'
class hydpy.models.dam.dam_control.HighestRemoteRelieve(subvars)[source]

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

The highest possible relieve discharge from another location [m³/s].

Required by the method:

Calc_AllowedRemoteRelieve_V2

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'highestremoterelieve'
unit: str = 'm³/s'
class hydpy.models.dam.dam_control.WaterLevelRelieveThreshold(subvars)[source]

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

The threshold water level of the dam regarding the allowed relieve discharge from another location [m].

Required by the method:

Calc_AllowedRemoteRelieve_V2

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'waterlevelrelievethreshold'
unit: str = 'm'
class hydpy.models.dam.dam_control.WaterLevelRelieveTolerance(subvars)[source]

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

A tolerance value for parameter WaterLevelRelieveThreshold [m].

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'waterlevelrelievetolerance'
unit: str = 'm'
class hydpy.models.dam.dam_control.HighestRemoteSupply(subvars)[source]

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

The highest possible supply discharge from another location [m³/s].

Required by the method:

Calc_RequiredRemoteSupply_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'highestremotesupply'
unit: str = 'm³/s'
class hydpy.models.dam.dam_control.WaterLevelSupplyThreshold(subvars)[source]

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

The threshold water level of the dam regarding the requried supply discharge from another location [m].

Required by the method:

Calc_RequiredRemoteSupply_V1

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'waterlevelsupplythreshold'
unit: str = 'm'
class hydpy.models.dam.dam_control.WaterLevelSupplyTolerance(subvars)[source]

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

A tolerance value for parameter WaterLevelSupplyThreshold [m].

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'waterlevelsupplytolerance'
unit: str = 'm'
class hydpy.models.dam.dam_control.HighestRemoteDischarge(subvars: SubVariablesType)[source]

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

The highest possible discharge between two remote locations [m³/s].

Required by the methods:

Update_ActualRemoteRelease_V1 Update_ActualRemoteRelieve_V1

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'highestremotedischarge'
unit: str = 'm³/s'
class hydpy.models.dam.dam_control.HighestRemoteTolerance(subvars: SubVariablesType)[source]

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

Smoothing parameter associated with HighestRemoteDischarge [m³/s].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'highestremotetolerance'
unit: str = 'm³/s'
class hydpy.models.dam.dam_control.WaterVolume2WaterLevel(subvars: hydpy.core.parametertools.SubParameters)[source]

Bases: hydpy.auxs.anntools.ANN

Artificial neural network describing the relationship between water level and water volume [-].

Required by the methods:

Calc_SurfaceArea_V1 Calc_WaterLevel_V1

XLABEL: str = 'water volume [million m³]'
YLABEL: str = 'water level [m]'
name = 'watervolume2waterlevel'
class hydpy.models.dam.dam_control.WaterLevel2FloodDischarge(subvars: hydpy.core.parametertools.SubParameters)[source]

Bases: hydpy.auxs.anntools.SeasonalANN

Artificial neural network describing the relationship between flood discharge and water volume [-].

Required by the method:

Calc_FloodDischarge_V1

XLABEL: str = 'water level [m]'
YLABEL: str = 'flood discharge [m³/s]'
name = 'waterlevel2flooddischarge'
class hydpy.models.dam.dam_control.AllowedWaterLevelDrop(subvars: SubVariablesType)[source]

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

The highest allowed water level decrease [m/T].

Required by the methods:

Calc_AllowedDischarge_V1 Calc_AllowedDischarge_V2

NDIM: int = 0
TYPE
TIME: Optional[bool] = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'allowedwaterleveldrop'
unit: str = 'm/T'
class hydpy.models.dam.dam_control.AllowedDischargeTolerance(subvars: SubVariablesType)[source]

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

Smoothing parameter eventually associated with AllowedWaterLevelDrop [m³/s].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'alloweddischargetolerance'
unit: str = 'm³/s'
class hydpy.models.dam.dam_control.AllowedRelease(subvars)[source]

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

The maximum water release not causing any harm downstream [m³/s].

Required by the methods:

Calc_ActualRelease_V2 Calc_AllowedDischarge_V2

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'allowedrelease'
unit: str = 'm³/s'
class hydpy.models.dam.dam_control.TargetVolume(subvars)[source]

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

The desired volume of water to be stored within the dam at specific times of the year [Mio. m³].

Required by the method:

Calc_ActualRelease_V3

NDIM: int = 1
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'targetvolume'
unit: str = 'Mio. m³'
class hydpy.models.dam.dam_control.TargetRangeAbsolute(subvars: SubVariablesType)[source]

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

The absolute interpolation range related to parameter TargetVolume [Mio. m³].

Required by the method:

Calc_ActualRelease_V3

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'targetrangeabsolute'
unit: str = 'Mio. m³'
class hydpy.models.dam.dam_control.TargetRangeRelative(subvars: SubVariablesType)[source]

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

The relative interpolation range related to parameter TargetVolume [-].

Required by the method:

Calc_ActualRelease_V3

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'targetrangerelative'
unit: str = '-'
class hydpy.models.dam.dam_control.VolumeTolerance(subvars: SubVariablesType)[source]

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

Smoothing parameter for volume related smoothing operations [Mio. m³].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'volumetolerance'
unit: str = 'Mio. m³'
class hydpy.models.dam.dam_control.DischargeTolerance(subvars: SubVariablesType)[source]

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

Smoothing parameter for discharge related smoothing operations [m³/s].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
name: str = 'dischargetolerance'
unit: str = 'm³/s'

Derived parameters

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

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

Derived parameters of model dam.

The following classes are selected:
class hydpy.models.dam.dam_derived.TOY(subvars: SubVariablesType)[source]

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

References the timeofyear index array provided by the instance of class Indexer available in module pub. [-].

Required by the methods:

Calc_ActualRelease_V2 Calc_ActualRelease_V3 Calc_AllowedDischarge_V2 Calc_AllowedRemoteRelieve_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

name: str = 'toy'
unit: str = '-'
class hydpy.models.dam.dam_derived.Seconds(subvars: SubVariablesType)[source]

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

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

Required by the methods:

Calc_AllowedDischarge_V1 Calc_AllowedDischarge_V2 Update_WaterVolume_V1 Update_WaterVolume_V2 Update_WaterVolume_V3

name: str = 'seconds'
unit: str = 's'
class hydpy.models.dam.dam_derived.RemoteDischargeSmoothPar(subvars: SubVariablesType)[source]

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

Smoothing parameter to be derived from RemoteDischargeSafety [m³/s].

Required by the method:

Calc_RequiredRemoteRelease_V1

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

Calculate the smoothing parameter values.

The following example is explained in some detail in module smoothtools:

>>> 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
name: str = 'remotedischargesmoothpar'
unit: str = 'm³/s'
class hydpy.models.dam.dam_derived.NearDischargeMinimumSmoothPar1(subvars: SubVariablesType)[source]

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

Smoothing parameter to be derived from NearDischargeMinimumThreshold for smoothing kernel smooth_logistic1() [m³/s].

Required by the method:

Calc_TargetedRelease_V1

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

Calculate the smoothing parameter values.

The following example is explained in some detail in module smoothtools:

>>> 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
name: str = 'neardischargeminimumsmoothpar1'
unit: str = 'm³/s'
class hydpy.models.dam.dam_derived.NearDischargeMinimumSmoothPar2(subvars: SubVariablesType)[source]

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

Smoothing parameter to be derived from NearDischargeMinimumThreshold for smoothing kernel smooth_logistic2() [m³/s].

Required by the method:

Calc_RequiredRelease_V1

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

Calculate the smoothing parameter values.

The following example is explained in some detail in module smoothtools:

>>> 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
name: str = 'neardischargeminimumsmoothpar2'
unit: str = 'm³/s'
class hydpy.models.dam.dam_derived.WaterLevelMinimumSmoothPar(subvars: SubVariablesType)[source]

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

Smoothing parameter to be derived from WaterLevelMinimumTolerance for smoothing kernel smooth_logistic1() [m].

Required by the methods:

Calc_ActualRelease_V1 Calc_ActualRelease_V2

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

Calculate the smoothing parameter value.

The following example is explained in some detail in module smoothtools:

>>> 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
name: str = 'waterlevelminimumsmoothpar'
unit: str = 'm'
class hydpy.models.dam.dam_derived.WaterLevelMinimumRemoteSmoothPar(subvars: SubVariablesType)[source]

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

Smoothing parameter to be derived from WaterLevelMinimumRemoteTolerance [m].

Required by the method:

Calc_ActualRemoteRelease_V1

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

Calculate the smoothing parameter value.

The following example is explained in some detail in module smoothtools:

>>> 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
name: str = 'waterlevelminimumremotesmoothpar'
unit: str = 'm'
class hydpy.models.dam.dam_derived.WaterLevelRelieveSmoothPar(subvars: SubVariablesType)[source]

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

Smoothing parameter to be derived from WaterLevelRelieveTolerance for smoothing kernel smooth_logistic1() [m³/s].

Required by the method:

Calc_AllowedRemoteRelieve_V2

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

Calculate the smoothing parameter values.

The following example is explained in some detail in module smoothtools:

>>> from hydpy import pub
>>> pub.timegrids = "2000.01.01", "2000.01.03", "1d"
>>> from hydpy.models.dam import *
>>> parameterstep()
>>> waterlevelrelievetolerance(0.0)
>>> waterlevelrelievetolerance.values[1] = 2.5
>>> derived.waterlevelrelievesmoothpar.update()
>>> from hydpy.cythons.smoothutils import smooth_logistic1
>>> from hydpy import round_
>>> round_(smooth_logistic1(
...     1.0, derived.waterlevelrelievesmoothpar[0]))
1.0
>>> round_(smooth_logistic1(
...     2.5, derived.waterlevelrelievesmoothpar[1]))
0.99
name: str = 'waterlevelrelievesmoothpar'
unit: str = 'm³/s'
class hydpy.models.dam.dam_derived.WaterLevelSupplySmoothPar(subvars: SubVariablesType)[source]

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

Smoothing parameter to be derived from WaterLevelSupplyTolerance for smoothing kernel smooth_logistic1() [m³/s].

Required by the method:

Calc_RequiredRemoteSupply_V1

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

Calculate the smoothing parameter values.

The following example is explained in some detail in module smoothtools:

>>> 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
name: str = 'waterlevelsupplysmoothpar'
unit: str = 'm³/s'
class hydpy.models.dam.dam_derived.HighestRemoteSmoothPar(subvars: SubVariablesType)[source]

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

Smoothing parameter to be derived from HighestRemoteTolerance for smoothing kernel smooth_min1() [m³/s].

Required by the methods:

Update_ActualRemoteRelease_V1 Update_ActualRemoteRelieve_V1

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

Calculate the smoothing parameter value.

The following example is explained in some detail in module smoothtools:

>>> 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 example on function calc_smoothpar_min1(), due to the value of parameter HighestRemoteDischarge being 1 m³/s. Doubling the value of HighestRemoteDischarge also doubles the value of HighestRemoteSmoothPar proportional. This leads 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 and HighestRemoteSmoothPar prevents from any smoothing when the value of HighestRemoteDischarge is zero:

>>> highestremotedischarge(0.0)
>>> derived.highestremotesmoothpar.update()
>>> round_(smooth_min1(1.0, 1.0, derived.highestremotesmoothpar))
1.0

In addition, HighestRemoteSmoothPar is set to zero if HighestRemoteDischarge is infinity (because no actual value will ever come in the vicinit of infinity), which is why no value would be changed through smoothing anyway):

>>> highestremotedischarge(inf)
>>> derived.highestremotesmoothpar.update()
>>> round_(smooth_min1(1.0, 1.0, derived.highestremotesmoothpar))
1.0
name: str = 'highestremotesmoothpar'
unit: str = 'm³/s'
class hydpy.models.dam.dam_derived.VolumeSmoothParLog1(subvars: SubVariablesType)[source]

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

Smoothing parameter to be derived from VolumeTolerance for smoothing kernel smooth_logistic1() [Mio. m³].

Required by the method:

Calc_ActualRelease_V3

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

Calculate the smoothing parameter value.

The following example is explained in some detail in module smoothtools:

>>> 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
name: str = 'volumesmoothparlog1'
unit: str = 'Mio. m³'
class hydpy.models.dam.dam_derived.VolumeSmoothParLog2(subvars: SubVariablesType)[source]

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

Smoothing parameter to be derived from VolumeTolerance for smoothing kernel smooth_logistic2() [Mio. m³].

Required by the method:

Calc_ActualRelease_V3

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

Calculate the smoothing parameter value.

The following example is explained in some detail in module smoothtools:

>>> 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
name: str = 'volumesmoothparlog2'
unit: str = 'Mio. m³'
class hydpy.models.dam.dam_derived.DischargeSmoothPar(subvars: SubVariablesType)[source]

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

Smoothing parameter to be derived from DischargeTolerance for smoothing kernels smooth_min1() and smooth_max1() [m³/s].

Required by the methods:

Calc_ActualRelease_V3 Calc_AllowedDischarge_V2 Calc_Outflow_V2

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

Calculate the smoothing parameter value.

The following example is explained in some detail in module smoothtools:

>>> 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
name: str = 'dischargesmoothpar'
unit: str = 'm³/s'

Solver parameters

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

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

Solver parameters of model dam.

The following classes are selected:
  • AbsErrorMax() Absolute numerical error tolerance [m3/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: hydpy.core.variabletools.Variable[hydpy.core.parametertools.SubParameters, hydpy.core.parametertools.FastAccessParameter]

Absolute numerical error tolerance [m3/s].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool] = 0.01
modify_init()[source]

“”Adjust and return the value of class constant INIT.

Note that the default initial value 0.01 refers to mm and the actual simulation step size. Hence the actual default initial value in m³/s is:

\(AbsErrorMax = 0.01 \cdot CatchmentArea \cdot 1000 / Seconds\)

>>> from hydpy.models.dam import *
>>> parameterstep("1d")
>>> simulationstep("1h")
>>> solver.abserrormax.INIT
0.01
>>> catchmentarea(2.0)
>>> derived.seconds.update()
>>> from hydpy import round_
>>> round_(solver.abserrormax.modify_init())
0.005556
name: str = 'abserrormax'
unit: str = 'm3/s'
class hydpy.models.dam.dam_solver.RelErrorMax(subvars)[source]

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

Relative numerical error tolerance [1/T].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, None)
INIT: Union[int, float, bool] = nan
name: str = 'relerrormax'
unit: str = '1/T'
class hydpy.models.dam.dam_solver.RelDTMin(subvars)[source]

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

Smallest relative integration time step size allowed [-].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
INIT: Union[int, float, bool] = 0.001
name: str = 'reldtmin'
unit: str = '-'
class hydpy.models.dam.dam_solver.RelDTMax(subvars)[source]

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

Largest relative integration time step size allowed [-].

NDIM: int = 0
TYPE
TIME: Optional[bool] = None
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (0.0, 1.0)
INIT: Union[int, float, bool] = 1.0
name: str = 'reldtmax'
unit: str = '-'

Sequence Features

Flux sequences

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

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

Flux sequences of model dam.

The following classes are selected:
  • Inflow() Total inflow [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 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 to the desired degree [m³/s].

  • AllowedRemoteRelieve() Allowed water release to relieve a dam during high flow conditions [m³/s].

  • RequiredRemoteSupply() Required water supply, e.g. to fill a dam during low water conditions [m³/s].

  • PossibleRemoteRelieve() Maximum possible water release to a remote location to relieve the dam during high flow conditions [m³/s].

  • ActualRemoteRelieve() 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 that could not be 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.Inflow(subvars: SubVariablesType)[source]

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

Total inflow [m³/s].

Calculated by the methods:

Pic_Inflow_V1 Pic_Inflow_V2

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

NDIM: int = 0
NUMERIC: bool = True
name: str = 'inflow'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.TotalRemoteDischarge(subvars: SubVariablesType)[source]

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

Total discharge at a cross section far downstream [m³/s].

Calculated by the method:

Pic_TotalRemoteDischarge_V1

Required by the method:

Update_LoggedTotalRemoteDischarge_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'totalremotedischarge'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.NaturalRemoteDischarge(subvars: SubVariablesType)[source]

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

Natural discharge at a cross section far downstream [m³/s].

Calculated by the method:

Calc_NaturalRemoteDischarge_V1

Required by the method:

Calc_RemoteDemand_V1

Natural means: without the water released by the dam.

NDIM: int = 0
NUMERIC: bool = False
name: str = 'naturalremotedischarge'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.RemoteDemand(subvars: SubVariablesType)[source]

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

Discharge demand at a cross section far downstream [m³/s].

Calculated by the method:

Calc_RemoteDemand_V1

Required by the method:

Calc_RequiredRemoteRelease_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'remotedemand'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.RemoteFailure(subvars: SubVariablesType)[source]

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

Difference between the the actual and the required discharge at a cross section far downstream [m³/s].

Calculated by the method:

Calc_RemoteFailure_V1

Required by the method:

Calc_RequiredRemoteRelease_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'remotefailure'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.RequiredRemoteRelease(subvars: SubVariablesType)[source]

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

Water release considered appropriate to reduce drought events at cross sections far downstream to the desired degree [m³/s].

Calculated by the methods:

Calc_RequiredRemoteRelease_V1 Calc_RequiredRemoteRelease_V2

Required by the methods:

Calc_ActualRemoteRelease_V1 Calc_MissingRemoteRelease_V1 Calc_RequiredRelease_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'requiredremoterelease'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.AllowedRemoteRelieve(subvars: SubVariablesType)[source]

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

Allowed water release to relieve a dam during high flow conditions [m³/s].

Calculated by the methods:

Calc_AllowedRemoteRelieve_V1 Calc_AllowedRemoteRelieve_V2

Required by the methods:

Calc_ActualRemoteRelieve_V1 Pass_AllowedRemoteRelieve_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'allowedremoterelieve'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.RequiredRemoteSupply(subvars: SubVariablesType)[source]

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

Required water supply, e.g. to fill a dam during low water conditions [m³/s].

Calculated by the method:

Calc_RequiredRemoteSupply_V1

Required by the method:

Pass_RequiredRemoteSupply_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'requiredremotesupply'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.PossibleRemoteRelieve(subvars: SubVariablesType)[source]

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

Maximum possible water release to a remote location to relieve the dam during high flow conditions [m³/s].

Calculated by the method:

Calc_PossibleRemoteRelieve_V1

Required by the method:

Calc_ActualRemoteRelieve_V1

NDIM: int = 0
NUMERIC: bool = True
name: str = 'possibleremoterelieve'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.ActualRemoteRelieve(subvars: SubVariablesType)[source]

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

Actual water release to a remote location to relieve the dam during high flow conditions [m³/s].

Calculated by the method:

Calc_ActualRemoteRelieve_V1

Updated by the method:

Update_ActualRemoteRelieve_V1

Required by the methods:

Pass_ActualRemoteRelieve_V1 Update_ActualRemoteRelease_V1 Update_WaterVolume_V3

NDIM: int = 0
NUMERIC: bool = True
name: str = 'actualremoterelieve'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.RequiredRelease(subvars: SubVariablesType)[source]

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

Required water release for reducing drought events downstream [m³/s].

Calculated by the methods:

Calc_RequiredRelease_V1 Calc_RequiredRelease_V2

Required by the method:

Calc_TargetedRelease_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'requiredrelease'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.TargetedRelease(subvars: SubVariablesType)[source]

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

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:

Calc_TargetedRelease_V1

Required by the method:

Calc_ActualRelease_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'targetedrelease'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.ActualRelease(subvars: SubVariablesType)[source]

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

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:

Calc_MissingRemoteRelease_V1 Calc_Outflow_V1

NDIM: int = 0
NUMERIC: bool = True
name: str = 'actualrelease'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.MissingRemoteRelease(subvars: SubVariablesType)[source]

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

Amount of the required remote demand that could not be met by the actual release [m³/s].

Calculated by the method:

Calc_MissingRemoteRelease_V1

Required by the method:

Pass_MissingRemoteRelease_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'missingremoterelease'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.ActualRemoteRelease(subvars: SubVariablesType)[source]

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

Actual water release thought for arbitrary “remote” purposes [m³/s].

Calculated by the method:

Calc_ActualRemoteRelease_V1

Updated by the method:

Update_ActualRemoteRelease_V1

Required by the methods:

Pass_ActualRemoteRelease_V1 Update_WaterVolume_V2 Update_WaterVolume_V3

NDIM: int = 0
NUMERIC: bool = True
name: str = 'actualremoterelease'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.FloodDischarge(subvars: SubVariablesType)[source]

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

Water release associated with flood events [m³/s].

Calculated by the method:

Calc_FloodDischarge_V1

Required by the methods:

Calc_Outflow_V1 Calc_Outflow_V2

NDIM: int = 0
NUMERIC: bool = True
name: str = 'flooddischarge'
unit: str = 'm³/s'
class hydpy.models.dam.dam_fluxes.Outflow(subvars: SubVariablesType)[source]

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

Total outflow [m³/s].

Calculated by the methods:

Calc_Outflow_V1 Calc_Outflow_V2

Required by the methods:

Pass_Outflow_V1 Update_LoggedOutflow_V1 Update_WaterVolume_V1 Update_WaterVolume_V2 Update_WaterVolume_V3

NDIM: int = 0
NUMERIC: bool = True
name: str = 'outflow'
unit: str = 'm³/s'

State sequences

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

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

State sequences of model dam.

The following classes are selected:
class hydpy.models.dam.dam_states.WaterVolume(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.OutputSequence[hydpy.core.sequencetools.StateSequences], hydpy.core.sequencetools.ConditionSequence[hydpy.core.sequencetools.StateSequences, hydpy.core.sequencetools.FastAccessOutputSequence]

Water volume [million m³].

Updated by the methods:

Update_WaterVolume_V1 Update_WaterVolume_V2 Update_WaterVolume_V3

Required by the methods:

Calc_ActualRelease_V3 Calc_SurfaceArea_V1 Calc_WaterLevel_V1

NDIM: int = 0
NUMERIC: bool = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'watervolume'
unit: str = 'million m³'

Log sequences

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

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

Log sequences of model dam.

The following classes are selected:
class hydpy.models.dam.dam_logs.LoggedTotalRemoteDischarge(subvars: SubVariablesType)[source]

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

Logged discharge values from somewhere else [m3/s].

Updated by the method:

Update_LoggedTotalRemoteDischarge_V1

Required by the methods:

Calc_NaturalRemoteDischarge_V1 Calc_RemoteFailure_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedtotalremotedischarge'
unit: str = 'm3/s'
class hydpy.models.dam.dam_logs.LoggedOutflow(subvars: SubVariablesType)[source]

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

Logged discharge values from the dam itself [m3/s].

Updated by the method:

Update_LoggedOutflow_V1

Required by the method:

Calc_NaturalRemoteDischarge_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedoutflow'
unit: str = 'm3/s'
class hydpy.models.dam.dam_logs.ShapeOne(subvars: SubVariablesType)[source]

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

Base class for log sequences with a shape of one.

property shape

Parameter derived from ShapeOne are generally initialised with a shape of one.

We take parameter LoggedRequiredRemoteRelease as an example:

>>> from hydpy.models.dam import *
>>> parameterstep()
>>> logs.loggedrequiredremoterelease.shape
(1,)

Trying to set a new shape results in the following exceptions:

>>> logs.loggedrequiredremoterelease.shape = 2
Traceback (most recent call last):
...
AttributeError: The shape of parameter `loggedrequiredremoterelease` cannot be changed, but this was attempted for element `?`.

See the documentation on property shape of class Variable for further information.

name: str = 'shapeone'
unit: str = '?'
class hydpy.models.dam.dam_logs.LoggedRequiredRemoteRelease(subvars: SubVariablesType)[source]

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

Logged required discharge values computed by another model [m3/s].

Calculated by the methods:

Pic_LoggedRequiredRemoteRelease_V1 Pic_LoggedRequiredRemoteRelease_V2

Required by the method:

Calc_RequiredRemoteRelease_V2

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedrequiredremoterelease'
unit: str = 'm3/s'
subvars: SubVariablesType
class hydpy.models.dam.dam_logs.LoggedAllowedRemoteRelieve(subvars: SubVariablesType)[source]

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

Logged allowed discharge values computed by another model [m3/s].

Calculated by the method:

Pic_LoggedAllowedRemoteRelieve_V1

Required by the method:

Calc_AllowedRemoteRelieve_V1

NDIM: int = 1
NUMERIC: bool = False
name: str = 'loggedallowedremoterelieve'
unit: str = 'm3/s'
subvars: SubVariablesType

Inlet sequences

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

Bases: hydpy.core.sequencetools.LinkSequences[InletSequence]

Inlet sequences of model dam.

The following classes are selected:
  • Q() Discharge [m³/s].

  • S() Water supply [m³/s].

  • R() Water relief [m³/s].

class hydpy.models.dam.dam_inlets.Q(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.InletSequences]

Discharge [m³/s].

Required by the methods:

Pic_Inflow_V1 Pic_Inflow_V2

NDIM: int = 0
NUMERIC: bool = False
name: str = 'q'
unit: str = 'm³/s'
class hydpy.models.dam.dam_inlets.S(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.InletSequences]

Water supply [m³/s].

Required by the method:

Pic_Inflow_V2

NDIM: int = 0
NUMERIC: bool = False
name: str = 's'
unit: str = 'm³/s'
class hydpy.models.dam.dam_inlets.R(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.InletSequences]

Water relief [m³/s].

Required by the method:

Pic_Inflow_V2

NDIM: int = 0
NUMERIC: bool = False
name: str = 'r'
unit: str = 'm³/s'

Outlet sequences

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

Bases: hydpy.core.sequencetools.LinkSequences[OutletSequence]

Outlet sequences of model dam.

The following classes are selected:
  • Q() Discharge [m³/s].

  • S() Water supply [m³/s].

  • R() Water relieve [m³/s].

class hydpy.models.dam.dam_outlets.Q(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.OutletSequences]

Discharge [m³/s].

Calculated by the method:

Pass_Outflow_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'q'
unit: str = 'm³/s'
class hydpy.models.dam.dam_outlets.S(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.OutletSequences]

Water supply [m³/s].

Calculated by the method:

Pass_ActualRemoteRelease_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 's'
unit: str = 'm³/s'
class hydpy.models.dam.dam_outlets.R(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.OutletSequences]

Water relieve [m³/s].

Calculated by the method:

Pass_ActualRemoteRelieve_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'r'
unit: str = 'm³/s'

Receiver sequences

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

Bases: hydpy.core.sequencetools.LinkSequences[ReceiverSequence]

Receiver sequences of model dam.

The following classes are selected:
  • Q() Discharge [m³/s].

  • D() Water demand [m³/s].

  • S() Water supply [m³/s].

  • R() Water relief [m³/s].

class hydpy.models.dam.dam_receivers.Q(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.ReceiverSequences]

Discharge [m³/s].

Required by the method:

Pic_TotalRemoteDischarge_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'q'
unit: str = 'm³/s'
class hydpy.models.dam.dam_receivers.D(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.ReceiverSequences]

Water demand [m³/s].

Required by the method:

Pic_LoggedRequiredRemoteRelease_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'd'
unit: str = 'm³/s'
class hydpy.models.dam.dam_receivers.S(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.ReceiverSequences]

Water supply [m³/s].

Required by the method:

Pic_LoggedRequiredRemoteRelease_V2

NDIM: int = 0
NUMERIC: bool = False
name: str = 's'
unit: str = 'm³/s'
class hydpy.models.dam.dam_receivers.R(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.ReceiverSequences]

Water relief [m³/s].

Required by the method:

Pic_LoggedAllowedRemoteRelieve_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'r'
unit: str = 'm³/s'

Sender sequences

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

Bases: hydpy.core.sequencetools.LinkSequences[SenderSequence]

Sender sequences of model dam.

The following classes are selected:
  • D() Water demand [m³/s].

  • S() Water supply [m³/s].

  • R() Water relief [m³/s].

class hydpy.models.dam.dam_senders.Q(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.SenderSequences]

Discharge [m³/s].

NDIM: int = 0
NUMERIC: bool = False
name: str = 'q'
unit: str = 'm³/s'
class hydpy.models.dam.dam_senders.D(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.SenderSequences]

Water demand [m³/s].

Calculated by the method:

Pass_MissingRemoteRelease_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'd'
unit: str = 'm³/s'
class hydpy.models.dam.dam_senders.S(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.SenderSequences]

Water supply [m³/s].

Calculated by the method:

Pass_RequiredRemoteSupply_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 's'
unit: str = 'm³/s'
class hydpy.models.dam.dam_senders.R(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.LinkSequence[hydpy.core.sequencetools.SenderSequences]

Water relief [m³/s].

Calculated by the method:

Pass_AllowedRemoteRelieve_V1

NDIM: int = 0
NUMERIC: bool = False
name: str = 'r'
unit: str = 'm³/s'

Aide sequences

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

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

Aide sequences of model dam.

The following classes are selected:
class hydpy.models.dam.dam_aides.WaterLevel(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelSequence[hydpy.core.sequencetools.AideSequences, hydpy.core.variabletools.FastAccess]

Water level [m].

Calculated by the method:

Calc_WaterLevel_V1

Required by the methods:

Calc_ActualRelease_V1 Calc_ActualRelease_V2 Calc_ActualRemoteRelease_V1 Calc_AllowedRemoteRelieve_V2 Calc_FloodDischarge_V1 Calc_PossibleRemoteRelieve_V1 Calc_RequiredRemoteSupply_V1

NDIM: int = 0
NUMERIC: bool = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'waterlevel'
unit: str = 'm'
class hydpy.models.dam.dam_aides.SurfaceArea(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelSequence[hydpy.core.sequencetools.AideSequences, hydpy.core.variabletools.FastAccess]

Surface area [million m²].

Calculated by the method:

Calc_SurfaceArea_V1

Required by the methods:

Calc_AllowedDischarge_V1 Calc_AllowedDischarge_V2

NDIM: int = 0
NUMERIC: bool = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'surfacearea'
unit: str = 'million m²'
class hydpy.models.dam.dam_aides.AllowedDischarge(subvars: SubVariablesType)[source]

Bases: hydpy.core.sequencetools.ModelSequence[hydpy.core.sequencetools.AideSequences, hydpy.core.variabletools.FastAccess]

Discharge threshold that should not be overcut by the actual discharge [m³/s].

Calculated by the methods:

Calc_AllowedDischarge_V1 Calc_AllowedDischarge_V2

Required by the methods:

Calc_ActualRelease_V3 Calc_Outflow_V2

NDIM: int = 0
NUMERIC: bool = True
SPAN: Tuple[Union[int, float, bool, None], Union[int, float, bool, None]] = (None, None)
name: str = 'alloweddischarge'
unit: str = 'm³/s'
class hydpy.models.dam.AideSequences(master: hydpy.core.sequencetools.Sequences, cls_fastaccess: Optional[Type[FastAccessType]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

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

Aide sequences of model dam.

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

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

Control parameters of model dam.

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

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

Derived parameters of model dam.

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

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

Flux sequences of model dam.

The following classes are selected:
  • Inflow() Total inflow [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 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 to the desired degree [m³/s].

  • AllowedRemoteRelieve() Allowed water release to relieve a dam during high flow conditions [m³/s].

  • RequiredRemoteSupply() Required water supply, e.g. to fill a dam during low water conditions [m³/s].

  • PossibleRemoteRelieve() Maximum possible water release to a remote location to relieve the dam during high flow conditions [m³/s].

  • ActualRemoteRelieve() 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 that could not be 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: hydpy.core.sequencetools.Sequences, cls_fastaccess: Optional[Type[FastAccessType]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

Bases: hydpy.core.sequencetools.LinkSequences[InletSequence]

Inlet sequences of model dam.

The following classes are selected:
  • Q() Discharge [m³/s].

  • S() Water supply [m³/s].

  • R() Water relief [m³/s].

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

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

Log sequences of model dam.

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

Bases: hydpy.core.sequencetools.LinkSequences[OutletSequence]

Outlet sequences of model dam.

The following classes are selected:
  • Q() Discharge [m³/s].

  • S() Water supply [m³/s].

  • R() Water relieve [m³/s].

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

Bases: hydpy.core.sequencetools.LinkSequences[ReceiverSequence]

Receiver sequences of model dam.

The following classes are selected:
  • Q() Discharge [m³/s].

  • D() Water demand [m³/s].

  • S() Water supply [m³/s].

  • R() Water relief [m³/s].

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

Bases: hydpy.core.sequencetools.LinkSequences[SenderSequence]

Sender sequences of model dam.

The following classes are selected:
  • D() Water demand [m³/s].

  • S() Water supply [m³/s].

  • R() Water relief [m³/s].

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

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

Solver parameters of model dam.

The following classes are selected:
  • AbsErrorMax() Absolute numerical error tolerance [m3/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: hydpy.core.sequencetools.Sequences, cls_fastaccess: Optional[Type[FastAccessType]] = None, cymodel: Optional[hydpy.core.typingtools.CyModelProtocol] = None)

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

State sequences of model dam.

The following classes are selected: