repository_name
stringlengths 7
55
| func_path_in_repository
stringlengths 4
223
| func_name
stringlengths 1
134
| whole_func_string
stringlengths 75
104k
| language
stringclasses 1
value | func_code_string
stringlengths 75
104k
| func_code_tokens
listlengths 19
28.4k
| func_documentation_string
stringlengths 1
46.9k
| func_documentation_tokens
listlengths 1
1.97k
| split_name
stringclasses 1
value | func_code_url
stringlengths 87
315
|
|---|---|---|---|---|---|---|---|---|---|---|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
calc_requiredrelease_v1
|
def calc_requiredrelease_v1(self):
"""Calculate the total water release (immediately and far downstream)
required for reducing drought events.
Required control parameter:
|NearDischargeMinimumThreshold|
Required derived parameters:
|NearDischargeMinimumSmoothPar2|
|dam_derived.TOY|
Required flux sequence:
|RequiredRemoteRelease|
Calculated flux sequence:
|RequiredRelease|
Basic equation:
:math:`RequiredRelease = RequiredRemoteRelease
\\cdot smooth_{logistic2}(
RequiredRemoteRelease-NearDischargeMinimumThreshold,
NearDischargeMinimumSmoothPar2)`
Used auxiliary method:
|smooth_logistic2|
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 |
"""
con = self.parameters.control.fastaccess
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
flu.requiredrelease = con.neardischargeminimumthreshold[
der.toy[self.idx_sim]]
flu.requiredrelease = (
flu.requiredrelease +
smoothutils.smooth_logistic2(
flu.requiredremoterelease-flu.requiredrelease,
der.neardischargeminimumsmoothpar2[
der.toy[self.idx_sim]]))
|
python
|
def calc_requiredrelease_v1(self):
"""Calculate the total water release (immediately and far downstream)
required for reducing drought events.
Required control parameter:
|NearDischargeMinimumThreshold|
Required derived parameters:
|NearDischargeMinimumSmoothPar2|
|dam_derived.TOY|
Required flux sequence:
|RequiredRemoteRelease|
Calculated flux sequence:
|RequiredRelease|
Basic equation:
:math:`RequiredRelease = RequiredRemoteRelease
\\cdot smooth_{logistic2}(
RequiredRemoteRelease-NearDischargeMinimumThreshold,
NearDischargeMinimumSmoothPar2)`
Used auxiliary method:
|smooth_logistic2|
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 |
"""
con = self.parameters.control.fastaccess
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
flu.requiredrelease = con.neardischargeminimumthreshold[
der.toy[self.idx_sim]]
flu.requiredrelease = (
flu.requiredrelease +
smoothutils.smooth_logistic2(
flu.requiredremoterelease-flu.requiredrelease,
der.neardischargeminimumsmoothpar2[
der.toy[self.idx_sim]]))
|
[
"def",
"calc_requiredrelease_v1",
"(",
"self",
")",
":",
"con",
"=",
"self",
".",
"parameters",
".",
"control",
".",
"fastaccess",
"der",
"=",
"self",
".",
"parameters",
".",
"derived",
".",
"fastaccess",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"flu",
".",
"requiredrelease",
"=",
"con",
".",
"neardischargeminimumthreshold",
"[",
"der",
".",
"toy",
"[",
"self",
".",
"idx_sim",
"]",
"]",
"flu",
".",
"requiredrelease",
"=",
"(",
"flu",
".",
"requiredrelease",
"+",
"smoothutils",
".",
"smooth_logistic2",
"(",
"flu",
".",
"requiredremoterelease",
"-",
"flu",
".",
"requiredrelease",
",",
"der",
".",
"neardischargeminimumsmoothpar2",
"[",
"der",
".",
"toy",
"[",
"self",
".",
"idx_sim",
"]",
"]",
")",
")"
] |
Calculate the total water release (immediately and far downstream)
required for reducing drought events.
Required control parameter:
|NearDischargeMinimumThreshold|
Required derived parameters:
|NearDischargeMinimumSmoothPar2|
|dam_derived.TOY|
Required flux sequence:
|RequiredRemoteRelease|
Calculated flux sequence:
|RequiredRelease|
Basic equation:
:math:`RequiredRelease = RequiredRemoteRelease
\\cdot smooth_{logistic2}(
RequiredRemoteRelease-NearDischargeMinimumThreshold,
NearDischargeMinimumSmoothPar2)`
Used auxiliary method:
|smooth_logistic2|
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 |
|
[
"Calculate",
"the",
"total",
"water",
"release",
"(",
"immediately",
"and",
"far",
"downstream",
")",
"required",
"for",
"reducing",
"drought",
"events",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L760-L874
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
calc_requiredrelease_v2
|
def calc_requiredrelease_v2(self):
"""Calculate the water release (immediately downstream) required for
reducing drought events.
Required control parameter:
|NearDischargeMinimumThreshold|
Required derived parameter:
|dam_derived.TOY|
Calculated flux sequence:
|RequiredRelease|
Basic equation:
:math:`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)
"""
con = self.parameters.control.fastaccess
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
flu.requiredrelease = con.neardischargeminimumthreshold[
der.toy[self.idx_sim]]
|
python
|
def calc_requiredrelease_v2(self):
"""Calculate the water release (immediately downstream) required for
reducing drought events.
Required control parameter:
|NearDischargeMinimumThreshold|
Required derived parameter:
|dam_derived.TOY|
Calculated flux sequence:
|RequiredRelease|
Basic equation:
:math:`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)
"""
con = self.parameters.control.fastaccess
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
flu.requiredrelease = con.neardischargeminimumthreshold[
der.toy[self.idx_sim]]
|
[
"def",
"calc_requiredrelease_v2",
"(",
"self",
")",
":",
"con",
"=",
"self",
".",
"parameters",
".",
"control",
".",
"fastaccess",
"der",
"=",
"self",
".",
"parameters",
".",
"derived",
".",
"fastaccess",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"flu",
".",
"requiredrelease",
"=",
"con",
".",
"neardischargeminimumthreshold",
"[",
"der",
".",
"toy",
"[",
"self",
".",
"idx_sim",
"]",
"]"
] |
Calculate the water release (immediately downstream) required for
reducing drought events.
Required control parameter:
|NearDischargeMinimumThreshold|
Required derived parameter:
|dam_derived.TOY|
Calculated flux sequence:
|RequiredRelease|
Basic equation:
:math:`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)
|
[
"Calculate",
"the",
"water",
"release",
"(",
"immediately",
"downstream",
")",
"required",
"for",
"reducing",
"drought",
"events",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L877-L930
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
calc_possibleremoterelieve_v1
|
def calc_possibleremoterelieve_v1(self):
"""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.
Required control parameter:
|WaterLevel2PossibleRemoteRelieve|
Required aide sequence:
|WaterLevel|
Calculated 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 |
"""
con = self.parameters.control.fastaccess
flu = self.sequences.fluxes.fastaccess
aid = self.sequences.aides.fastaccess
con.waterlevel2possibleremoterelieve.inputs[0] = aid.waterlevel
con.waterlevel2possibleremoterelieve.process_actual_input()
flu.possibleremoterelieve = con.waterlevel2possibleremoterelieve.outputs[0]
|
python
|
def calc_possibleremoterelieve_v1(self):
"""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.
Required control parameter:
|WaterLevel2PossibleRemoteRelieve|
Required aide sequence:
|WaterLevel|
Calculated 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 |
"""
con = self.parameters.control.fastaccess
flu = self.sequences.fluxes.fastaccess
aid = self.sequences.aides.fastaccess
con.waterlevel2possibleremoterelieve.inputs[0] = aid.waterlevel
con.waterlevel2possibleremoterelieve.process_actual_input()
flu.possibleremoterelieve = con.waterlevel2possibleremoterelieve.outputs[0]
|
[
"def",
"calc_possibleremoterelieve_v1",
"(",
"self",
")",
":",
"con",
"=",
"self",
".",
"parameters",
".",
"control",
".",
"fastaccess",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"aid",
"=",
"self",
".",
"sequences",
".",
"aides",
".",
"fastaccess",
"con",
".",
"waterlevel2possibleremoterelieve",
".",
"inputs",
"[",
"0",
"]",
"=",
"aid",
".",
"waterlevel",
"con",
".",
"waterlevel2possibleremoterelieve",
".",
"process_actual_input",
"(",
")",
"flu",
".",
"possibleremoterelieve",
"=",
"con",
".",
"waterlevel2possibleremoterelieve",
".",
"outputs",
"[",
"0",
"]"
] |
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.
Required control parameter:
|WaterLevel2PossibleRemoteRelieve|
Required aide sequence:
|WaterLevel|
Calculated 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 |
|
[
"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",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L933-L999
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
calc_actualremoterelieve_v1
|
def calc_actualremoterelieve_v1(self):
"""Calculate the actual amount of water released to a remote location
to relieve the dam during high flow conditions.
Required control parameter:
|RemoteRelieveTolerance|
Required flux sequences:
|AllowedRemoteRelieve|
|PossibleRemoteRelieve|
Calculated flux sequence:
|ActualRemoteRelieve|
Basic equation - discontinous:
:math:`ActualRemoteRelease = min(PossibleRemoteRelease,
AllowedRemoteRelease)`
Basic equation - continous:
:math:`ActualRemoteRelease = smooth_min1(PossibleRemoteRelease,
AllowedRemoteRelease, RemoteRelieveTolerance)`
Used auxiliary methods:
|smooth_min1|
|smooth_max1|
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 a 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.
"""
con = self.parameters.control.fastaccess
flu = self.sequences.fluxes.fastaccess
d_smoothpar = con.remoterelievetolerance*flu.allowedremoterelieve
flu.actualremoterelieve = smoothutils.smooth_min1(
flu.possibleremoterelieve, flu.allowedremoterelieve, d_smoothpar)
for dummy in range(5):
d_smoothpar /= 5.
flu.actualremoterelieve = smoothutils.smooth_max1(
flu.actualremoterelieve, 0., d_smoothpar)
d_smoothpar /= 5.
flu.actualremoterelieve = smoothutils.smooth_min1(
flu.actualremoterelieve, flu.possibleremoterelieve, d_smoothpar)
flu.actualremoterelieve = min(flu.actualremoterelieve,
flu.possibleremoterelieve)
flu.actualremoterelieve = min(flu.actualremoterelieve,
flu.allowedremoterelieve)
flu.actualremoterelieve = max(flu.actualremoterelieve, 0.)
|
python
|
def calc_actualremoterelieve_v1(self):
"""Calculate the actual amount of water released to a remote location
to relieve the dam during high flow conditions.
Required control parameter:
|RemoteRelieveTolerance|
Required flux sequences:
|AllowedRemoteRelieve|
|PossibleRemoteRelieve|
Calculated flux sequence:
|ActualRemoteRelieve|
Basic equation - discontinous:
:math:`ActualRemoteRelease = min(PossibleRemoteRelease,
AllowedRemoteRelease)`
Basic equation - continous:
:math:`ActualRemoteRelease = smooth_min1(PossibleRemoteRelease,
AllowedRemoteRelease, RemoteRelieveTolerance)`
Used auxiliary methods:
|smooth_min1|
|smooth_max1|
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 a 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.
"""
con = self.parameters.control.fastaccess
flu = self.sequences.fluxes.fastaccess
d_smoothpar = con.remoterelievetolerance*flu.allowedremoterelieve
flu.actualremoterelieve = smoothutils.smooth_min1(
flu.possibleremoterelieve, flu.allowedremoterelieve, d_smoothpar)
for dummy in range(5):
d_smoothpar /= 5.
flu.actualremoterelieve = smoothutils.smooth_max1(
flu.actualremoterelieve, 0., d_smoothpar)
d_smoothpar /= 5.
flu.actualremoterelieve = smoothutils.smooth_min1(
flu.actualremoterelieve, flu.possibleremoterelieve, d_smoothpar)
flu.actualremoterelieve = min(flu.actualremoterelieve,
flu.possibleremoterelieve)
flu.actualremoterelieve = min(flu.actualremoterelieve,
flu.allowedremoterelieve)
flu.actualremoterelieve = max(flu.actualremoterelieve, 0.)
|
[
"def",
"calc_actualremoterelieve_v1",
"(",
"self",
")",
":",
"con",
"=",
"self",
".",
"parameters",
".",
"control",
".",
"fastaccess",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"d_smoothpar",
"=",
"con",
".",
"remoterelievetolerance",
"*",
"flu",
".",
"allowedremoterelieve",
"flu",
".",
"actualremoterelieve",
"=",
"smoothutils",
".",
"smooth_min1",
"(",
"flu",
".",
"possibleremoterelieve",
",",
"flu",
".",
"allowedremoterelieve",
",",
"d_smoothpar",
")",
"for",
"dummy",
"in",
"range",
"(",
"5",
")",
":",
"d_smoothpar",
"/=",
"5.",
"flu",
".",
"actualremoterelieve",
"=",
"smoothutils",
".",
"smooth_max1",
"(",
"flu",
".",
"actualremoterelieve",
",",
"0.",
",",
"d_smoothpar",
")",
"d_smoothpar",
"/=",
"5.",
"flu",
".",
"actualremoterelieve",
"=",
"smoothutils",
".",
"smooth_min1",
"(",
"flu",
".",
"actualremoterelieve",
",",
"flu",
".",
"possibleremoterelieve",
",",
"d_smoothpar",
")",
"flu",
".",
"actualremoterelieve",
"=",
"min",
"(",
"flu",
".",
"actualremoterelieve",
",",
"flu",
".",
"possibleremoterelieve",
")",
"flu",
".",
"actualremoterelieve",
"=",
"min",
"(",
"flu",
".",
"actualremoterelieve",
",",
"flu",
".",
"allowedremoterelieve",
")",
"flu",
".",
"actualremoterelieve",
"=",
"max",
"(",
"flu",
".",
"actualremoterelieve",
",",
"0.",
")"
] |
Calculate the actual amount of water released to a remote location
to relieve the dam during high flow conditions.
Required control parameter:
|RemoteRelieveTolerance|
Required flux sequences:
|AllowedRemoteRelieve|
|PossibleRemoteRelieve|
Calculated flux sequence:
|ActualRemoteRelieve|
Basic equation - discontinous:
:math:`ActualRemoteRelease = min(PossibleRemoteRelease,
AllowedRemoteRelease)`
Basic equation - continous:
:math:`ActualRemoteRelease = smooth_min1(PossibleRemoteRelease,
AllowedRemoteRelease, RemoteRelieveTolerance)`
Used auxiliary methods:
|smooth_min1|
|smooth_max1|
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 a 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.
|
[
"Calculate",
"the",
"actual",
"amount",
"of",
"water",
"released",
"to",
"a",
"remote",
"location",
"to",
"relieve",
"the",
"dam",
"during",
"high",
"flow",
"conditions",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L1002-L1160
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
calc_targetedrelease_v1
|
def calc_targetedrelease_v1(self):
"""Calculate the targeted water release for reducing drought events,
taking into account both the required water release and the actual
inflow into the dam.
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|.
Required control parameter:
|RestrictTargetedRelease|
|NearDischargeMinimumThreshold|
Required derived parameters:
|NearDischargeMinimumSmoothPar1|
|dam_derived.TOY|
Required flux sequence:
|RequiredRelease|
Calculated flux sequence:
|TargetedRelease|
Used auxiliary method:
|smooth_logistic1|
Basic equation:
:math:`TargetedRelease =
w \\cdot RequiredRelease + (1-w) \\cdot Inflow`
:math:`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 |
"""
con = self.parameters.control.fastaccess
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
if con.restricttargetedrelease:
flu.targetedrelease = smoothutils.smooth_logistic1(
flu.inflow-con.neardischargeminimumthreshold[
der.toy[self.idx_sim]],
der.neardischargeminimumsmoothpar1[der.toy[self.idx_sim]])
flu.targetedrelease = (flu.targetedrelease * flu.requiredrelease +
(1.-flu.targetedrelease) * flu.inflow)
else:
flu.targetedrelease = flu.requiredrelease
|
python
|
def calc_targetedrelease_v1(self):
"""Calculate the targeted water release for reducing drought events,
taking into account both the required water release and the actual
inflow into the dam.
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|.
Required control parameter:
|RestrictTargetedRelease|
|NearDischargeMinimumThreshold|
Required derived parameters:
|NearDischargeMinimumSmoothPar1|
|dam_derived.TOY|
Required flux sequence:
|RequiredRelease|
Calculated flux sequence:
|TargetedRelease|
Used auxiliary method:
|smooth_logistic1|
Basic equation:
:math:`TargetedRelease =
w \\cdot RequiredRelease + (1-w) \\cdot Inflow`
:math:`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 |
"""
con = self.parameters.control.fastaccess
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
if con.restricttargetedrelease:
flu.targetedrelease = smoothutils.smooth_logistic1(
flu.inflow-con.neardischargeminimumthreshold[
der.toy[self.idx_sim]],
der.neardischargeminimumsmoothpar1[der.toy[self.idx_sim]])
flu.targetedrelease = (flu.targetedrelease * flu.requiredrelease +
(1.-flu.targetedrelease) * flu.inflow)
else:
flu.targetedrelease = flu.requiredrelease
|
[
"def",
"calc_targetedrelease_v1",
"(",
"self",
")",
":",
"con",
"=",
"self",
".",
"parameters",
".",
"control",
".",
"fastaccess",
"der",
"=",
"self",
".",
"parameters",
".",
"derived",
".",
"fastaccess",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"if",
"con",
".",
"restricttargetedrelease",
":",
"flu",
".",
"targetedrelease",
"=",
"smoothutils",
".",
"smooth_logistic1",
"(",
"flu",
".",
"inflow",
"-",
"con",
".",
"neardischargeminimumthreshold",
"[",
"der",
".",
"toy",
"[",
"self",
".",
"idx_sim",
"]",
"]",
",",
"der",
".",
"neardischargeminimumsmoothpar1",
"[",
"der",
".",
"toy",
"[",
"self",
".",
"idx_sim",
"]",
"]",
")",
"flu",
".",
"targetedrelease",
"=",
"(",
"flu",
".",
"targetedrelease",
"*",
"flu",
".",
"requiredrelease",
"+",
"(",
"1.",
"-",
"flu",
".",
"targetedrelease",
")",
"*",
"flu",
".",
"inflow",
")",
"else",
":",
"flu",
".",
"targetedrelease",
"=",
"flu",
".",
"requiredrelease"
] |
Calculate the targeted water release for reducing drought events,
taking into account both the required water release and the actual
inflow into the dam.
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|.
Required control parameter:
|RestrictTargetedRelease|
|NearDischargeMinimumThreshold|
Required derived parameters:
|NearDischargeMinimumSmoothPar1|
|dam_derived.TOY|
Required flux sequence:
|RequiredRelease|
Calculated flux sequence:
|TargetedRelease|
Used auxiliary method:
|smooth_logistic1|
Basic equation:
:math:`TargetedRelease =
w \\cdot RequiredRelease + (1-w) \\cdot Inflow`
:math:`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 |
|
[
"Calculate",
"the",
"targeted",
"water",
"release",
"for",
"reducing",
"drought",
"events",
"taking",
"into",
"account",
"both",
"the",
"required",
"water",
"release",
"and",
"the",
"actual",
"inflow",
"into",
"the",
"dam",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L1163-L1475
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
calc_actualrelease_v1
|
def calc_actualrelease_v1(self):
"""Calculate the actual water release that can be supplied by the
dam considering the targeted release and the given water level.
Required control parameter:
|WaterLevelMinimumThreshold|
Required derived parameters:
|WaterLevelMinimumSmoothPar|
Required flux sequence:
|TargetedRelease|
Required aide sequence:
|WaterLevel|
Calculated flux sequence:
|ActualRelease|
Basic equation:
:math:`ActualRelease = TargetedRelease \\cdot
smooth_{logistic1}(WaterLevelMinimumThreshold-WaterLevel,
WaterLevelMinimumSmoothPar)`
Used auxiliary method:
|smooth_logistic1|
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)
.. _dam_calc_actualrelease_v1_ex01:
**Example 1**
Firstly, we define a sharp minimum water level of 0 m:
>>> waterlevelminimumthreshold(0.)
>>> waterlevelminimumtolerance(0.)
>>> derived.waterlevelminimumsmoothpar.update()
The following test results show that the water releae 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.
.. _dam_calc_actualrelease_v1_ex02:
**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 |
.. _dam_calc_actualrelease_v1_ex03:
**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 |
"""
con = self.parameters.control.fastaccess
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
aid = self.sequences.aides.fastaccess
flu.actualrelease = (flu.targetedrelease *
smoothutils.smooth_logistic1(
aid.waterlevel-con.waterlevelminimumthreshold,
der.waterlevelminimumsmoothpar))
|
python
|
def calc_actualrelease_v1(self):
"""Calculate the actual water release that can be supplied by the
dam considering the targeted release and the given water level.
Required control parameter:
|WaterLevelMinimumThreshold|
Required derived parameters:
|WaterLevelMinimumSmoothPar|
Required flux sequence:
|TargetedRelease|
Required aide sequence:
|WaterLevel|
Calculated flux sequence:
|ActualRelease|
Basic equation:
:math:`ActualRelease = TargetedRelease \\cdot
smooth_{logistic1}(WaterLevelMinimumThreshold-WaterLevel,
WaterLevelMinimumSmoothPar)`
Used auxiliary method:
|smooth_logistic1|
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)
.. _dam_calc_actualrelease_v1_ex01:
**Example 1**
Firstly, we define a sharp minimum water level of 0 m:
>>> waterlevelminimumthreshold(0.)
>>> waterlevelminimumtolerance(0.)
>>> derived.waterlevelminimumsmoothpar.update()
The following test results show that the water releae 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.
.. _dam_calc_actualrelease_v1_ex02:
**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 |
.. _dam_calc_actualrelease_v1_ex03:
**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 |
"""
con = self.parameters.control.fastaccess
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
aid = self.sequences.aides.fastaccess
flu.actualrelease = (flu.targetedrelease *
smoothutils.smooth_logistic1(
aid.waterlevel-con.waterlevelminimumthreshold,
der.waterlevelminimumsmoothpar))
|
[
"def",
"calc_actualrelease_v1",
"(",
"self",
")",
":",
"con",
"=",
"self",
".",
"parameters",
".",
"control",
".",
"fastaccess",
"der",
"=",
"self",
".",
"parameters",
".",
"derived",
".",
"fastaccess",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"aid",
"=",
"self",
".",
"sequences",
".",
"aides",
".",
"fastaccess",
"flu",
".",
"actualrelease",
"=",
"(",
"flu",
".",
"targetedrelease",
"*",
"smoothutils",
".",
"smooth_logistic1",
"(",
"aid",
".",
"waterlevel",
"-",
"con",
".",
"waterlevelminimumthreshold",
",",
"der",
".",
"waterlevelminimumsmoothpar",
")",
")"
] |
Calculate the actual water release that can be supplied by the
dam considering the targeted release and the given water level.
Required control parameter:
|WaterLevelMinimumThreshold|
Required derived parameters:
|WaterLevelMinimumSmoothPar|
Required flux sequence:
|TargetedRelease|
Required aide sequence:
|WaterLevel|
Calculated flux sequence:
|ActualRelease|
Basic equation:
:math:`ActualRelease = TargetedRelease \\cdot
smooth_{logistic1}(WaterLevelMinimumThreshold-WaterLevel,
WaterLevelMinimumSmoothPar)`
Used auxiliary method:
|smooth_logistic1|
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)
.. _dam_calc_actualrelease_v1_ex01:
**Example 1**
Firstly, we define a sharp minimum water level of 0 m:
>>> waterlevelminimumthreshold(0.)
>>> waterlevelminimumtolerance(0.)
>>> derived.waterlevelminimumsmoothpar.update()
The following test results show that the water releae 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.
.. _dam_calc_actualrelease_v1_ex02:
**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 |
.. _dam_calc_actualrelease_v1_ex03:
**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 |
|
[
"Calculate",
"the",
"actual",
"water",
"release",
"that",
"can",
"be",
"supplied",
"by",
"the",
"dam",
"considering",
"the",
"targeted",
"release",
"and",
"the",
"given",
"water",
"level",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L1478-L1622
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
calc_missingremoterelease_v1
|
def calc_missingremoterelease_v1(self):
"""Calculate the portion of the required remote demand that could not
be met by the actual discharge release.
Required flux sequences:
|RequiredRemoteRelease|
|ActualRelease|
Calculated flux sequence:
|MissingRemoteRelease|
Basic equation:
:math:`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)
"""
flu = self.sequences.fluxes.fastaccess
flu.missingremoterelease = max(
flu.requiredremoterelease-flu.actualrelease, 0.)
|
python
|
def calc_missingremoterelease_v1(self):
"""Calculate the portion of the required remote demand that could not
be met by the actual discharge release.
Required flux sequences:
|RequiredRemoteRelease|
|ActualRelease|
Calculated flux sequence:
|MissingRemoteRelease|
Basic equation:
:math:`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)
"""
flu = self.sequences.fluxes.fastaccess
flu.missingremoterelease = max(
flu.requiredremoterelease-flu.actualrelease, 0.)
|
[
"def",
"calc_missingremoterelease_v1",
"(",
"self",
")",
":",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"flu",
".",
"missingremoterelease",
"=",
"max",
"(",
"flu",
".",
"requiredremoterelease",
"-",
"flu",
".",
"actualrelease",
",",
"0.",
")"
] |
Calculate the portion of the required remote demand that could not
be met by the actual discharge release.
Required flux sequences:
|RequiredRemoteRelease|
|ActualRelease|
Calculated flux sequence:
|MissingRemoteRelease|
Basic equation:
:math:`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)
|
[
"Calculate",
"the",
"portion",
"of",
"the",
"required",
"remote",
"demand",
"that",
"could",
"not",
"be",
"met",
"by",
"the",
"actual",
"discharge",
"release",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L1625-L1656
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
calc_actualremoterelease_v1
|
def calc_actualremoterelease_v1(self):
"""Calculate the actual remote water release that can be supplied by the
dam considering the required remote release and the given water level.
Required control parameter:
|WaterLevelMinimumRemoteThreshold|
Required derived parameters:
|WaterLevelMinimumRemoteSmoothPar|
Required flux sequence:
|RequiredRemoteRelease|
Required aide sequence:
|WaterLevel|
Calculated flux sequence:
|ActualRemoteRelease|
Basic equation:
:math:`ActualRemoteRelease = RequiredRemoteRelease \\cdot
smooth_{logistic1}(WaterLevelMinimumRemoteThreshold-WaterLevel,
WaterLevelMinimumRemoteSmoothPar)`
Used auxiliary method:
|smooth_logistic1|
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)
:ref:`Recalculation of example 1 <dam_calc_actualrelease_v1_ex01>`
>>> 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 |
:ref:`Recalculation of example 2 <dam_calc_actualrelease_v1_ex02>`
>>> 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 |
:ref:`Recalculation of example 3 <dam_calc_actualrelease_v1_ex03>`
>>> 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 |
"""
con = self.parameters.control.fastaccess
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
aid = self.sequences.aides.fastaccess
flu.actualremoterelease = (
flu.requiredremoterelease *
smoothutils.smooth_logistic1(
aid.waterlevel-con.waterlevelminimumremotethreshold,
der.waterlevelminimumremotesmoothpar))
|
python
|
def calc_actualremoterelease_v1(self):
"""Calculate the actual remote water release that can be supplied by the
dam considering the required remote release and the given water level.
Required control parameter:
|WaterLevelMinimumRemoteThreshold|
Required derived parameters:
|WaterLevelMinimumRemoteSmoothPar|
Required flux sequence:
|RequiredRemoteRelease|
Required aide sequence:
|WaterLevel|
Calculated flux sequence:
|ActualRemoteRelease|
Basic equation:
:math:`ActualRemoteRelease = RequiredRemoteRelease \\cdot
smooth_{logistic1}(WaterLevelMinimumRemoteThreshold-WaterLevel,
WaterLevelMinimumRemoteSmoothPar)`
Used auxiliary method:
|smooth_logistic1|
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)
:ref:`Recalculation of example 1 <dam_calc_actualrelease_v1_ex01>`
>>> 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 |
:ref:`Recalculation of example 2 <dam_calc_actualrelease_v1_ex02>`
>>> 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 |
:ref:`Recalculation of example 3 <dam_calc_actualrelease_v1_ex03>`
>>> 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 |
"""
con = self.parameters.control.fastaccess
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
aid = self.sequences.aides.fastaccess
flu.actualremoterelease = (
flu.requiredremoterelease *
smoothutils.smooth_logistic1(
aid.waterlevel-con.waterlevelminimumremotethreshold,
der.waterlevelminimumremotesmoothpar))
|
[
"def",
"calc_actualremoterelease_v1",
"(",
"self",
")",
":",
"con",
"=",
"self",
".",
"parameters",
".",
"control",
".",
"fastaccess",
"der",
"=",
"self",
".",
"parameters",
".",
"derived",
".",
"fastaccess",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"aid",
"=",
"self",
".",
"sequences",
".",
"aides",
".",
"fastaccess",
"flu",
".",
"actualremoterelease",
"=",
"(",
"flu",
".",
"requiredremoterelease",
"*",
"smoothutils",
".",
"smooth_logistic1",
"(",
"aid",
".",
"waterlevel",
"-",
"con",
".",
"waterlevelminimumremotethreshold",
",",
"der",
".",
"waterlevelminimumremotesmoothpar",
")",
")"
] |
Calculate the actual remote water release that can be supplied by the
dam considering the required remote release and the given water level.
Required control parameter:
|WaterLevelMinimumRemoteThreshold|
Required derived parameters:
|WaterLevelMinimumRemoteSmoothPar|
Required flux sequence:
|RequiredRemoteRelease|
Required aide sequence:
|WaterLevel|
Calculated flux sequence:
|ActualRemoteRelease|
Basic equation:
:math:`ActualRemoteRelease = RequiredRemoteRelease \\cdot
smooth_{logistic1}(WaterLevelMinimumRemoteThreshold-WaterLevel,
WaterLevelMinimumRemoteSmoothPar)`
Used auxiliary method:
|smooth_logistic1|
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)
:ref:`Recalculation of example 1 <dam_calc_actualrelease_v1_ex01>`
>>> 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 |
:ref:`Recalculation of example 2 <dam_calc_actualrelease_v1_ex02>`
>>> 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 |
:ref:`Recalculation of example 3 <dam_calc_actualrelease_v1_ex03>`
>>> 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 |
|
[
"Calculate",
"the",
"actual",
"remote",
"water",
"release",
"that",
"can",
"be",
"supplied",
"by",
"the",
"dam",
"considering",
"the",
"required",
"remote",
"release",
"and",
"the",
"given",
"water",
"level",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L1659-L1762
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
update_actualremoterelieve_v1
|
def update_actualremoterelieve_v1(self):
"""Constrain the actual relieve discharge to a remote location.
Required control parameter:
|HighestRemoteDischarge|
Required derived parameter:
|HighestRemoteSmoothPar|
Updated flux sequence:
|ActualRemoteRelieve|
Basic equation - discontinous:
:math:`ActualRemoteRelieve = min(ActualRemoteRelease,
HighestRemoteDischarge)`
Basic equation - continous:
:math:`ActualRemoteRelieve = smooth_min1(ActualRemoteRelieve,
HighestRemoteDischarge, HighestRemoteSmoothPar)`
Used auxiliary methods:
|smooth_min1|
|smooth_max1|
Note that the given continous basic equation is a simplification of
the complete algorithm to update |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 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 |
Method |update_actualremoterelieve_v1| is defined in a similar
way as method |calc_actualremoterelieve_v1|. Please read the
documentation on |calc_actualremoterelieve_v1| for further
information.
"""
con = self.parameters.control.fastaccess
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
d_smooth = der.highestremotesmoothpar
d_highest = con.highestremotedischarge
d_value = smoothutils.smooth_min1(
flu.actualremoterelieve, d_highest, d_smooth)
for dummy in range(5):
d_smooth /= 5.
d_value = smoothutils.smooth_max1(
d_value, 0., d_smooth)
d_smooth /= 5.
d_value = smoothutils.smooth_min1(
d_value, d_highest, d_smooth)
d_value = min(d_value, flu.actualremoterelieve)
d_value = min(d_value, d_highest)
flu.actualremoterelieve = max(d_value, 0.)
|
python
|
def update_actualremoterelieve_v1(self):
"""Constrain the actual relieve discharge to a remote location.
Required control parameter:
|HighestRemoteDischarge|
Required derived parameter:
|HighestRemoteSmoothPar|
Updated flux sequence:
|ActualRemoteRelieve|
Basic equation - discontinous:
:math:`ActualRemoteRelieve = min(ActualRemoteRelease,
HighestRemoteDischarge)`
Basic equation - continous:
:math:`ActualRemoteRelieve = smooth_min1(ActualRemoteRelieve,
HighestRemoteDischarge, HighestRemoteSmoothPar)`
Used auxiliary methods:
|smooth_min1|
|smooth_max1|
Note that the given continous basic equation is a simplification of
the complete algorithm to update |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 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 |
Method |update_actualremoterelieve_v1| is defined in a similar
way as method |calc_actualremoterelieve_v1|. Please read the
documentation on |calc_actualremoterelieve_v1| for further
information.
"""
con = self.parameters.control.fastaccess
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
d_smooth = der.highestremotesmoothpar
d_highest = con.highestremotedischarge
d_value = smoothutils.smooth_min1(
flu.actualremoterelieve, d_highest, d_smooth)
for dummy in range(5):
d_smooth /= 5.
d_value = smoothutils.smooth_max1(
d_value, 0., d_smooth)
d_smooth /= 5.
d_value = smoothutils.smooth_min1(
d_value, d_highest, d_smooth)
d_value = min(d_value, flu.actualremoterelieve)
d_value = min(d_value, d_highest)
flu.actualremoterelieve = max(d_value, 0.)
|
[
"def",
"update_actualremoterelieve_v1",
"(",
"self",
")",
":",
"con",
"=",
"self",
".",
"parameters",
".",
"control",
".",
"fastaccess",
"der",
"=",
"self",
".",
"parameters",
".",
"derived",
".",
"fastaccess",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"d_smooth",
"=",
"der",
".",
"highestremotesmoothpar",
"d_highest",
"=",
"con",
".",
"highestremotedischarge",
"d_value",
"=",
"smoothutils",
".",
"smooth_min1",
"(",
"flu",
".",
"actualremoterelieve",
",",
"d_highest",
",",
"d_smooth",
")",
"for",
"dummy",
"in",
"range",
"(",
"5",
")",
":",
"d_smooth",
"/=",
"5.",
"d_value",
"=",
"smoothutils",
".",
"smooth_max1",
"(",
"d_value",
",",
"0.",
",",
"d_smooth",
")",
"d_smooth",
"/=",
"5.",
"d_value",
"=",
"smoothutils",
".",
"smooth_min1",
"(",
"d_value",
",",
"d_highest",
",",
"d_smooth",
")",
"d_value",
"=",
"min",
"(",
"d_value",
",",
"flu",
".",
"actualremoterelieve",
")",
"d_value",
"=",
"min",
"(",
"d_value",
",",
"d_highest",
")",
"flu",
".",
"actualremoterelieve",
"=",
"max",
"(",
"d_value",
",",
"0.",
")"
] |
Constrain the actual relieve discharge to a remote location.
Required control parameter:
|HighestRemoteDischarge|
Required derived parameter:
|HighestRemoteSmoothPar|
Updated flux sequence:
|ActualRemoteRelieve|
Basic equation - discontinous:
:math:`ActualRemoteRelieve = min(ActualRemoteRelease,
HighestRemoteDischarge)`
Basic equation - continous:
:math:`ActualRemoteRelieve = smooth_min1(ActualRemoteRelieve,
HighestRemoteDischarge, HighestRemoteSmoothPar)`
Used auxiliary methods:
|smooth_min1|
|smooth_max1|
Note that the given continous basic equation is a simplification of
the complete algorithm to update |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 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 |
Method |update_actualremoterelieve_v1| is defined in a similar
way as method |calc_actualremoterelieve_v1|. Please read the
documentation on |calc_actualremoterelieve_v1| for further
information.
|
[
"Constrain",
"the",
"actual",
"relieve",
"discharge",
"to",
"a",
"remote",
"location",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L1765-L1869
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
calc_flooddischarge_v1
|
def calc_flooddischarge_v1(self):
"""Calculate the discharge during and after a flood event based on an
|anntools.SeasonalANN| describing the relationship(s) between discharge
and water stage.
Required control parameter:
|WaterLevel2FloodDischarge|
Required derived parameter:
|dam_derived.TOY|
Required aide sequence:
|WaterLevel|
Calculated 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 |
"""
con = self.parameters.control.fastaccess
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
aid = self.sequences.aides.fastaccess
con.waterlevel2flooddischarge.inputs[0] = aid.waterlevel
con.waterlevel2flooddischarge.process_actual_input(der.toy[self.idx_sim])
flu.flooddischarge = con.waterlevel2flooddischarge.outputs[0]
|
python
|
def calc_flooddischarge_v1(self):
"""Calculate the discharge during and after a flood event based on an
|anntools.SeasonalANN| describing the relationship(s) between discharge
and water stage.
Required control parameter:
|WaterLevel2FloodDischarge|
Required derived parameter:
|dam_derived.TOY|
Required aide sequence:
|WaterLevel|
Calculated 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 |
"""
con = self.parameters.control.fastaccess
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
aid = self.sequences.aides.fastaccess
con.waterlevel2flooddischarge.inputs[0] = aid.waterlevel
con.waterlevel2flooddischarge.process_actual_input(der.toy[self.idx_sim])
flu.flooddischarge = con.waterlevel2flooddischarge.outputs[0]
|
[
"def",
"calc_flooddischarge_v1",
"(",
"self",
")",
":",
"con",
"=",
"self",
".",
"parameters",
".",
"control",
".",
"fastaccess",
"der",
"=",
"self",
".",
"parameters",
".",
"derived",
".",
"fastaccess",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"aid",
"=",
"self",
".",
"sequences",
".",
"aides",
".",
"fastaccess",
"con",
".",
"waterlevel2flooddischarge",
".",
"inputs",
"[",
"0",
"]",
"=",
"aid",
".",
"waterlevel",
"con",
".",
"waterlevel2flooddischarge",
".",
"process_actual_input",
"(",
"der",
".",
"toy",
"[",
"self",
".",
"idx_sim",
"]",
")",
"flu",
".",
"flooddischarge",
"=",
"con",
".",
"waterlevel2flooddischarge",
".",
"outputs",
"[",
"0",
"]"
] |
Calculate the discharge during and after a flood event based on an
|anntools.SeasonalANN| describing the relationship(s) between discharge
and water stage.
Required control parameter:
|WaterLevel2FloodDischarge|
Required derived parameter:
|dam_derived.TOY|
Required aide sequence:
|WaterLevel|
Calculated 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 |
|
[
"Calculate",
"the",
"discharge",
"during",
"and",
"after",
"a",
"flood",
"event",
"based",
"on",
"an",
"|anntools",
".",
"SeasonalANN|",
"describing",
"the",
"relationship",
"(",
"s",
")",
"between",
"discharge",
"and",
"water",
"stage",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L1994-L2092
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
calc_outflow_v1
|
def calc_outflow_v1(self):
"""Calculate the total outflow of the dam.
Note that the maximum function is used to prevent from negative outflow
values, which could otherwise occur within the required level of
numerical accuracy.
Required flux sequences:
|ActualRelease|
|FloodDischarge|
Calculated flux sequence:
|Outflow|
Basic equation:
:math:`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)
"""
flu = self.sequences.fluxes.fastaccess
flu.outflow = max(flu.actualrelease + flu.flooddischarge, 0.)
|
python
|
def calc_outflow_v1(self):
"""Calculate the total outflow of the dam.
Note that the maximum function is used to prevent from negative outflow
values, which could otherwise occur within the required level of
numerical accuracy.
Required flux sequences:
|ActualRelease|
|FloodDischarge|
Calculated flux sequence:
|Outflow|
Basic equation:
:math:`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)
"""
flu = self.sequences.fluxes.fastaccess
flu.outflow = max(flu.actualrelease + flu.flooddischarge, 0.)
|
[
"def",
"calc_outflow_v1",
"(",
"self",
")",
":",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"flu",
".",
"outflow",
"=",
"max",
"(",
"flu",
".",
"actualrelease",
"+",
"flu",
".",
"flooddischarge",
",",
"0.",
")"
] |
Calculate the total outflow of the dam.
Note that the maximum function is used to prevent from negative outflow
values, which could otherwise occur within the required level of
numerical accuracy.
Required flux sequences:
|ActualRelease|
|FloodDischarge|
Calculated flux sequence:
|Outflow|
Basic equation:
:math:`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)
|
[
"Calculate",
"the",
"total",
"outflow",
"of",
"the",
"dam",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L2095-L2127
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
update_watervolume_v1
|
def update_watervolume_v1(self):
"""Update the actual water volume.
Required derived parameter:
|Seconds|
Required flux sequences:
|Inflow|
|Outflow|
Updated state sequence:
|WaterVolume|
Basic equation:
:math:`\\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)
"""
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
old = self.sequences.states.fastaccess_old
new = self.sequences.states.fastaccess_new
new.watervolume = (old.watervolume +
der.seconds*(flu.inflow-flu.outflow)/1e6)
|
python
|
def update_watervolume_v1(self):
"""Update the actual water volume.
Required derived parameter:
|Seconds|
Required flux sequences:
|Inflow|
|Outflow|
Updated state sequence:
|WaterVolume|
Basic equation:
:math:`\\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)
"""
der = self.parameters.derived.fastaccess
flu = self.sequences.fluxes.fastaccess
old = self.sequences.states.fastaccess_old
new = self.sequences.states.fastaccess_new
new.watervolume = (old.watervolume +
der.seconds*(flu.inflow-flu.outflow)/1e6)
|
[
"def",
"update_watervolume_v1",
"(",
"self",
")",
":",
"der",
"=",
"self",
".",
"parameters",
".",
"derived",
".",
"fastaccess",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"old",
"=",
"self",
".",
"sequences",
".",
"states",
".",
"fastaccess_old",
"new",
"=",
"self",
".",
"sequences",
".",
"states",
".",
"fastaccess_new",
"new",
".",
"watervolume",
"=",
"(",
"old",
".",
"watervolume",
"+",
"der",
".",
"seconds",
"*",
"(",
"flu",
".",
"inflow",
"-",
"flu",
".",
"outflow",
")",
"/",
"1e6",
")"
] |
Update the actual water volume.
Required derived parameter:
|Seconds|
Required flux sequences:
|Inflow|
|Outflow|
Updated state sequence:
|WaterVolume|
Basic equation:
:math:`\\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)
|
[
"Update",
"the",
"actual",
"water",
"volume",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L2130-L2163
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
pass_outflow_v1
|
def pass_outflow_v1(self):
"""Update the outlet link sequence |dam_outlets.Q|."""
flu = self.sequences.fluxes.fastaccess
out = self.sequences.outlets.fastaccess
out.q[0] += flu.outflow
|
python
|
def pass_outflow_v1(self):
"""Update the outlet link sequence |dam_outlets.Q|."""
flu = self.sequences.fluxes.fastaccess
out = self.sequences.outlets.fastaccess
out.q[0] += flu.outflow
|
[
"def",
"pass_outflow_v1",
"(",
"self",
")",
":",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"out",
"=",
"self",
".",
"sequences",
".",
"outlets",
".",
"fastaccess",
"out",
".",
"q",
"[",
"0",
"]",
"+=",
"flu",
".",
"outflow"
] |
Update the outlet link sequence |dam_outlets.Q|.
|
[
"Update",
"the",
"outlet",
"link",
"sequence",
"|dam_outlets",
".",
"Q|",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L2251-L2255
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
pass_actualremoterelease_v1
|
def pass_actualremoterelease_v1(self):
"""Update the outlet link sequence |dam_outlets.S|."""
flu = self.sequences.fluxes.fastaccess
out = self.sequences.outlets.fastaccess
out.s[0] += flu.actualremoterelease
|
python
|
def pass_actualremoterelease_v1(self):
"""Update the outlet link sequence |dam_outlets.S|."""
flu = self.sequences.fluxes.fastaccess
out = self.sequences.outlets.fastaccess
out.s[0] += flu.actualremoterelease
|
[
"def",
"pass_actualremoterelease_v1",
"(",
"self",
")",
":",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"out",
"=",
"self",
".",
"sequences",
".",
"outlets",
".",
"fastaccess",
"out",
".",
"s",
"[",
"0",
"]",
"+=",
"flu",
".",
"actualremoterelease"
] |
Update the outlet link sequence |dam_outlets.S|.
|
[
"Update",
"the",
"outlet",
"link",
"sequence",
"|dam_outlets",
".",
"S|",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L2258-L2262
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
pass_actualremoterelieve_v1
|
def pass_actualremoterelieve_v1(self):
"""Update the outlet link sequence |dam_outlets.R|."""
flu = self.sequences.fluxes.fastaccess
out = self.sequences.outlets.fastaccess
out.r[0] += flu.actualremoterelieve
|
python
|
def pass_actualremoterelieve_v1(self):
"""Update the outlet link sequence |dam_outlets.R|."""
flu = self.sequences.fluxes.fastaccess
out = self.sequences.outlets.fastaccess
out.r[0] += flu.actualremoterelieve
|
[
"def",
"pass_actualremoterelieve_v1",
"(",
"self",
")",
":",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"out",
"=",
"self",
".",
"sequences",
".",
"outlets",
".",
"fastaccess",
"out",
".",
"r",
"[",
"0",
"]",
"+=",
"flu",
".",
"actualremoterelieve"
] |
Update the outlet link sequence |dam_outlets.R|.
|
[
"Update",
"the",
"outlet",
"link",
"sequence",
"|dam_outlets",
".",
"R|",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L2265-L2269
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
pass_missingremoterelease_v1
|
def pass_missingremoterelease_v1(self):
"""Update the outlet link sequence |dam_senders.D|."""
flu = self.sequences.fluxes.fastaccess
sen = self.sequences.senders.fastaccess
sen.d[0] += flu.missingremoterelease
|
python
|
def pass_missingremoterelease_v1(self):
"""Update the outlet link sequence |dam_senders.D|."""
flu = self.sequences.fluxes.fastaccess
sen = self.sequences.senders.fastaccess
sen.d[0] += flu.missingremoterelease
|
[
"def",
"pass_missingremoterelease_v1",
"(",
"self",
")",
":",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"sen",
"=",
"self",
".",
"sequences",
".",
"senders",
".",
"fastaccess",
"sen",
".",
"d",
"[",
"0",
"]",
"+=",
"flu",
".",
"missingremoterelease"
] |
Update the outlet link sequence |dam_senders.D|.
|
[
"Update",
"the",
"outlet",
"link",
"sequence",
"|dam_senders",
".",
"D|",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L2272-L2276
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
pass_allowedremoterelieve_v1
|
def pass_allowedremoterelieve_v1(self):
"""Update the outlet link sequence |dam_outlets.R|."""
flu = self.sequences.fluxes.fastaccess
sen = self.sequences.senders.fastaccess
sen.r[0] += flu.allowedremoterelieve
|
python
|
def pass_allowedremoterelieve_v1(self):
"""Update the outlet link sequence |dam_outlets.R|."""
flu = self.sequences.fluxes.fastaccess
sen = self.sequences.senders.fastaccess
sen.r[0] += flu.allowedremoterelieve
|
[
"def",
"pass_allowedremoterelieve_v1",
"(",
"self",
")",
":",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"sen",
"=",
"self",
".",
"sequences",
".",
"senders",
".",
"fastaccess",
"sen",
".",
"r",
"[",
"0",
"]",
"+=",
"flu",
".",
"allowedremoterelieve"
] |
Update the outlet link sequence |dam_outlets.R|.
|
[
"Update",
"the",
"outlet",
"link",
"sequence",
"|dam_outlets",
".",
"R|",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L2279-L2283
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
pass_requiredremotesupply_v1
|
def pass_requiredremotesupply_v1(self):
"""Update the outlet link sequence |dam_outlets.S|."""
flu = self.sequences.fluxes.fastaccess
sen = self.sequences.senders.fastaccess
sen.s[0] += flu.requiredremotesupply
|
python
|
def pass_requiredremotesupply_v1(self):
"""Update the outlet link sequence |dam_outlets.S|."""
flu = self.sequences.fluxes.fastaccess
sen = self.sequences.senders.fastaccess
sen.s[0] += flu.requiredremotesupply
|
[
"def",
"pass_requiredremotesupply_v1",
"(",
"self",
")",
":",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"sen",
"=",
"self",
".",
"sequences",
".",
"senders",
".",
"fastaccess",
"sen",
".",
"s",
"[",
"0",
"]",
"+=",
"flu",
".",
"requiredremotesupply"
] |
Update the outlet link sequence |dam_outlets.S|.
|
[
"Update",
"the",
"outlet",
"link",
"sequence",
"|dam_outlets",
".",
"S|",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L2286-L2290
|
hydpy-dev/hydpy
|
hydpy/models/dam/dam_model.py
|
update_loggedoutflow_v1
|
def update_loggedoutflow_v1(self):
"""Log a new entry of discharge at a cross section far downstream.
Required control parameter:
|NmbLogEntries|
Required flux sequence:
|Outflow|
Calculated flux 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 |
"""
con = self.parameters.control.fastaccess
flu = self.sequences.fluxes.fastaccess
log = self.sequences.logs.fastaccess
for idx in range(con.nmblogentries-1, 0, -1):
log.loggedoutflow[idx] = log.loggedoutflow[idx-1]
log.loggedoutflow[0] = flu.outflow
|
python
|
def update_loggedoutflow_v1(self):
"""Log a new entry of discharge at a cross section far downstream.
Required control parameter:
|NmbLogEntries|
Required flux sequence:
|Outflow|
Calculated flux 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 |
"""
con = self.parameters.control.fastaccess
flu = self.sequences.fluxes.fastaccess
log = self.sequences.logs.fastaccess
for idx in range(con.nmblogentries-1, 0, -1):
log.loggedoutflow[idx] = log.loggedoutflow[idx-1]
log.loggedoutflow[0] = flu.outflow
|
[
"def",
"update_loggedoutflow_v1",
"(",
"self",
")",
":",
"con",
"=",
"self",
".",
"parameters",
".",
"control",
".",
"fastaccess",
"flu",
"=",
"self",
".",
"sequences",
".",
"fluxes",
".",
"fastaccess",
"log",
"=",
"self",
".",
"sequences",
".",
"logs",
".",
"fastaccess",
"for",
"idx",
"in",
"range",
"(",
"con",
".",
"nmblogentries",
"-",
"1",
",",
"0",
",",
"-",
"1",
")",
":",
"log",
".",
"loggedoutflow",
"[",
"idx",
"]",
"=",
"log",
".",
"loggedoutflow",
"[",
"idx",
"-",
"1",
"]",
"log",
".",
"loggedoutflow",
"[",
"0",
"]",
"=",
"flu",
".",
"outflow"
] |
Log a new entry of discharge at a cross section far downstream.
Required control parameter:
|NmbLogEntries|
Required flux sequence:
|Outflow|
Calculated flux 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 |
|
[
"Log",
"a",
"new",
"entry",
"of",
"discharge",
"at",
"a",
"cross",
"section",
"far",
"downstream",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/models/dam/dam_model.py#L2293-L2335
|
hydpy-dev/hydpy
|
hydpy/auxs/armatools.py
|
MA.update_coefs
|
def update_coefs(self):
"""(Re)calculate the MA coefficients based on the instantaneous
unit hydrograph."""
coefs = []
sum_coefs = 0.
moment1 = self.iuh.moment1
for t in itertools.count(0., 1.):
points = (moment1 % 1,) if t <= moment1 <= (t+2.) else ()
try:
coef = integrate.quad(
self._quad, 0., 1., args=(t,), points=points)[0]
except integrate.IntegrationWarning:
idx = int(moment1)
coefs = numpy.zeros(idx+2, dtype=float)
weight = (moment1-idx)
coefs[idx] = (1.-weight)
coefs[idx+1] = weight
self.coefs = coefs
warnings.warn(
'During the determination of the MA coefficients '
'corresponding to the instantaneous unit hydrograph '
'`%s` a numerical integration problem occurred. '
'Please check the calculated coefficients: %s.'
% (repr(self.iuh), objecttools.repr_values(coefs)))
break # pragma: no cover
sum_coefs += coef
if (sum_coefs > .9) and (coef < self.smallest_coeff):
coefs = numpy.array(coefs)
coefs /= numpy.sum(coefs)
self.coefs = coefs
break
else:
coefs.append(coef)
|
python
|
def update_coefs(self):
"""(Re)calculate the MA coefficients based on the instantaneous
unit hydrograph."""
coefs = []
sum_coefs = 0.
moment1 = self.iuh.moment1
for t in itertools.count(0., 1.):
points = (moment1 % 1,) if t <= moment1 <= (t+2.) else ()
try:
coef = integrate.quad(
self._quad, 0., 1., args=(t,), points=points)[0]
except integrate.IntegrationWarning:
idx = int(moment1)
coefs = numpy.zeros(idx+2, dtype=float)
weight = (moment1-idx)
coefs[idx] = (1.-weight)
coefs[idx+1] = weight
self.coefs = coefs
warnings.warn(
'During the determination of the MA coefficients '
'corresponding to the instantaneous unit hydrograph '
'`%s` a numerical integration problem occurred. '
'Please check the calculated coefficients: %s.'
% (repr(self.iuh), objecttools.repr_values(coefs)))
break # pragma: no cover
sum_coefs += coef
if (sum_coefs > .9) and (coef < self.smallest_coeff):
coefs = numpy.array(coefs)
coefs /= numpy.sum(coefs)
self.coefs = coefs
break
else:
coefs.append(coef)
|
[
"def",
"update_coefs",
"(",
"self",
")",
":",
"coefs",
"=",
"[",
"]",
"sum_coefs",
"=",
"0.",
"moment1",
"=",
"self",
".",
"iuh",
".",
"moment1",
"for",
"t",
"in",
"itertools",
".",
"count",
"(",
"0.",
",",
"1.",
")",
":",
"points",
"=",
"(",
"moment1",
"%",
"1",
",",
")",
"if",
"t",
"<=",
"moment1",
"<=",
"(",
"t",
"+",
"2.",
")",
"else",
"(",
")",
"try",
":",
"coef",
"=",
"integrate",
".",
"quad",
"(",
"self",
".",
"_quad",
",",
"0.",
",",
"1.",
",",
"args",
"=",
"(",
"t",
",",
")",
",",
"points",
"=",
"points",
")",
"[",
"0",
"]",
"except",
"integrate",
".",
"IntegrationWarning",
":",
"idx",
"=",
"int",
"(",
"moment1",
")",
"coefs",
"=",
"numpy",
".",
"zeros",
"(",
"idx",
"+",
"2",
",",
"dtype",
"=",
"float",
")",
"weight",
"=",
"(",
"moment1",
"-",
"idx",
")",
"coefs",
"[",
"idx",
"]",
"=",
"(",
"1.",
"-",
"weight",
")",
"coefs",
"[",
"idx",
"+",
"1",
"]",
"=",
"weight",
"self",
".",
"coefs",
"=",
"coefs",
"warnings",
".",
"warn",
"(",
"'During the determination of the MA coefficients '",
"'corresponding to the instantaneous unit hydrograph '",
"'`%s` a numerical integration problem occurred. '",
"'Please check the calculated coefficients: %s.'",
"%",
"(",
"repr",
"(",
"self",
".",
"iuh",
")",
",",
"objecttools",
".",
"repr_values",
"(",
"coefs",
")",
")",
")",
"break",
"# pragma: no cover",
"sum_coefs",
"+=",
"coef",
"if",
"(",
"sum_coefs",
">",
".9",
")",
"and",
"(",
"coef",
"<",
"self",
".",
"smallest_coeff",
")",
":",
"coefs",
"=",
"numpy",
".",
"array",
"(",
"coefs",
")",
"coefs",
"/=",
"numpy",
".",
"sum",
"(",
"coefs",
")",
"self",
".",
"coefs",
"=",
"coefs",
"break",
"else",
":",
"coefs",
".",
"append",
"(",
"coef",
")"
] |
(Re)calculate the MA coefficients based on the instantaneous
unit hydrograph.
|
[
"(",
"Re",
")",
"calculate",
"the",
"MA",
"coefficients",
"based",
"on",
"the",
"instantaneous",
"unit",
"hydrograph",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/armatools.py#L201-L233
|
hydpy-dev/hydpy
|
hydpy/auxs/armatools.py
|
MA.turningpoint
|
def turningpoint(self):
"""Turning point (index and value tuple) in the recession part of the
MA approximation of the instantaneous unit hydrograph."""
coefs = self.coefs
old_dc = coefs[1]-coefs[0]
for idx in range(self.order-2):
new_dc = coefs[idx+2]-coefs[idx+1]
if (old_dc < 0.) and (new_dc > old_dc):
return idx, coefs[idx]
old_dc = new_dc
raise RuntimeError(
'Not able to detect a turning point in the impulse response '
'defined by the MA coefficients %s.'
% objecttools.repr_values(coefs))
|
python
|
def turningpoint(self):
"""Turning point (index and value tuple) in the recession part of the
MA approximation of the instantaneous unit hydrograph."""
coefs = self.coefs
old_dc = coefs[1]-coefs[0]
for idx in range(self.order-2):
new_dc = coefs[idx+2]-coefs[idx+1]
if (old_dc < 0.) and (new_dc > old_dc):
return idx, coefs[idx]
old_dc = new_dc
raise RuntimeError(
'Not able to detect a turning point in the impulse response '
'defined by the MA coefficients %s.'
% objecttools.repr_values(coefs))
|
[
"def",
"turningpoint",
"(",
"self",
")",
":",
"coefs",
"=",
"self",
".",
"coefs",
"old_dc",
"=",
"coefs",
"[",
"1",
"]",
"-",
"coefs",
"[",
"0",
"]",
"for",
"idx",
"in",
"range",
"(",
"self",
".",
"order",
"-",
"2",
")",
":",
"new_dc",
"=",
"coefs",
"[",
"idx",
"+",
"2",
"]",
"-",
"coefs",
"[",
"idx",
"+",
"1",
"]",
"if",
"(",
"old_dc",
"<",
"0.",
")",
"and",
"(",
"new_dc",
">",
"old_dc",
")",
":",
"return",
"idx",
",",
"coefs",
"[",
"idx",
"]",
"old_dc",
"=",
"new_dc",
"raise",
"RuntimeError",
"(",
"'Not able to detect a turning point in the impulse response '",
"'defined by the MA coefficients %s.'",
"%",
"objecttools",
".",
"repr_values",
"(",
"coefs",
")",
")"
] |
Turning point (index and value tuple) in the recession part of the
MA approximation of the instantaneous unit hydrograph.
|
[
"Turning",
"point",
"(",
"index",
"and",
"value",
"tuple",
")",
"in",
"the",
"recession",
"part",
"of",
"the",
"MA",
"approximation",
"of",
"the",
"instantaneous",
"unit",
"hydrograph",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/armatools.py#L236-L249
|
hydpy-dev/hydpy
|
hydpy/auxs/armatools.py
|
MA.moments
|
def moments(self):
"""The first two time delay weighted statistical moments of the
MA coefficients."""
moment1 = statstools.calc_mean_time(self.delays, self.coefs)
moment2 = statstools.calc_mean_time_deviation(
self.delays, self.coefs, moment1)
return numpy.array([moment1, moment2])
|
python
|
def moments(self):
"""The first two time delay weighted statistical moments of the
MA coefficients."""
moment1 = statstools.calc_mean_time(self.delays, self.coefs)
moment2 = statstools.calc_mean_time_deviation(
self.delays, self.coefs, moment1)
return numpy.array([moment1, moment2])
|
[
"def",
"moments",
"(",
"self",
")",
":",
"moment1",
"=",
"statstools",
".",
"calc_mean_time",
"(",
"self",
".",
"delays",
",",
"self",
".",
"coefs",
")",
"moment2",
"=",
"statstools",
".",
"calc_mean_time_deviation",
"(",
"self",
".",
"delays",
",",
"self",
".",
"coefs",
",",
"moment1",
")",
"return",
"numpy",
".",
"array",
"(",
"[",
"moment1",
",",
"moment2",
"]",
")"
] |
The first two time delay weighted statistical moments of the
MA coefficients.
|
[
"The",
"first",
"two",
"time",
"delay",
"weighted",
"statistical",
"moments",
"of",
"the",
"MA",
"coefficients",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/armatools.py#L257-L263
|
hydpy-dev/hydpy
|
hydpy/auxs/armatools.py
|
ARMA.effective_max_ar_order
|
def effective_max_ar_order(self):
"""The maximum number of AR coefficients that shall or can be
determined.
It is the minimum of |ARMA.max_ar_order| and the number of
coefficients of the pure |MA| after their turning point.
"""
return min(self.max_ar_order, self.ma.order-self.ma.turningpoint[0]-1)
|
python
|
def effective_max_ar_order(self):
"""The maximum number of AR coefficients that shall or can be
determined.
It is the minimum of |ARMA.max_ar_order| and the number of
coefficients of the pure |MA| after their turning point.
"""
return min(self.max_ar_order, self.ma.order-self.ma.turningpoint[0]-1)
|
[
"def",
"effective_max_ar_order",
"(",
"self",
")",
":",
"return",
"min",
"(",
"self",
".",
"max_ar_order",
",",
"self",
".",
"ma",
".",
"order",
"-",
"self",
".",
"ma",
".",
"turningpoint",
"[",
"0",
"]",
"-",
"1",
")"
] |
The maximum number of AR coefficients that shall or can be
determined.
It is the minimum of |ARMA.max_ar_order| and the number of
coefficients of the pure |MA| after their turning point.
|
[
"The",
"maximum",
"number",
"of",
"AR",
"coefficients",
"that",
"shall",
"or",
"can",
"be",
"determined",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/armatools.py#L548-L555
|
hydpy-dev/hydpy
|
hydpy/auxs/armatools.py
|
ARMA.update_ar_coefs
|
def update_ar_coefs(self):
"""Determine the AR coefficients.
The number of AR coefficients is subsequently increased until the
required precision |ARMA.max_rel_rmse| is reached. Otherwise,
a |RuntimeError| is raised.
"""
del self.ar_coefs
for ar_order in range(1, self.effective_max_ar_order+1):
self.calc_all_ar_coefs(ar_order, self.ma)
if self._rel_rmse < self.max_rel_rmse:
break
else:
with hydpy.pub.options.reprdigits(12):
raise RuntimeError(
f'Method `update_ar_coefs` is not able to determine '
f'the AR coefficients of the ARMA model with the desired '
f'accuracy. You can either set the tolerance value '
f'`max_rel_rmse` to a higher value or increase the '
f'allowed `max_ar_order`. An accuracy of `'
f'{objecttools.repr_(self._rel_rmse)}` has been reached '
f'using `{self.effective_max_ar_order}` coefficients.')
|
python
|
def update_ar_coefs(self):
"""Determine the AR coefficients.
The number of AR coefficients is subsequently increased until the
required precision |ARMA.max_rel_rmse| is reached. Otherwise,
a |RuntimeError| is raised.
"""
del self.ar_coefs
for ar_order in range(1, self.effective_max_ar_order+1):
self.calc_all_ar_coefs(ar_order, self.ma)
if self._rel_rmse < self.max_rel_rmse:
break
else:
with hydpy.pub.options.reprdigits(12):
raise RuntimeError(
f'Method `update_ar_coefs` is not able to determine '
f'the AR coefficients of the ARMA model with the desired '
f'accuracy. You can either set the tolerance value '
f'`max_rel_rmse` to a higher value or increase the '
f'allowed `max_ar_order`. An accuracy of `'
f'{objecttools.repr_(self._rel_rmse)}` has been reached '
f'using `{self.effective_max_ar_order}` coefficients.')
|
[
"def",
"update_ar_coefs",
"(",
"self",
")",
":",
"del",
"self",
".",
"ar_coefs",
"for",
"ar_order",
"in",
"range",
"(",
"1",
",",
"self",
".",
"effective_max_ar_order",
"+",
"1",
")",
":",
"self",
".",
"calc_all_ar_coefs",
"(",
"ar_order",
",",
"self",
".",
"ma",
")",
"if",
"self",
".",
"_rel_rmse",
"<",
"self",
".",
"max_rel_rmse",
":",
"break",
"else",
":",
"with",
"hydpy",
".",
"pub",
".",
"options",
".",
"reprdigits",
"(",
"12",
")",
":",
"raise",
"RuntimeError",
"(",
"f'Method `update_ar_coefs` is not able to determine '",
"f'the AR coefficients of the ARMA model with the desired '",
"f'accuracy. You can either set the tolerance value '",
"f'`max_rel_rmse` to a higher value or increase the '",
"f'allowed `max_ar_order`. An accuracy of `'",
"f'{objecttools.repr_(self._rel_rmse)}` has been reached '",
"f'using `{self.effective_max_ar_order}` coefficients.'",
")"
] |
Determine the AR coefficients.
The number of AR coefficients is subsequently increased until the
required precision |ARMA.max_rel_rmse| is reached. Otherwise,
a |RuntimeError| is raised.
|
[
"Determine",
"the",
"AR",
"coefficients",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/armatools.py#L557-L578
|
hydpy-dev/hydpy
|
hydpy/auxs/armatools.py
|
ARMA.dev_moments
|
def dev_moments(self):
"""Sum of the absolute deviations between the central moments of the
instantaneous unit hydrograph and the ARMA approximation."""
return numpy.sum(numpy.abs(self.moments-self.ma.moments))
|
python
|
def dev_moments(self):
"""Sum of the absolute deviations between the central moments of the
instantaneous unit hydrograph and the ARMA approximation."""
return numpy.sum(numpy.abs(self.moments-self.ma.moments))
|
[
"def",
"dev_moments",
"(",
"self",
")",
":",
"return",
"numpy",
".",
"sum",
"(",
"numpy",
".",
"abs",
"(",
"self",
".",
"moments",
"-",
"self",
".",
"ma",
".",
"moments",
")",
")"
] |
Sum of the absolute deviations between the central moments of the
instantaneous unit hydrograph and the ARMA approximation.
|
[
"Sum",
"of",
"the",
"absolute",
"deviations",
"between",
"the",
"central",
"moments",
"of",
"the",
"instantaneous",
"unit",
"hydrograph",
"and",
"the",
"ARMA",
"approximation",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/armatools.py#L581-L584
|
hydpy-dev/hydpy
|
hydpy/auxs/armatools.py
|
ARMA.norm_coefs
|
def norm_coefs(self):
"""Multiply all coefficients by the same factor, so that their sum
becomes one."""
sum_coefs = self.sum_coefs
self.ar_coefs /= sum_coefs
self.ma_coefs /= sum_coefs
|
python
|
def norm_coefs(self):
"""Multiply all coefficients by the same factor, so that their sum
becomes one."""
sum_coefs = self.sum_coefs
self.ar_coefs /= sum_coefs
self.ma_coefs /= sum_coefs
|
[
"def",
"norm_coefs",
"(",
"self",
")",
":",
"sum_coefs",
"=",
"self",
".",
"sum_coefs",
"self",
".",
"ar_coefs",
"/=",
"sum_coefs",
"self",
".",
"ma_coefs",
"/=",
"sum_coefs"
] |
Multiply all coefficients by the same factor, so that their sum
becomes one.
|
[
"Multiply",
"all",
"coefficients",
"by",
"the",
"same",
"factor",
"so",
"that",
"their",
"sum",
"becomes",
"one",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/armatools.py#L586-L591
|
hydpy-dev/hydpy
|
hydpy/auxs/armatools.py
|
ARMA.sum_coefs
|
def sum_coefs(self):
"""The sum of all AR and MA coefficients"""
return numpy.sum(self.ar_coefs) + numpy.sum(self.ma_coefs)
|
python
|
def sum_coefs(self):
"""The sum of all AR and MA coefficients"""
return numpy.sum(self.ar_coefs) + numpy.sum(self.ma_coefs)
|
[
"def",
"sum_coefs",
"(",
"self",
")",
":",
"return",
"numpy",
".",
"sum",
"(",
"self",
".",
"ar_coefs",
")",
"+",
"numpy",
".",
"sum",
"(",
"self",
".",
"ma_coefs",
")"
] |
The sum of all AR and MA coefficients
|
[
"The",
"sum",
"of",
"all",
"AR",
"and",
"MA",
"coefficients"
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/armatools.py#L594-L596
|
hydpy-dev/hydpy
|
hydpy/auxs/armatools.py
|
ARMA.calc_all_ar_coefs
|
def calc_all_ar_coefs(self, ar_order, ma_model):
"""Determine the AR coeffcients based on a least squares approach.
The argument `ar_order` defines the number of AR coefficients to be
determined. The argument `ma_order` defines a pure |MA| model.
The least squares approach is applied on all those coefficents of the
pure MA model, which are associated with the part of the recession
curve behind its turning point.
The attribute |ARMA.rel_rmse| is updated with the resulting
relative root mean square error.
"""
turning_idx, _ = ma_model.turningpoint
values = ma_model.coefs[turning_idx:]
self.ar_coefs, residuals = numpy.linalg.lstsq(
self.get_a(values, ar_order),
self.get_b(values, ar_order),
rcond=-1)[:2]
if len(residuals) == 1:
self._rel_rmse = numpy.sqrt(residuals[0])/numpy.sum(values)
else:
self._rel_rmse = 0.
|
python
|
def calc_all_ar_coefs(self, ar_order, ma_model):
"""Determine the AR coeffcients based on a least squares approach.
The argument `ar_order` defines the number of AR coefficients to be
determined. The argument `ma_order` defines a pure |MA| model.
The least squares approach is applied on all those coefficents of the
pure MA model, which are associated with the part of the recession
curve behind its turning point.
The attribute |ARMA.rel_rmse| is updated with the resulting
relative root mean square error.
"""
turning_idx, _ = ma_model.turningpoint
values = ma_model.coefs[turning_idx:]
self.ar_coefs, residuals = numpy.linalg.lstsq(
self.get_a(values, ar_order),
self.get_b(values, ar_order),
rcond=-1)[:2]
if len(residuals) == 1:
self._rel_rmse = numpy.sqrt(residuals[0])/numpy.sum(values)
else:
self._rel_rmse = 0.
|
[
"def",
"calc_all_ar_coefs",
"(",
"self",
",",
"ar_order",
",",
"ma_model",
")",
":",
"turning_idx",
",",
"_",
"=",
"ma_model",
".",
"turningpoint",
"values",
"=",
"ma_model",
".",
"coefs",
"[",
"turning_idx",
":",
"]",
"self",
".",
"ar_coefs",
",",
"residuals",
"=",
"numpy",
".",
"linalg",
".",
"lstsq",
"(",
"self",
".",
"get_a",
"(",
"values",
",",
"ar_order",
")",
",",
"self",
".",
"get_b",
"(",
"values",
",",
"ar_order",
")",
",",
"rcond",
"=",
"-",
"1",
")",
"[",
":",
"2",
"]",
"if",
"len",
"(",
"residuals",
")",
"==",
"1",
":",
"self",
".",
"_rel_rmse",
"=",
"numpy",
".",
"sqrt",
"(",
"residuals",
"[",
"0",
"]",
")",
"/",
"numpy",
".",
"sum",
"(",
"values",
")",
"else",
":",
"self",
".",
"_rel_rmse",
"=",
"0."
] |
Determine the AR coeffcients based on a least squares approach.
The argument `ar_order` defines the number of AR coefficients to be
determined. The argument `ma_order` defines a pure |MA| model.
The least squares approach is applied on all those coefficents of the
pure MA model, which are associated with the part of the recession
curve behind its turning point.
The attribute |ARMA.rel_rmse| is updated with the resulting
relative root mean square error.
|
[
"Determine",
"the",
"AR",
"coeffcients",
"based",
"on",
"a",
"least",
"squares",
"approach",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/armatools.py#L603-L624
|
hydpy-dev/hydpy
|
hydpy/auxs/armatools.py
|
ARMA.get_a
|
def get_a(values, n):
"""Extract the independent variables of the given values and return
them as a matrix with n columns in a form suitable for the least
squares approach applied in method |ARMA.update_ar_coefs|.
"""
m = len(values)-n
a = numpy.empty((m, n), dtype=float)
for i in range(m):
i0 = i-1 if i > 0 else None
i1 = i+n-1
a[i] = values[i1:i0:-1]
return numpy.array(a)
|
python
|
def get_a(values, n):
"""Extract the independent variables of the given values and return
them as a matrix with n columns in a form suitable for the least
squares approach applied in method |ARMA.update_ar_coefs|.
"""
m = len(values)-n
a = numpy.empty((m, n), dtype=float)
for i in range(m):
i0 = i-1 if i > 0 else None
i1 = i+n-1
a[i] = values[i1:i0:-1]
return numpy.array(a)
|
[
"def",
"get_a",
"(",
"values",
",",
"n",
")",
":",
"m",
"=",
"len",
"(",
"values",
")",
"-",
"n",
"a",
"=",
"numpy",
".",
"empty",
"(",
"(",
"m",
",",
"n",
")",
",",
"dtype",
"=",
"float",
")",
"for",
"i",
"in",
"range",
"(",
"m",
")",
":",
"i0",
"=",
"i",
"-",
"1",
"if",
"i",
">",
"0",
"else",
"None",
"i1",
"=",
"i",
"+",
"n",
"-",
"1",
"a",
"[",
"i",
"]",
"=",
"values",
"[",
"i1",
":",
"i0",
":",
"-",
"1",
"]",
"return",
"numpy",
".",
"array",
"(",
"a",
")"
] |
Extract the independent variables of the given values and return
them as a matrix with n columns in a form suitable for the least
squares approach applied in method |ARMA.update_ar_coefs|.
|
[
"Extract",
"the",
"independent",
"variables",
"of",
"the",
"given",
"values",
"and",
"return",
"them",
"as",
"a",
"matrix",
"with",
"n",
"columns",
"in",
"a",
"form",
"suitable",
"for",
"the",
"least",
"squares",
"approach",
"applied",
"in",
"method",
"|ARMA",
".",
"update_ar_coefs|",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/armatools.py#L627-L638
|
hydpy-dev/hydpy
|
hydpy/auxs/armatools.py
|
ARMA.update_ma_coefs
|
def update_ma_coefs(self):
"""Determine the MA coefficients.
The number of MA coefficients is subsequently increased until the
required precision |ARMA.max_dev_coefs| is reached. Otherwise,
a |RuntimeError| is raised.
"""
self.ma_coefs = []
for ma_order in range(1, self.ma.order+1):
self.calc_next_ma_coef(ma_order, self.ma)
if self.dev_coefs < self.max_dev_coefs:
self.norm_coefs()
break
else:
with hydpy.pub.options.reprdigits(12):
raise RuntimeError(
f'Method `update_ma_coefs` is not able to determine the '
f'MA coefficients of the ARMA model with the desired '
f'accuracy. You can set the tolerance value '
f'´max_dev_coefs` to a higher value. An accuracy of '
f'`{objecttools.repr_(self.dev_coefs)}` has been reached '
f'using `{self.ma.order}` MA coefficients.')
if numpy.min(self.response) < 0.:
warnings.warn(
'Note that the smallest response to a standard impulse of the '
'determined ARMA model is negative (`%s`).'
% objecttools.repr_(numpy.min(self.response)))
|
python
|
def update_ma_coefs(self):
"""Determine the MA coefficients.
The number of MA coefficients is subsequently increased until the
required precision |ARMA.max_dev_coefs| is reached. Otherwise,
a |RuntimeError| is raised.
"""
self.ma_coefs = []
for ma_order in range(1, self.ma.order+1):
self.calc_next_ma_coef(ma_order, self.ma)
if self.dev_coefs < self.max_dev_coefs:
self.norm_coefs()
break
else:
with hydpy.pub.options.reprdigits(12):
raise RuntimeError(
f'Method `update_ma_coefs` is not able to determine the '
f'MA coefficients of the ARMA model with the desired '
f'accuracy. You can set the tolerance value '
f'´max_dev_coefs` to a higher value. An accuracy of '
f'`{objecttools.repr_(self.dev_coefs)}` has been reached '
f'using `{self.ma.order}` MA coefficients.')
if numpy.min(self.response) < 0.:
warnings.warn(
'Note that the smallest response to a standard impulse of the '
'determined ARMA model is negative (`%s`).'
% objecttools.repr_(numpy.min(self.response)))
|
[
"def",
"update_ma_coefs",
"(",
"self",
")",
":",
"self",
".",
"ma_coefs",
"=",
"[",
"]",
"for",
"ma_order",
"in",
"range",
"(",
"1",
",",
"self",
".",
"ma",
".",
"order",
"+",
"1",
")",
":",
"self",
".",
"calc_next_ma_coef",
"(",
"ma_order",
",",
"self",
".",
"ma",
")",
"if",
"self",
".",
"dev_coefs",
"<",
"self",
".",
"max_dev_coefs",
":",
"self",
".",
"norm_coefs",
"(",
")",
"break",
"else",
":",
"with",
"hydpy",
".",
"pub",
".",
"options",
".",
"reprdigits",
"(",
"12",
")",
":",
"raise",
"RuntimeError",
"(",
"f'Method `update_ma_coefs` is not able to determine the '",
"f'MA coefficients of the ARMA model with the desired '",
"f'accuracy. You can set the tolerance value '",
"f'´max_dev_coefs` to a higher value. An accuracy of '",
"f'`{objecttools.repr_(self.dev_coefs)}` has been reached '",
"f'using `{self.ma.order}` MA coefficients.'",
")",
"if",
"numpy",
".",
"min",
"(",
"self",
".",
"response",
")",
"<",
"0.",
":",
"warnings",
".",
"warn",
"(",
"'Note that the smallest response to a standard impulse of the '",
"'determined ARMA model is negative (`%s`).'",
"%",
"objecttools",
".",
"repr_",
"(",
"numpy",
".",
"min",
"(",
"self",
".",
"response",
")",
")",
")"
] |
Determine the MA coefficients.
The number of MA coefficients is subsequently increased until the
required precision |ARMA.max_dev_coefs| is reached. Otherwise,
a |RuntimeError| is raised.
|
[
"Determine",
"the",
"MA",
"coefficients",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/armatools.py#L648-L674
|
hydpy-dev/hydpy
|
hydpy/auxs/armatools.py
|
ARMA.calc_next_ma_coef
|
def calc_next_ma_coef(self, ma_order, ma_model):
"""Determine the MA coefficients of the ARMA model based on its
predetermined AR coefficients and the MA ordinates of the given
|MA| model.
The MA coefficients are determined one at a time, beginning with the
first one. Each ARMA MA coefficient in set in a manner that allows
for the exact reproduction of the equivalent pure MA coefficient with
all relevant ARMA coefficients.
"""
idx = ma_order-1
coef = ma_model.coefs[idx]
for jdx, ar_coef in enumerate(self.ar_coefs):
zdx = idx-jdx-1
if zdx >= 0:
coef -= ar_coef*ma_model.coefs[zdx]
self.ma_coefs = numpy.concatenate((self.ma_coefs, [coef]))
|
python
|
def calc_next_ma_coef(self, ma_order, ma_model):
"""Determine the MA coefficients of the ARMA model based on its
predetermined AR coefficients and the MA ordinates of the given
|MA| model.
The MA coefficients are determined one at a time, beginning with the
first one. Each ARMA MA coefficient in set in a manner that allows
for the exact reproduction of the equivalent pure MA coefficient with
all relevant ARMA coefficients.
"""
idx = ma_order-1
coef = ma_model.coefs[idx]
for jdx, ar_coef in enumerate(self.ar_coefs):
zdx = idx-jdx-1
if zdx >= 0:
coef -= ar_coef*ma_model.coefs[zdx]
self.ma_coefs = numpy.concatenate((self.ma_coefs, [coef]))
|
[
"def",
"calc_next_ma_coef",
"(",
"self",
",",
"ma_order",
",",
"ma_model",
")",
":",
"idx",
"=",
"ma_order",
"-",
"1",
"coef",
"=",
"ma_model",
".",
"coefs",
"[",
"idx",
"]",
"for",
"jdx",
",",
"ar_coef",
"in",
"enumerate",
"(",
"self",
".",
"ar_coefs",
")",
":",
"zdx",
"=",
"idx",
"-",
"jdx",
"-",
"1",
"if",
"zdx",
">=",
"0",
":",
"coef",
"-=",
"ar_coef",
"*",
"ma_model",
".",
"coefs",
"[",
"zdx",
"]",
"self",
".",
"ma_coefs",
"=",
"numpy",
".",
"concatenate",
"(",
"(",
"self",
".",
"ma_coefs",
",",
"[",
"coef",
"]",
")",
")"
] |
Determine the MA coefficients of the ARMA model based on its
predetermined AR coefficients and the MA ordinates of the given
|MA| model.
The MA coefficients are determined one at a time, beginning with the
first one. Each ARMA MA coefficient in set in a manner that allows
for the exact reproduction of the equivalent pure MA coefficient with
all relevant ARMA coefficients.
|
[
"Determine",
"the",
"MA",
"coefficients",
"of",
"the",
"ARMA",
"model",
"based",
"on",
"its",
"predetermined",
"AR",
"coefficients",
"and",
"the",
"MA",
"ordinates",
"of",
"the",
"given",
"|MA|",
"model",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/armatools.py#L676-L692
|
hydpy-dev/hydpy
|
hydpy/auxs/armatools.py
|
ARMA.response
|
def response(self):
"""Return the response to a standard dt impulse."""
values = []
sum_values = 0.
ma_coefs = self.ma_coefs
ar_coefs = self.ar_coefs
ma_order = self.ma_order
for idx in range(len(self.ma.delays)):
value = 0.
if idx < ma_order:
value += ma_coefs[idx]
for jdx, ar_coef in enumerate(ar_coefs):
zdx = idx-jdx-1
if zdx >= 0:
value += ar_coef*values[zdx]
values.append(value)
sum_values += value
return numpy.array(values)
|
python
|
def response(self):
"""Return the response to a standard dt impulse."""
values = []
sum_values = 0.
ma_coefs = self.ma_coefs
ar_coefs = self.ar_coefs
ma_order = self.ma_order
for idx in range(len(self.ma.delays)):
value = 0.
if idx < ma_order:
value += ma_coefs[idx]
for jdx, ar_coef in enumerate(ar_coefs):
zdx = idx-jdx-1
if zdx >= 0:
value += ar_coef*values[zdx]
values.append(value)
sum_values += value
return numpy.array(values)
|
[
"def",
"response",
"(",
"self",
")",
":",
"values",
"=",
"[",
"]",
"sum_values",
"=",
"0.",
"ma_coefs",
"=",
"self",
".",
"ma_coefs",
"ar_coefs",
"=",
"self",
".",
"ar_coefs",
"ma_order",
"=",
"self",
".",
"ma_order",
"for",
"idx",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"ma",
".",
"delays",
")",
")",
":",
"value",
"=",
"0.",
"if",
"idx",
"<",
"ma_order",
":",
"value",
"+=",
"ma_coefs",
"[",
"idx",
"]",
"for",
"jdx",
",",
"ar_coef",
"in",
"enumerate",
"(",
"ar_coefs",
")",
":",
"zdx",
"=",
"idx",
"-",
"jdx",
"-",
"1",
"if",
"zdx",
">=",
"0",
":",
"value",
"+=",
"ar_coef",
"*",
"values",
"[",
"zdx",
"]",
"values",
".",
"append",
"(",
"value",
")",
"sum_values",
"+=",
"value",
"return",
"numpy",
".",
"array",
"(",
"values",
")"
] |
Return the response to a standard dt impulse.
|
[
"Return",
"the",
"response",
"to",
"a",
"standard",
"dt",
"impulse",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/armatools.py#L695-L712
|
hydpy-dev/hydpy
|
hydpy/auxs/armatools.py
|
ARMA.moments
|
def moments(self):
"""The first two time delay weighted statistical moments of the
ARMA response."""
timepoints = self.ma.delays
response = self.response
moment1 = statstools.calc_mean_time(timepoints, response)
moment2 = statstools.calc_mean_time_deviation(
timepoints, response, moment1)
return numpy.array([moment1, moment2])
|
python
|
def moments(self):
"""The first two time delay weighted statistical moments of the
ARMA response."""
timepoints = self.ma.delays
response = self.response
moment1 = statstools.calc_mean_time(timepoints, response)
moment2 = statstools.calc_mean_time_deviation(
timepoints, response, moment1)
return numpy.array([moment1, moment2])
|
[
"def",
"moments",
"(",
"self",
")",
":",
"timepoints",
"=",
"self",
".",
"ma",
".",
"delays",
"response",
"=",
"self",
".",
"response",
"moment1",
"=",
"statstools",
".",
"calc_mean_time",
"(",
"timepoints",
",",
"response",
")",
"moment2",
"=",
"statstools",
".",
"calc_mean_time_deviation",
"(",
"timepoints",
",",
"response",
",",
"moment1",
")",
"return",
"numpy",
".",
"array",
"(",
"[",
"moment1",
",",
"moment2",
"]",
")"
] |
The first two time delay weighted statistical moments of the
ARMA response.
|
[
"The",
"first",
"two",
"time",
"delay",
"weighted",
"statistical",
"moments",
"of",
"the",
"ARMA",
"response",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/armatools.py#L715-L723
|
hydpy-dev/hydpy
|
hydpy/auxs/armatools.py
|
ARMA.plot
|
def plot(self, threshold=None, **kwargs):
"""Barplot of the ARMA response."""
try:
# Works under matplotlib 3.
pyplot.bar(x=self.ma.delays+.5, height=self.response,
width=1., fill=False, **kwargs)
except TypeError: # pragma: no cover
# Works under matplotlib 2.
pyplot.bar(left=self.ma.delays+.5, height=self.response,
width=1., fill=False, **kwargs)
pyplot.xlabel('time')
pyplot.ylabel('response')
if threshold is not None:
cumsum = numpy.cumsum(self.response)
idx = numpy.where(cumsum > threshold*cumsum[-1])[0][0]
pyplot.xlim(0., idx)
|
python
|
def plot(self, threshold=None, **kwargs):
"""Barplot of the ARMA response."""
try:
# Works under matplotlib 3.
pyplot.bar(x=self.ma.delays+.5, height=self.response,
width=1., fill=False, **kwargs)
except TypeError: # pragma: no cover
# Works under matplotlib 2.
pyplot.bar(left=self.ma.delays+.5, height=self.response,
width=1., fill=False, **kwargs)
pyplot.xlabel('time')
pyplot.ylabel('response')
if threshold is not None:
cumsum = numpy.cumsum(self.response)
idx = numpy.where(cumsum > threshold*cumsum[-1])[0][0]
pyplot.xlim(0., idx)
|
[
"def",
"plot",
"(",
"self",
",",
"threshold",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"# Works under matplotlib 3.",
"pyplot",
".",
"bar",
"(",
"x",
"=",
"self",
".",
"ma",
".",
"delays",
"+",
".5",
",",
"height",
"=",
"self",
".",
"response",
",",
"width",
"=",
"1.",
",",
"fill",
"=",
"False",
",",
"*",
"*",
"kwargs",
")",
"except",
"TypeError",
":",
"# pragma: no cover",
"# Works under matplotlib 2.",
"pyplot",
".",
"bar",
"(",
"left",
"=",
"self",
".",
"ma",
".",
"delays",
"+",
".5",
",",
"height",
"=",
"self",
".",
"response",
",",
"width",
"=",
"1.",
",",
"fill",
"=",
"False",
",",
"*",
"*",
"kwargs",
")",
"pyplot",
".",
"xlabel",
"(",
"'time'",
")",
"pyplot",
".",
"ylabel",
"(",
"'response'",
")",
"if",
"threshold",
"is",
"not",
"None",
":",
"cumsum",
"=",
"numpy",
".",
"cumsum",
"(",
"self",
".",
"response",
")",
"idx",
"=",
"numpy",
".",
"where",
"(",
"cumsum",
">",
"threshold",
"*",
"cumsum",
"[",
"-",
"1",
"]",
")",
"[",
"0",
"]",
"[",
"0",
"]",
"pyplot",
".",
"xlim",
"(",
"0.",
",",
"idx",
")"
] |
Barplot of the ARMA response.
|
[
"Barplot",
"of",
"the",
"ARMA",
"response",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/armatools.py#L725-L740
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
method_header
|
def method_header(method_name, nogil=False, idx_as_arg=False):
"""Returns the Cython method header for methods without arguments except
`self`."""
if not config.FASTCYTHON:
nogil = False
header = 'cpdef inline void %s(self' % method_name
header += ', int idx)' if idx_as_arg else ')'
header += ' nogil:' if nogil else ':'
return header
|
python
|
def method_header(method_name, nogil=False, idx_as_arg=False):
"""Returns the Cython method header for methods without arguments except
`self`."""
if not config.FASTCYTHON:
nogil = False
header = 'cpdef inline void %s(self' % method_name
header += ', int idx)' if idx_as_arg else ')'
header += ' nogil:' if nogil else ':'
return header
|
[
"def",
"method_header",
"(",
"method_name",
",",
"nogil",
"=",
"False",
",",
"idx_as_arg",
"=",
"False",
")",
":",
"if",
"not",
"config",
".",
"FASTCYTHON",
":",
"nogil",
"=",
"False",
"header",
"=",
"'cpdef inline void %s(self'",
"%",
"method_name",
"header",
"+=",
"', int idx)'",
"if",
"idx_as_arg",
"else",
"')'",
"header",
"+=",
"' nogil:'",
"if",
"nogil",
"else",
"':'",
"return",
"header"
] |
Returns the Cython method header for methods without arguments except
`self`.
|
[
"Returns",
"the",
"Cython",
"method",
"header",
"for",
"methods",
"without",
"arguments",
"except",
"self",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L80-L88
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
decorate_method
|
def decorate_method(wrapped):
"""The decorated method will return a |Lines| object including
a method header. However, the |Lines| object will be empty if
the respective model does not implement a method with the same
name as the wrapped method.
"""
def wrapper(self):
lines = Lines()
if hasattr(self.model, wrapped.__name__):
print(' . %s' % wrapped.__name__)
lines.add(1, method_header(wrapped.__name__, nogil=True))
for line in wrapped(self):
lines.add(2, line)
return lines
functools.update_wrapper(wrapper, wrapped)
wrapper.__doc__ = 'Lines of model method %s.' % wrapped.__name__
return property(wrapper)
|
python
|
def decorate_method(wrapped):
"""The decorated method will return a |Lines| object including
a method header. However, the |Lines| object will be empty if
the respective model does not implement a method with the same
name as the wrapped method.
"""
def wrapper(self):
lines = Lines()
if hasattr(self.model, wrapped.__name__):
print(' . %s' % wrapped.__name__)
lines.add(1, method_header(wrapped.__name__, nogil=True))
for line in wrapped(self):
lines.add(2, line)
return lines
functools.update_wrapper(wrapper, wrapped)
wrapper.__doc__ = 'Lines of model method %s.' % wrapped.__name__
return property(wrapper)
|
[
"def",
"decorate_method",
"(",
"wrapped",
")",
":",
"def",
"wrapper",
"(",
"self",
")",
":",
"lines",
"=",
"Lines",
"(",
")",
"if",
"hasattr",
"(",
"self",
".",
"model",
",",
"wrapped",
".",
"__name__",
")",
":",
"print",
"(",
"' . %s'",
"%",
"wrapped",
".",
"__name__",
")",
"lines",
".",
"add",
"(",
"1",
",",
"method_header",
"(",
"wrapped",
".",
"__name__",
",",
"nogil",
"=",
"True",
")",
")",
"for",
"line",
"in",
"wrapped",
"(",
"self",
")",
":",
"lines",
".",
"add",
"(",
"2",
",",
"line",
")",
"return",
"lines",
"functools",
".",
"update_wrapper",
"(",
"wrapper",
",",
"wrapped",
")",
"wrapper",
".",
"__doc__",
"=",
"'Lines of model method %s.'",
"%",
"wrapped",
".",
"__name__",
"return",
"property",
"(",
"wrapper",
")"
] |
The decorated method will return a |Lines| object including
a method header. However, the |Lines| object will be empty if
the respective model does not implement a method with the same
name as the wrapped method.
|
[
"The",
"decorated",
"method",
"will",
"return",
"a",
"|Lines|",
"object",
"including",
"a",
"method",
"header",
".",
"However",
"the",
"|Lines|",
"object",
"will",
"be",
"empty",
"if",
"the",
"respective",
"model",
"does",
"not",
"implement",
"a",
"method",
"with",
"the",
"same",
"name",
"as",
"the",
"wrapped",
"method",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L91-L107
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
Lines.add
|
def add(self, indent, line):
"""Appends the given text line with prefixed spaces in accordance with
the given number of indentation levels.
"""
if isinstance(line, str):
list.append(self, indent*4*' ' + line)
else:
for subline in line:
list.append(self, indent*4*' ' + subline)
|
python
|
def add(self, indent, line):
"""Appends the given text line with prefixed spaces in accordance with
the given number of indentation levels.
"""
if isinstance(line, str):
list.append(self, indent*4*' ' + line)
else:
for subline in line:
list.append(self, indent*4*' ' + subline)
|
[
"def",
"add",
"(",
"self",
",",
"indent",
",",
"line",
")",
":",
"if",
"isinstance",
"(",
"line",
",",
"str",
")",
":",
"list",
".",
"append",
"(",
"self",
",",
"indent",
"*",
"4",
"*",
"' '",
"+",
"line",
")",
"else",
":",
"for",
"subline",
"in",
"line",
":",
"list",
".",
"append",
"(",
"self",
",",
"indent",
"*",
"4",
"*",
"' '",
"+",
"subline",
")"
] |
Appends the given text line with prefixed spaces in accordance with
the given number of indentation levels.
|
[
"Appends",
"the",
"given",
"text",
"line",
"with",
"prefixed",
"spaces",
"in",
"accordance",
"with",
"the",
"given",
"number",
"of",
"indentation",
"levels",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L66-L74
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
Cythonizer.pyname
|
def pyname(self):
"""Name of the compiled module."""
if self.pymodule.endswith('__init__'):
return self.pymodule.split('.')[-2]
else:
return self.pymodule.split('.')[-1]
|
python
|
def pyname(self):
"""Name of the compiled module."""
if self.pymodule.endswith('__init__'):
return self.pymodule.split('.')[-2]
else:
return self.pymodule.split('.')[-1]
|
[
"def",
"pyname",
"(",
"self",
")",
":",
"if",
"self",
".",
"pymodule",
".",
"endswith",
"(",
"'__init__'",
")",
":",
"return",
"self",
".",
"pymodule",
".",
"split",
"(",
"'.'",
")",
"[",
"-",
"2",
"]",
"else",
":",
"return",
"self",
".",
"pymodule",
".",
"split",
"(",
"'.'",
")",
"[",
"-",
"1",
"]"
] |
Name of the compiled module.
|
[
"Name",
"of",
"the",
"compiled",
"module",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L147-L152
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
Cythonizer.pyxwriter
|
def pyxwriter(self):
"""Update the pyx file."""
model = self.Model()
if hasattr(self, 'Parameters'):
model.parameters = self.Parameters(vars(self))
else:
model.parameters = parametertools.Parameters(vars(self))
if hasattr(self, 'Sequences'):
model.sequences = self.Sequences(model=model, **vars(self))
else:
model.sequences = sequencetools.Sequences(model=model,
**vars(self))
return PyxWriter(self, model, self.pyxfilepath)
|
python
|
def pyxwriter(self):
"""Update the pyx file."""
model = self.Model()
if hasattr(self, 'Parameters'):
model.parameters = self.Parameters(vars(self))
else:
model.parameters = parametertools.Parameters(vars(self))
if hasattr(self, 'Sequences'):
model.sequences = self.Sequences(model=model, **vars(self))
else:
model.sequences = sequencetools.Sequences(model=model,
**vars(self))
return PyxWriter(self, model, self.pyxfilepath)
|
[
"def",
"pyxwriter",
"(",
"self",
")",
":",
"model",
"=",
"self",
".",
"Model",
"(",
")",
"if",
"hasattr",
"(",
"self",
",",
"'Parameters'",
")",
":",
"model",
".",
"parameters",
"=",
"self",
".",
"Parameters",
"(",
"vars",
"(",
"self",
")",
")",
"else",
":",
"model",
".",
"parameters",
"=",
"parametertools",
".",
"Parameters",
"(",
"vars",
"(",
"self",
")",
")",
"if",
"hasattr",
"(",
"self",
",",
"'Sequences'",
")",
":",
"model",
".",
"sequences",
"=",
"self",
".",
"Sequences",
"(",
"model",
"=",
"model",
",",
"*",
"*",
"vars",
"(",
"self",
")",
")",
"else",
":",
"model",
".",
"sequences",
"=",
"sequencetools",
".",
"Sequences",
"(",
"model",
"=",
"model",
",",
"*",
"*",
"vars",
"(",
"self",
")",
")",
"return",
"PyxWriter",
"(",
"self",
",",
"model",
",",
"self",
".",
"pyxfilepath",
")"
] |
Update the pyx file.
|
[
"Update",
"the",
"pyx",
"file",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L185-L197
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
Cythonizer.pysourcefiles
|
def pysourcefiles(self):
"""All source files of the actual models Python classes and their
respective base classes."""
sourcefiles = set()
for (name, child) in vars(self).items():
try:
parents = inspect.getmro(child)
except AttributeError:
continue
for parent in parents:
try:
sourcefile = inspect.getfile(parent)
except TypeError:
break
sourcefiles.add(sourcefile)
return Lines(*sourcefiles)
|
python
|
def pysourcefiles(self):
"""All source files of the actual models Python classes and their
respective base classes."""
sourcefiles = set()
for (name, child) in vars(self).items():
try:
parents = inspect.getmro(child)
except AttributeError:
continue
for parent in parents:
try:
sourcefile = inspect.getfile(parent)
except TypeError:
break
sourcefiles.add(sourcefile)
return Lines(*sourcefiles)
|
[
"def",
"pysourcefiles",
"(",
"self",
")",
":",
"sourcefiles",
"=",
"set",
"(",
")",
"for",
"(",
"name",
",",
"child",
")",
"in",
"vars",
"(",
"self",
")",
".",
"items",
"(",
")",
":",
"try",
":",
"parents",
"=",
"inspect",
".",
"getmro",
"(",
"child",
")",
"except",
"AttributeError",
":",
"continue",
"for",
"parent",
"in",
"parents",
":",
"try",
":",
"sourcefile",
"=",
"inspect",
".",
"getfile",
"(",
"parent",
")",
"except",
"TypeError",
":",
"break",
"sourcefiles",
".",
"add",
"(",
"sourcefile",
")",
"return",
"Lines",
"(",
"*",
"sourcefiles",
")"
] |
All source files of the actual models Python classes and their
respective base classes.
|
[
"All",
"source",
"files",
"of",
"the",
"actual",
"models",
"Python",
"classes",
"and",
"their",
"respective",
"base",
"classes",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L200-L215
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
Cythonizer.outdated
|
def outdated(self):
"""True if at least one of the |Cythonizer.pysourcefiles| is
newer than the compiled file under |Cythonizer.pyxfilepath|,
otherwise False.
"""
if hydpy.pub.options.forcecompiling:
return True
if os.path.split(hydpy.__path__[0])[-2].endswith('-packages'):
return False
if not os.path.exists(self.dllfilepath):
return True
cydate = os.stat(self.dllfilepath).st_mtime
for pysourcefile in self.pysourcefiles:
pydate = os.stat(pysourcefile).st_mtime
if pydate > cydate:
return True
return False
|
python
|
def outdated(self):
"""True if at least one of the |Cythonizer.pysourcefiles| is
newer than the compiled file under |Cythonizer.pyxfilepath|,
otherwise False.
"""
if hydpy.pub.options.forcecompiling:
return True
if os.path.split(hydpy.__path__[0])[-2].endswith('-packages'):
return False
if not os.path.exists(self.dllfilepath):
return True
cydate = os.stat(self.dllfilepath).st_mtime
for pysourcefile in self.pysourcefiles:
pydate = os.stat(pysourcefile).st_mtime
if pydate > cydate:
return True
return False
|
[
"def",
"outdated",
"(",
"self",
")",
":",
"if",
"hydpy",
".",
"pub",
".",
"options",
".",
"forcecompiling",
":",
"return",
"True",
"if",
"os",
".",
"path",
".",
"split",
"(",
"hydpy",
".",
"__path__",
"[",
"0",
"]",
")",
"[",
"-",
"2",
"]",
".",
"endswith",
"(",
"'-packages'",
")",
":",
"return",
"False",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"self",
".",
"dllfilepath",
")",
":",
"return",
"True",
"cydate",
"=",
"os",
".",
"stat",
"(",
"self",
".",
"dllfilepath",
")",
".",
"st_mtime",
"for",
"pysourcefile",
"in",
"self",
".",
"pysourcefiles",
":",
"pydate",
"=",
"os",
".",
"stat",
"(",
"pysourcefile",
")",
".",
"st_mtime",
"if",
"pydate",
">",
"cydate",
":",
"return",
"True",
"return",
"False"
] |
True if at least one of the |Cythonizer.pysourcefiles| is
newer than the compiled file under |Cythonizer.pyxfilepath|,
otherwise False.
|
[
"True",
"if",
"at",
"least",
"one",
"of",
"the",
"|Cythonizer",
".",
"pysourcefiles|",
"is",
"newer",
"than",
"the",
"compiled",
"file",
"under",
"|Cythonizer",
".",
"pyxfilepath|",
"otherwise",
"False",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L218-L234
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
Cythonizer.compile_
|
def compile_(self):
"""Translate cython code to C code and compile it."""
from Cython import Build
argv = copy.deepcopy(sys.argv)
sys.argv = [sys.argv[0], 'build_ext', '--build-lib='+self.buildpath]
exc_modules = [
distutils.extension.Extension(
'hydpy.cythons.autogen.'+self.cyname,
[self.pyxfilepath], extra_compile_args=['-O2'])]
distutils.core.setup(ext_modules=Build.cythonize(exc_modules),
include_dirs=[numpy.get_include()])
sys.argv = argv
|
python
|
def compile_(self):
"""Translate cython code to C code and compile it."""
from Cython import Build
argv = copy.deepcopy(sys.argv)
sys.argv = [sys.argv[0], 'build_ext', '--build-lib='+self.buildpath]
exc_modules = [
distutils.extension.Extension(
'hydpy.cythons.autogen.'+self.cyname,
[self.pyxfilepath], extra_compile_args=['-O2'])]
distutils.core.setup(ext_modules=Build.cythonize(exc_modules),
include_dirs=[numpy.get_include()])
sys.argv = argv
|
[
"def",
"compile_",
"(",
"self",
")",
":",
"from",
"Cython",
"import",
"Build",
"argv",
"=",
"copy",
".",
"deepcopy",
"(",
"sys",
".",
"argv",
")",
"sys",
".",
"argv",
"=",
"[",
"sys",
".",
"argv",
"[",
"0",
"]",
",",
"'build_ext'",
",",
"'--build-lib='",
"+",
"self",
".",
"buildpath",
"]",
"exc_modules",
"=",
"[",
"distutils",
".",
"extension",
".",
"Extension",
"(",
"'hydpy.cythons.autogen.'",
"+",
"self",
".",
"cyname",
",",
"[",
"self",
".",
"pyxfilepath",
"]",
",",
"extra_compile_args",
"=",
"[",
"'-O2'",
"]",
")",
"]",
"distutils",
".",
"core",
".",
"setup",
"(",
"ext_modules",
"=",
"Build",
".",
"cythonize",
"(",
"exc_modules",
")",
",",
"include_dirs",
"=",
"[",
"numpy",
".",
"get_include",
"(",
")",
"]",
")",
"sys",
".",
"argv",
"=",
"argv"
] |
Translate cython code to C code and compile it.
|
[
"Translate",
"cython",
"code",
"to",
"C",
"code",
"and",
"compile",
"it",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L236-L247
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
Cythonizer.move_dll
|
def move_dll(self):
"""Try to find the resulting dll file and to move it into the
`cythons` package.
Things to be aware of:
* The file extension either `pyd` (Window) or `so` (Linux).
* The folder containing the dll file is system dependent, but is
always a subfolder of the `cythons` package.
* Under Linux, the filename might contain system information, e.g.
...cpython-36m-x86_64-linux-gnu.so.
"""
dirinfos = os.walk(self.buildpath)
next(dirinfos)
system_dependent_filename = None
for dirinfo in dirinfos:
for filename in dirinfo[2]:
if (filename.startswith(self.cyname) and
filename.endswith(dllextension)):
system_dependent_filename = filename
break
if system_dependent_filename:
try:
shutil.move(os.path.join(dirinfo[0],
system_dependent_filename),
os.path.join(self.cydirpath,
self.cyname+dllextension))
break
except BaseException:
prefix = ('After trying to cythonize module %s, when '
'trying to move the final cython module %s '
'from directory %s to directory %s'
% (self.pyname, system_dependent_filename,
self.buildpath, self.cydirpath))
suffix = ('A likely error cause is that the cython module '
'%s does already exist in this directory and is '
'currently blocked by another Python process. '
'Maybe it helps to close all Python processes '
'and restart the cyhonization afterwards.'
% self.cyname+dllextension)
objecttools.augment_excmessage(prefix, suffix)
else:
raise IOError('After trying to cythonize module %s, the resulting '
'file %s could neither be found in directory %s nor '
'its subdirectories. The distul report should tell '
'whether the file has been stored somewhere else,'
'is named somehow else, or could not be build at '
'all.' % self.buildpath)
|
python
|
def move_dll(self):
"""Try to find the resulting dll file and to move it into the
`cythons` package.
Things to be aware of:
* The file extension either `pyd` (Window) or `so` (Linux).
* The folder containing the dll file is system dependent, but is
always a subfolder of the `cythons` package.
* Under Linux, the filename might contain system information, e.g.
...cpython-36m-x86_64-linux-gnu.so.
"""
dirinfos = os.walk(self.buildpath)
next(dirinfos)
system_dependent_filename = None
for dirinfo in dirinfos:
for filename in dirinfo[2]:
if (filename.startswith(self.cyname) and
filename.endswith(dllextension)):
system_dependent_filename = filename
break
if system_dependent_filename:
try:
shutil.move(os.path.join(dirinfo[0],
system_dependent_filename),
os.path.join(self.cydirpath,
self.cyname+dllextension))
break
except BaseException:
prefix = ('After trying to cythonize module %s, when '
'trying to move the final cython module %s '
'from directory %s to directory %s'
% (self.pyname, system_dependent_filename,
self.buildpath, self.cydirpath))
suffix = ('A likely error cause is that the cython module '
'%s does already exist in this directory and is '
'currently blocked by another Python process. '
'Maybe it helps to close all Python processes '
'and restart the cyhonization afterwards.'
% self.cyname+dllextension)
objecttools.augment_excmessage(prefix, suffix)
else:
raise IOError('After trying to cythonize module %s, the resulting '
'file %s could neither be found in directory %s nor '
'its subdirectories. The distul report should tell '
'whether the file has been stored somewhere else,'
'is named somehow else, or could not be build at '
'all.' % self.buildpath)
|
[
"def",
"move_dll",
"(",
"self",
")",
":",
"dirinfos",
"=",
"os",
".",
"walk",
"(",
"self",
".",
"buildpath",
")",
"next",
"(",
"dirinfos",
")",
"system_dependent_filename",
"=",
"None",
"for",
"dirinfo",
"in",
"dirinfos",
":",
"for",
"filename",
"in",
"dirinfo",
"[",
"2",
"]",
":",
"if",
"(",
"filename",
".",
"startswith",
"(",
"self",
".",
"cyname",
")",
"and",
"filename",
".",
"endswith",
"(",
"dllextension",
")",
")",
":",
"system_dependent_filename",
"=",
"filename",
"break",
"if",
"system_dependent_filename",
":",
"try",
":",
"shutil",
".",
"move",
"(",
"os",
".",
"path",
".",
"join",
"(",
"dirinfo",
"[",
"0",
"]",
",",
"system_dependent_filename",
")",
",",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"cydirpath",
",",
"self",
".",
"cyname",
"+",
"dllextension",
")",
")",
"break",
"except",
"BaseException",
":",
"prefix",
"=",
"(",
"'After trying to cythonize module %s, when '",
"'trying to move the final cython module %s '",
"'from directory %s to directory %s'",
"%",
"(",
"self",
".",
"pyname",
",",
"system_dependent_filename",
",",
"self",
".",
"buildpath",
",",
"self",
".",
"cydirpath",
")",
")",
"suffix",
"=",
"(",
"'A likely error cause is that the cython module '",
"'%s does already exist in this directory and is '",
"'currently blocked by another Python process. '",
"'Maybe it helps to close all Python processes '",
"'and restart the cyhonization afterwards.'",
"%",
"self",
".",
"cyname",
"+",
"dllextension",
")",
"objecttools",
".",
"augment_excmessage",
"(",
"prefix",
",",
"suffix",
")",
"else",
":",
"raise",
"IOError",
"(",
"'After trying to cythonize module %s, the resulting '",
"'file %s could neither be found in directory %s nor '",
"'its subdirectories. The distul report should tell '",
"'whether the file has been stored somewhere else,'",
"'is named somehow else, or could not be build at '",
"'all.'",
"%",
"self",
".",
"buildpath",
")"
] |
Try to find the resulting dll file and to move it into the
`cythons` package.
Things to be aware of:
* The file extension either `pyd` (Window) or `so` (Linux).
* The folder containing the dll file is system dependent, but is
always a subfolder of the `cythons` package.
* Under Linux, the filename might contain system information, e.g.
...cpython-36m-x86_64-linux-gnu.so.
|
[
"Try",
"to",
"find",
"the",
"resulting",
"dll",
"file",
"and",
"to",
"move",
"it",
"into",
"the",
"cythons",
"package",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L249-L295
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.constants
|
def constants(self):
"""Constants declaration lines."""
lines = Lines()
for (name, member) in vars(self.cythonizer).items():
if (name.isupper() and
(not inspect.isclass(member)) and
(type(member) in TYPE2STR)):
ndim = numpy.array(member).ndim
ctype = TYPE2STR[type(member)] + NDIM2STR[ndim]
lines.add(0, 'cdef public %s %s = %s'
% (ctype, name, member))
return lines
|
python
|
def constants(self):
"""Constants declaration lines."""
lines = Lines()
for (name, member) in vars(self.cythonizer).items():
if (name.isupper() and
(not inspect.isclass(member)) and
(type(member) in TYPE2STR)):
ndim = numpy.array(member).ndim
ctype = TYPE2STR[type(member)] + NDIM2STR[ndim]
lines.add(0, 'cdef public %s %s = %s'
% (ctype, name, member))
return lines
|
[
"def",
"constants",
"(",
"self",
")",
":",
"lines",
"=",
"Lines",
"(",
")",
"for",
"(",
"name",
",",
"member",
")",
"in",
"vars",
"(",
"self",
".",
"cythonizer",
")",
".",
"items",
"(",
")",
":",
"if",
"(",
"name",
".",
"isupper",
"(",
")",
"and",
"(",
"not",
"inspect",
".",
"isclass",
"(",
"member",
")",
")",
"and",
"(",
"type",
"(",
"member",
")",
"in",
"TYPE2STR",
")",
")",
":",
"ndim",
"=",
"numpy",
".",
"array",
"(",
"member",
")",
".",
"ndim",
"ctype",
"=",
"TYPE2STR",
"[",
"type",
"(",
"member",
")",
"]",
"+",
"NDIM2STR",
"[",
"ndim",
"]",
"lines",
".",
"add",
"(",
"0",
",",
"'cdef public %s %s = %s'",
"%",
"(",
"ctype",
",",
"name",
",",
"member",
")",
")",
"return",
"lines"
] |
Constants declaration lines.
|
[
"Constants",
"declaration",
"lines",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L361-L372
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.parameters
|
def parameters(self):
"""Parameter declaration lines."""
lines = Lines()
lines.add(0, '@cython.final')
lines.add(0, 'cdef class Parameters(object):')
for subpars in self.model.parameters:
if subpars:
lines.add(1, 'cdef public %s %s'
% (objecttools.classname(subpars), subpars.name))
for subpars in self.model.parameters:
if subpars:
print(' - %s' % subpars.name)
lines.add(0, '@cython.final')
lines.add(0, 'cdef class %s(object):'
% objecttools.classname(subpars))
for par in subpars:
try:
ctype = TYPE2STR[par.TYPE] + NDIM2STR[par.NDIM]
except KeyError:
ctype = par.TYPE + NDIM2STR[par.NDIM]
lines.add(1, 'cdef public %s %s' % (ctype, par.name))
return lines
|
python
|
def parameters(self):
"""Parameter declaration lines."""
lines = Lines()
lines.add(0, '@cython.final')
lines.add(0, 'cdef class Parameters(object):')
for subpars in self.model.parameters:
if subpars:
lines.add(1, 'cdef public %s %s'
% (objecttools.classname(subpars), subpars.name))
for subpars in self.model.parameters:
if subpars:
print(' - %s' % subpars.name)
lines.add(0, '@cython.final')
lines.add(0, 'cdef class %s(object):'
% objecttools.classname(subpars))
for par in subpars:
try:
ctype = TYPE2STR[par.TYPE] + NDIM2STR[par.NDIM]
except KeyError:
ctype = par.TYPE + NDIM2STR[par.NDIM]
lines.add(1, 'cdef public %s %s' % (ctype, par.name))
return lines
|
[
"def",
"parameters",
"(",
"self",
")",
":",
"lines",
"=",
"Lines",
"(",
")",
"lines",
".",
"add",
"(",
"0",
",",
"'@cython.final'",
")",
"lines",
".",
"add",
"(",
"0",
",",
"'cdef class Parameters(object):'",
")",
"for",
"subpars",
"in",
"self",
".",
"model",
".",
"parameters",
":",
"if",
"subpars",
":",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public %s %s'",
"%",
"(",
"objecttools",
".",
"classname",
"(",
"subpars",
")",
",",
"subpars",
".",
"name",
")",
")",
"for",
"subpars",
"in",
"self",
".",
"model",
".",
"parameters",
":",
"if",
"subpars",
":",
"print",
"(",
"' - %s'",
"%",
"subpars",
".",
"name",
")",
"lines",
".",
"add",
"(",
"0",
",",
"'@cython.final'",
")",
"lines",
".",
"add",
"(",
"0",
",",
"'cdef class %s(object):'",
"%",
"objecttools",
".",
"classname",
"(",
"subpars",
")",
")",
"for",
"par",
"in",
"subpars",
":",
"try",
":",
"ctype",
"=",
"TYPE2STR",
"[",
"par",
".",
"TYPE",
"]",
"+",
"NDIM2STR",
"[",
"par",
".",
"NDIM",
"]",
"except",
"KeyError",
":",
"ctype",
"=",
"par",
".",
"TYPE",
"+",
"NDIM2STR",
"[",
"par",
".",
"NDIM",
"]",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public %s %s'",
"%",
"(",
"ctype",
",",
"par",
".",
"name",
")",
")",
"return",
"lines"
] |
Parameter declaration lines.
|
[
"Parameter",
"declaration",
"lines",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L375-L396
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.sequences
|
def sequences(self):
"""Sequence declaration lines."""
lines = Lines()
lines.add(0, '@cython.final')
lines.add(0, 'cdef class Sequences(object):')
for subseqs in self.model.sequences:
lines.add(1, 'cdef public %s %s'
% (objecttools.classname(subseqs), subseqs.name))
if getattr(self.model.sequences, 'states', None) is not None:
lines.add(1, 'cdef public StateSequences old_states')
lines.add(1, 'cdef public StateSequences new_states')
for subseqs in self.model.sequences:
print(' - %s' % subseqs.name)
lines.add(0, '@cython.final')
lines.add(0, 'cdef class %s(object):'
% objecttools.classname(subseqs))
for seq in subseqs:
ctype = 'double' + NDIM2STR[seq.NDIM]
if isinstance(subseqs, sequencetools.LinkSequences):
if seq.NDIM == 0:
lines.add(1, 'cdef double *%s' % seq.name)
elif seq.NDIM == 1:
lines.add(1, 'cdef double **%s' % seq.name)
lines.add(1, 'cdef public int len_%s' % seq.name)
else:
lines.add(1, 'cdef public %s %s' % (ctype, seq.name))
lines.add(1, 'cdef public int _%s_ndim' % seq.name)
lines.add(1, 'cdef public int _%s_length' % seq.name)
for idx in range(seq.NDIM):
lines.add(1, 'cdef public int _%s_length_%d'
% (seq.name, idx))
if seq.NUMERIC:
ctype_numeric = 'double' + NDIM2STR[seq.NDIM+1]
lines.add(1, 'cdef public %s _%s_points'
% (ctype_numeric, seq.name))
lines.add(1, 'cdef public %s _%s_results'
% (ctype_numeric, seq.name))
if isinstance(subseqs, sequencetools.FluxSequences):
lines.add(1, 'cdef public %s _%s_integrals'
% (ctype_numeric, seq.name))
lines.add(1, 'cdef public %s _%s_sum'
% (ctype, seq.name))
if isinstance(subseqs, sequencetools.IOSequences):
lines.extend(self.iosequence(seq))
if isinstance(subseqs, sequencetools.InputSequences):
lines.extend(self.load_data(subseqs))
if isinstance(subseqs, sequencetools.IOSequences):
lines.extend(self.open_files(subseqs))
lines.extend(self.close_files(subseqs))
if not isinstance(subseqs, sequencetools.InputSequence):
lines.extend(self.save_data(subseqs))
if isinstance(subseqs, sequencetools.LinkSequences):
lines.extend(self.set_pointer(subseqs))
return lines
|
python
|
def sequences(self):
"""Sequence declaration lines."""
lines = Lines()
lines.add(0, '@cython.final')
lines.add(0, 'cdef class Sequences(object):')
for subseqs in self.model.sequences:
lines.add(1, 'cdef public %s %s'
% (objecttools.classname(subseqs), subseqs.name))
if getattr(self.model.sequences, 'states', None) is not None:
lines.add(1, 'cdef public StateSequences old_states')
lines.add(1, 'cdef public StateSequences new_states')
for subseqs in self.model.sequences:
print(' - %s' % subseqs.name)
lines.add(0, '@cython.final')
lines.add(0, 'cdef class %s(object):'
% objecttools.classname(subseqs))
for seq in subseqs:
ctype = 'double' + NDIM2STR[seq.NDIM]
if isinstance(subseqs, sequencetools.LinkSequences):
if seq.NDIM == 0:
lines.add(1, 'cdef double *%s' % seq.name)
elif seq.NDIM == 1:
lines.add(1, 'cdef double **%s' % seq.name)
lines.add(1, 'cdef public int len_%s' % seq.name)
else:
lines.add(1, 'cdef public %s %s' % (ctype, seq.name))
lines.add(1, 'cdef public int _%s_ndim' % seq.name)
lines.add(1, 'cdef public int _%s_length' % seq.name)
for idx in range(seq.NDIM):
lines.add(1, 'cdef public int _%s_length_%d'
% (seq.name, idx))
if seq.NUMERIC:
ctype_numeric = 'double' + NDIM2STR[seq.NDIM+1]
lines.add(1, 'cdef public %s _%s_points'
% (ctype_numeric, seq.name))
lines.add(1, 'cdef public %s _%s_results'
% (ctype_numeric, seq.name))
if isinstance(subseqs, sequencetools.FluxSequences):
lines.add(1, 'cdef public %s _%s_integrals'
% (ctype_numeric, seq.name))
lines.add(1, 'cdef public %s _%s_sum'
% (ctype, seq.name))
if isinstance(subseqs, sequencetools.IOSequences):
lines.extend(self.iosequence(seq))
if isinstance(subseqs, sequencetools.InputSequences):
lines.extend(self.load_data(subseqs))
if isinstance(subseqs, sequencetools.IOSequences):
lines.extend(self.open_files(subseqs))
lines.extend(self.close_files(subseqs))
if not isinstance(subseqs, sequencetools.InputSequence):
lines.extend(self.save_data(subseqs))
if isinstance(subseqs, sequencetools.LinkSequences):
lines.extend(self.set_pointer(subseqs))
return lines
|
[
"def",
"sequences",
"(",
"self",
")",
":",
"lines",
"=",
"Lines",
"(",
")",
"lines",
".",
"add",
"(",
"0",
",",
"'@cython.final'",
")",
"lines",
".",
"add",
"(",
"0",
",",
"'cdef class Sequences(object):'",
")",
"for",
"subseqs",
"in",
"self",
".",
"model",
".",
"sequences",
":",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public %s %s'",
"%",
"(",
"objecttools",
".",
"classname",
"(",
"subseqs",
")",
",",
"subseqs",
".",
"name",
")",
")",
"if",
"getattr",
"(",
"self",
".",
"model",
".",
"sequences",
",",
"'states'",
",",
"None",
")",
"is",
"not",
"None",
":",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public StateSequences old_states'",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public StateSequences new_states'",
")",
"for",
"subseqs",
"in",
"self",
".",
"model",
".",
"sequences",
":",
"print",
"(",
"' - %s'",
"%",
"subseqs",
".",
"name",
")",
"lines",
".",
"add",
"(",
"0",
",",
"'@cython.final'",
")",
"lines",
".",
"add",
"(",
"0",
",",
"'cdef class %s(object):'",
"%",
"objecttools",
".",
"classname",
"(",
"subseqs",
")",
")",
"for",
"seq",
"in",
"subseqs",
":",
"ctype",
"=",
"'double'",
"+",
"NDIM2STR",
"[",
"seq",
".",
"NDIM",
"]",
"if",
"isinstance",
"(",
"subseqs",
",",
"sequencetools",
".",
"LinkSequences",
")",
":",
"if",
"seq",
".",
"NDIM",
"==",
"0",
":",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef double *%s'",
"%",
"seq",
".",
"name",
")",
"elif",
"seq",
".",
"NDIM",
"==",
"1",
":",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef double **%s'",
"%",
"seq",
".",
"name",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public int len_%s'",
"%",
"seq",
".",
"name",
")",
"else",
":",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public %s %s'",
"%",
"(",
"ctype",
",",
"seq",
".",
"name",
")",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public int _%s_ndim'",
"%",
"seq",
".",
"name",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public int _%s_length'",
"%",
"seq",
".",
"name",
")",
"for",
"idx",
"in",
"range",
"(",
"seq",
".",
"NDIM",
")",
":",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public int _%s_length_%d'",
"%",
"(",
"seq",
".",
"name",
",",
"idx",
")",
")",
"if",
"seq",
".",
"NUMERIC",
":",
"ctype_numeric",
"=",
"'double'",
"+",
"NDIM2STR",
"[",
"seq",
".",
"NDIM",
"+",
"1",
"]",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public %s _%s_points'",
"%",
"(",
"ctype_numeric",
",",
"seq",
".",
"name",
")",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public %s _%s_results'",
"%",
"(",
"ctype_numeric",
",",
"seq",
".",
"name",
")",
")",
"if",
"isinstance",
"(",
"subseqs",
",",
"sequencetools",
".",
"FluxSequences",
")",
":",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public %s _%s_integrals'",
"%",
"(",
"ctype_numeric",
",",
"seq",
".",
"name",
")",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public %s _%s_sum'",
"%",
"(",
"ctype",
",",
"seq",
".",
"name",
")",
")",
"if",
"isinstance",
"(",
"subseqs",
",",
"sequencetools",
".",
"IOSequences",
")",
":",
"lines",
".",
"extend",
"(",
"self",
".",
"iosequence",
"(",
"seq",
")",
")",
"if",
"isinstance",
"(",
"subseqs",
",",
"sequencetools",
".",
"InputSequences",
")",
":",
"lines",
".",
"extend",
"(",
"self",
".",
"load_data",
"(",
"subseqs",
")",
")",
"if",
"isinstance",
"(",
"subseqs",
",",
"sequencetools",
".",
"IOSequences",
")",
":",
"lines",
".",
"extend",
"(",
"self",
".",
"open_files",
"(",
"subseqs",
")",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"close_files",
"(",
"subseqs",
")",
")",
"if",
"not",
"isinstance",
"(",
"subseqs",
",",
"sequencetools",
".",
"InputSequence",
")",
":",
"lines",
".",
"extend",
"(",
"self",
".",
"save_data",
"(",
"subseqs",
")",
")",
"if",
"isinstance",
"(",
"subseqs",
",",
"sequencetools",
".",
"LinkSequences",
")",
":",
"lines",
".",
"extend",
"(",
"self",
".",
"set_pointer",
"(",
"subseqs",
")",
")",
"return",
"lines"
] |
Sequence declaration lines.
|
[
"Sequence",
"declaration",
"lines",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L399-L452
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.iosequence
|
def iosequence(seq):
"""Special declaration lines for the given |IOSequence| object.
"""
lines = Lines()
lines.add(1, 'cdef public bint _%s_diskflag' % seq.name)
lines.add(1, 'cdef public str _%s_path' % seq.name)
lines.add(1, 'cdef FILE *_%s_file' % seq.name)
lines.add(1, 'cdef public bint _%s_ramflag' % seq.name)
ctype = 'double' + NDIM2STR[seq.NDIM+1]
lines.add(1, 'cdef public %s _%s_array' % (ctype, seq.name))
return lines
|
python
|
def iosequence(seq):
"""Special declaration lines for the given |IOSequence| object.
"""
lines = Lines()
lines.add(1, 'cdef public bint _%s_diskflag' % seq.name)
lines.add(1, 'cdef public str _%s_path' % seq.name)
lines.add(1, 'cdef FILE *_%s_file' % seq.name)
lines.add(1, 'cdef public bint _%s_ramflag' % seq.name)
ctype = 'double' + NDIM2STR[seq.NDIM+1]
lines.add(1, 'cdef public %s _%s_array' % (ctype, seq.name))
return lines
|
[
"def",
"iosequence",
"(",
"seq",
")",
":",
"lines",
"=",
"Lines",
"(",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public bint _%s_diskflag'",
"%",
"seq",
".",
"name",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public str _%s_path'",
"%",
"seq",
".",
"name",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef FILE *_%s_file'",
"%",
"seq",
".",
"name",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public bint _%s_ramflag'",
"%",
"seq",
".",
"name",
")",
"ctype",
"=",
"'double'",
"+",
"NDIM2STR",
"[",
"seq",
".",
"NDIM",
"+",
"1",
"]",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public %s _%s_array'",
"%",
"(",
"ctype",
",",
"seq",
".",
"name",
")",
")",
"return",
"lines"
] |
Special declaration lines for the given |IOSequence| object.
|
[
"Special",
"declaration",
"lines",
"for",
"the",
"given",
"|IOSequence|",
"object",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L455-L465
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.open_files
|
def open_files(subseqs):
"""Open file statements."""
print(' . open_files')
lines = Lines()
lines.add(1, 'cpdef open_files(self, int idx):')
for seq in subseqs:
lines.add(2, 'if self._%s_diskflag:' % seq.name)
lines.add(3, 'self._%s_file = fopen(str(self._%s_path).encode(), '
'"rb+")' % (2*(seq.name,)))
if seq.NDIM == 0:
lines.add(3,
'fseek(self._%s_file, idx*8, SEEK_SET)' % seq.name)
else:
lines.add(3, 'fseek(self._%s_file, idx*self._%s_length*8, '
'SEEK_SET)' % (2*(seq.name,)))
return lines
|
python
|
def open_files(subseqs):
"""Open file statements."""
print(' . open_files')
lines = Lines()
lines.add(1, 'cpdef open_files(self, int idx):')
for seq in subseqs:
lines.add(2, 'if self._%s_diskflag:' % seq.name)
lines.add(3, 'self._%s_file = fopen(str(self._%s_path).encode(), '
'"rb+")' % (2*(seq.name,)))
if seq.NDIM == 0:
lines.add(3,
'fseek(self._%s_file, idx*8, SEEK_SET)' % seq.name)
else:
lines.add(3, 'fseek(self._%s_file, idx*self._%s_length*8, '
'SEEK_SET)' % (2*(seq.name,)))
return lines
|
[
"def",
"open_files",
"(",
"subseqs",
")",
":",
"print",
"(",
"' . open_files'",
")",
"lines",
"=",
"Lines",
"(",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cpdef open_files(self, int idx):'",
")",
"for",
"seq",
"in",
"subseqs",
":",
"lines",
".",
"add",
"(",
"2",
",",
"'if self._%s_diskflag:'",
"%",
"seq",
".",
"name",
")",
"lines",
".",
"add",
"(",
"3",
",",
"'self._%s_file = fopen(str(self._%s_path).encode(), '",
"'\"rb+\")'",
"%",
"(",
"2",
"*",
"(",
"seq",
".",
"name",
",",
")",
")",
")",
"if",
"seq",
".",
"NDIM",
"==",
"0",
":",
"lines",
".",
"add",
"(",
"3",
",",
"'fseek(self._%s_file, idx*8, SEEK_SET)'",
"%",
"seq",
".",
"name",
")",
"else",
":",
"lines",
".",
"add",
"(",
"3",
",",
"'fseek(self._%s_file, idx*self._%s_length*8, '",
"'SEEK_SET)'",
"%",
"(",
"2",
"*",
"(",
"seq",
".",
"name",
",",
")",
")",
")",
"return",
"lines"
] |
Open file statements.
|
[
"Open",
"file",
"statements",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L468-L483
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.close_files
|
def close_files(subseqs):
"""Close file statements."""
print(' . close_files')
lines = Lines()
lines.add(1, 'cpdef inline close_files(self):')
for seq in subseqs:
lines.add(2, 'if self._%s_diskflag:' % seq.name)
lines.add(3, 'fclose(self._%s_file)' % seq.name)
return lines
|
python
|
def close_files(subseqs):
"""Close file statements."""
print(' . close_files')
lines = Lines()
lines.add(1, 'cpdef inline close_files(self):')
for seq in subseqs:
lines.add(2, 'if self._%s_diskflag:' % seq.name)
lines.add(3, 'fclose(self._%s_file)' % seq.name)
return lines
|
[
"def",
"close_files",
"(",
"subseqs",
")",
":",
"print",
"(",
"' . close_files'",
")",
"lines",
"=",
"Lines",
"(",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cpdef inline close_files(self):'",
")",
"for",
"seq",
"in",
"subseqs",
":",
"lines",
".",
"add",
"(",
"2",
",",
"'if self._%s_diskflag:'",
"%",
"seq",
".",
"name",
")",
"lines",
".",
"add",
"(",
"3",
",",
"'fclose(self._%s_file)'",
"%",
"seq",
".",
"name",
")",
"return",
"lines"
] |
Close file statements.
|
[
"Close",
"file",
"statements",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L486-L494
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.load_data
|
def load_data(subseqs):
"""Load data statements."""
print(' . load_data')
lines = Lines()
lines.add(1, 'cpdef inline void load_data(self, int idx) %s:' % _nogil)
lines.add(2, 'cdef int jdx0, jdx1, jdx2, jdx3, jdx4, jdx5')
for seq in subseqs:
lines.add(2, 'if self._%s_diskflag:' % seq.name)
if seq.NDIM == 0:
lines.add(3, 'fread(&self.%s, 8, 1, self._%s_file)'
% (2*(seq.name,)))
else:
lines.add(3, 'fread(&self.%s[0], 8, self._%s_length, '
'self._%s_file)' % (3*(seq.name,)))
lines.add(2, 'elif self._%s_ramflag:' % seq.name)
if seq.NDIM == 0:
lines.add(3, 'self.%s = self._%s_array[idx]' % (2*(seq.name,)))
else:
indexing = ''
for idx in range(seq.NDIM):
lines.add(3+idx, 'for jdx%d in range(self._%s_length_%d):'
% (idx, seq.name, idx))
indexing += 'jdx%d,' % idx
indexing = indexing[:-1]
lines.add(3+seq.NDIM, 'self.%s[%s] = self._%s_array[idx,%s]'
% (2*(seq.name, indexing)))
return lines
|
python
|
def load_data(subseqs):
"""Load data statements."""
print(' . load_data')
lines = Lines()
lines.add(1, 'cpdef inline void load_data(self, int idx) %s:' % _nogil)
lines.add(2, 'cdef int jdx0, jdx1, jdx2, jdx3, jdx4, jdx5')
for seq in subseqs:
lines.add(2, 'if self._%s_diskflag:' % seq.name)
if seq.NDIM == 0:
lines.add(3, 'fread(&self.%s, 8, 1, self._%s_file)'
% (2*(seq.name,)))
else:
lines.add(3, 'fread(&self.%s[0], 8, self._%s_length, '
'self._%s_file)' % (3*(seq.name,)))
lines.add(2, 'elif self._%s_ramflag:' % seq.name)
if seq.NDIM == 0:
lines.add(3, 'self.%s = self._%s_array[idx]' % (2*(seq.name,)))
else:
indexing = ''
for idx in range(seq.NDIM):
lines.add(3+idx, 'for jdx%d in range(self._%s_length_%d):'
% (idx, seq.name, idx))
indexing += 'jdx%d,' % idx
indexing = indexing[:-1]
lines.add(3+seq.NDIM, 'self.%s[%s] = self._%s_array[idx,%s]'
% (2*(seq.name, indexing)))
return lines
|
[
"def",
"load_data",
"(",
"subseqs",
")",
":",
"print",
"(",
"' . load_data'",
")",
"lines",
"=",
"Lines",
"(",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cpdef inline void load_data(self, int idx) %s:'",
"%",
"_nogil",
")",
"lines",
".",
"add",
"(",
"2",
",",
"'cdef int jdx0, jdx1, jdx2, jdx3, jdx4, jdx5'",
")",
"for",
"seq",
"in",
"subseqs",
":",
"lines",
".",
"add",
"(",
"2",
",",
"'if self._%s_diskflag:'",
"%",
"seq",
".",
"name",
")",
"if",
"seq",
".",
"NDIM",
"==",
"0",
":",
"lines",
".",
"add",
"(",
"3",
",",
"'fread(&self.%s, 8, 1, self._%s_file)'",
"%",
"(",
"2",
"*",
"(",
"seq",
".",
"name",
",",
")",
")",
")",
"else",
":",
"lines",
".",
"add",
"(",
"3",
",",
"'fread(&self.%s[0], 8, self._%s_length, '",
"'self._%s_file)'",
"%",
"(",
"3",
"*",
"(",
"seq",
".",
"name",
",",
")",
")",
")",
"lines",
".",
"add",
"(",
"2",
",",
"'elif self._%s_ramflag:'",
"%",
"seq",
".",
"name",
")",
"if",
"seq",
".",
"NDIM",
"==",
"0",
":",
"lines",
".",
"add",
"(",
"3",
",",
"'self.%s = self._%s_array[idx]'",
"%",
"(",
"2",
"*",
"(",
"seq",
".",
"name",
",",
")",
")",
")",
"else",
":",
"indexing",
"=",
"''",
"for",
"idx",
"in",
"range",
"(",
"seq",
".",
"NDIM",
")",
":",
"lines",
".",
"add",
"(",
"3",
"+",
"idx",
",",
"'for jdx%d in range(self._%s_length_%d):'",
"%",
"(",
"idx",
",",
"seq",
".",
"name",
",",
"idx",
")",
")",
"indexing",
"+=",
"'jdx%d,'",
"%",
"idx",
"indexing",
"=",
"indexing",
"[",
":",
"-",
"1",
"]",
"lines",
".",
"add",
"(",
"3",
"+",
"seq",
".",
"NDIM",
",",
"'self.%s[%s] = self._%s_array[idx,%s]'",
"%",
"(",
"2",
"*",
"(",
"seq",
".",
"name",
",",
"indexing",
")",
")",
")",
"return",
"lines"
] |
Load data statements.
|
[
"Load",
"data",
"statements",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L497-L523
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.set_pointer
|
def set_pointer(self, subseqs):
"""Set_pointer functions for link sequences."""
lines = Lines()
for seq in subseqs:
if seq.NDIM == 0:
lines.extend(self.set_pointer0d(subseqs))
break
for seq in subseqs:
if seq.NDIM == 1:
lines.extend(self.alloc(subseqs))
lines.extend(self.dealloc(subseqs))
lines.extend(self.set_pointer1d(subseqs))
break
return lines
|
python
|
def set_pointer(self, subseqs):
"""Set_pointer functions for link sequences."""
lines = Lines()
for seq in subseqs:
if seq.NDIM == 0:
lines.extend(self.set_pointer0d(subseqs))
break
for seq in subseqs:
if seq.NDIM == 1:
lines.extend(self.alloc(subseqs))
lines.extend(self.dealloc(subseqs))
lines.extend(self.set_pointer1d(subseqs))
break
return lines
|
[
"def",
"set_pointer",
"(",
"self",
",",
"subseqs",
")",
":",
"lines",
"=",
"Lines",
"(",
")",
"for",
"seq",
"in",
"subseqs",
":",
"if",
"seq",
".",
"NDIM",
"==",
"0",
":",
"lines",
".",
"extend",
"(",
"self",
".",
"set_pointer0d",
"(",
"subseqs",
")",
")",
"break",
"for",
"seq",
"in",
"subseqs",
":",
"if",
"seq",
".",
"NDIM",
"==",
"1",
":",
"lines",
".",
"extend",
"(",
"self",
".",
"alloc",
"(",
"subseqs",
")",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"dealloc",
"(",
"subseqs",
")",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"set_pointer1d",
"(",
"subseqs",
")",
")",
"break",
"return",
"lines"
] |
Set_pointer functions for link sequences.
|
[
"Set_pointer",
"functions",
"for",
"link",
"sequences",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L554-L567
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.set_pointer0d
|
def set_pointer0d(subseqs):
"""Set_pointer function for 0-dimensional link sequences."""
print(' . set_pointer0d')
lines = Lines()
lines.add(1, 'cpdef inline set_pointer0d'
'(self, str name, pointerutils.PDouble value):')
for seq in subseqs:
lines.add(2, 'if name == "%s":' % seq.name)
lines.add(3, 'self.%s = value.p_value' % seq.name)
return lines
|
python
|
def set_pointer0d(subseqs):
"""Set_pointer function for 0-dimensional link sequences."""
print(' . set_pointer0d')
lines = Lines()
lines.add(1, 'cpdef inline set_pointer0d'
'(self, str name, pointerutils.PDouble value):')
for seq in subseqs:
lines.add(2, 'if name == "%s":' % seq.name)
lines.add(3, 'self.%s = value.p_value' % seq.name)
return lines
|
[
"def",
"set_pointer0d",
"(",
"subseqs",
")",
":",
"print",
"(",
"' . set_pointer0d'",
")",
"lines",
"=",
"Lines",
"(",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cpdef inline set_pointer0d'",
"'(self, str name, pointerutils.PDouble value):'",
")",
"for",
"seq",
"in",
"subseqs",
":",
"lines",
".",
"add",
"(",
"2",
",",
"'if name == \"%s\":'",
"%",
"seq",
".",
"name",
")",
"lines",
".",
"add",
"(",
"3",
",",
"'self.%s = value.p_value'",
"%",
"seq",
".",
"name",
")",
"return",
"lines"
] |
Set_pointer function for 0-dimensional link sequences.
|
[
"Set_pointer",
"function",
"for",
"0",
"-",
"dimensional",
"link",
"sequences",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L570-L579
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.alloc
|
def alloc(subseqs):
"""Allocate memory for 1-dimensional link sequences."""
print(' . setlength')
lines = Lines()
lines.add(1, 'cpdef inline alloc(self, name, int length):')
for seq in subseqs:
lines.add(2, 'if name == "%s":' % seq.name)
lines.add(3, 'self._%s_length_0 = length' % seq.name)
lines.add(3, 'self.%s = <double**> '
'PyMem_Malloc(length * sizeof(double*))' % seq.name)
return lines
|
python
|
def alloc(subseqs):
"""Allocate memory for 1-dimensional link sequences."""
print(' . setlength')
lines = Lines()
lines.add(1, 'cpdef inline alloc(self, name, int length):')
for seq in subseqs:
lines.add(2, 'if name == "%s":' % seq.name)
lines.add(3, 'self._%s_length_0 = length' % seq.name)
lines.add(3, 'self.%s = <double**> '
'PyMem_Malloc(length * sizeof(double*))' % seq.name)
return lines
|
[
"def",
"alloc",
"(",
"subseqs",
")",
":",
"print",
"(",
"' . setlength'",
")",
"lines",
"=",
"Lines",
"(",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cpdef inline alloc(self, name, int length):'",
")",
"for",
"seq",
"in",
"subseqs",
":",
"lines",
".",
"add",
"(",
"2",
",",
"'if name == \"%s\":'",
"%",
"seq",
".",
"name",
")",
"lines",
".",
"add",
"(",
"3",
",",
"'self._%s_length_0 = length'",
"%",
"seq",
".",
"name",
")",
"lines",
".",
"add",
"(",
"3",
",",
"'self.%s = <double**> '",
"'PyMem_Malloc(length * sizeof(double*))'",
"%",
"seq",
".",
"name",
")",
"return",
"lines"
] |
Allocate memory for 1-dimensional link sequences.
|
[
"Allocate",
"memory",
"for",
"1",
"-",
"dimensional",
"link",
"sequences",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L582-L592
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.dealloc
|
def dealloc(subseqs):
"""Deallocate memory for 1-dimensional link sequences."""
print(' . dealloc')
lines = Lines()
lines.add(1, 'cpdef inline dealloc(self):')
for seq in subseqs:
lines.add(2, 'PyMem_Free(self.%s)' % seq.name)
return lines
|
python
|
def dealloc(subseqs):
"""Deallocate memory for 1-dimensional link sequences."""
print(' . dealloc')
lines = Lines()
lines.add(1, 'cpdef inline dealloc(self):')
for seq in subseqs:
lines.add(2, 'PyMem_Free(self.%s)' % seq.name)
return lines
|
[
"def",
"dealloc",
"(",
"subseqs",
")",
":",
"print",
"(",
"' . dealloc'",
")",
"lines",
"=",
"Lines",
"(",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cpdef inline dealloc(self):'",
")",
"for",
"seq",
"in",
"subseqs",
":",
"lines",
".",
"add",
"(",
"2",
",",
"'PyMem_Free(self.%s)'",
"%",
"seq",
".",
"name",
")",
"return",
"lines"
] |
Deallocate memory for 1-dimensional link sequences.
|
[
"Deallocate",
"memory",
"for",
"1",
"-",
"dimensional",
"link",
"sequences",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L595-L602
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.set_pointer1d
|
def set_pointer1d(subseqs):
"""Set_pointer function for 1-dimensional link sequences."""
print(' . set_pointer1d')
lines = Lines()
lines.add(1, 'cpdef inline set_pointer1d'
'(self, str name, pointerutils.PDouble value, int idx):')
for seq in subseqs:
lines.add(2, 'if name == "%s":' % seq.name)
lines.add(3, 'self.%s[idx] = value.p_value' % seq.name)
return lines
|
python
|
def set_pointer1d(subseqs):
"""Set_pointer function for 1-dimensional link sequences."""
print(' . set_pointer1d')
lines = Lines()
lines.add(1, 'cpdef inline set_pointer1d'
'(self, str name, pointerutils.PDouble value, int idx):')
for seq in subseqs:
lines.add(2, 'if name == "%s":' % seq.name)
lines.add(3, 'self.%s[idx] = value.p_value' % seq.name)
return lines
|
[
"def",
"set_pointer1d",
"(",
"subseqs",
")",
":",
"print",
"(",
"' . set_pointer1d'",
")",
"lines",
"=",
"Lines",
"(",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cpdef inline set_pointer1d'",
"'(self, str name, pointerutils.PDouble value, int idx):'",
")",
"for",
"seq",
"in",
"subseqs",
":",
"lines",
".",
"add",
"(",
"2",
",",
"'if name == \"%s\":'",
"%",
"seq",
".",
"name",
")",
"lines",
".",
"add",
"(",
"3",
",",
"'self.%s[idx] = value.p_value'",
"%",
"seq",
".",
"name",
")",
"return",
"lines"
] |
Set_pointer function for 1-dimensional link sequences.
|
[
"Set_pointer",
"function",
"for",
"1",
"-",
"dimensional",
"link",
"sequences",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L605-L614
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.numericalparameters
|
def numericalparameters(self):
"""Numeric parameter declaration lines."""
lines = Lines()
if self.model.NUMERICAL:
lines.add(0, '@cython.final')
lines.add(0, 'cdef class NumConsts(object):')
for name in ('nmb_methods', 'nmb_stages'):
lines.add(1, 'cdef public %s %s' % (TYPE2STR[int], name))
for name in ('dt_increase', 'dt_decrease'):
lines.add(1, 'cdef public %s %s' % (TYPE2STR[float], name))
lines.add(1, 'cdef public configutils.Config pub')
lines.add(1, 'cdef public double[:, :, :] a_coefs')
lines.add(0, 'cdef class NumVars(object):')
for name in ('nmb_calls', 'idx_method', 'idx_stage'):
lines.add(1, 'cdef public %s %s' % (TYPE2STR[int], name))
for name in ('t0', 't1', 'dt', 'dt_est',
'error', 'last_error', 'extrapolated_error'):
lines.add(1, 'cdef public %s %s' % (TYPE2STR[float], name))
lines.add(1, 'cdef public %s f0_ready' % TYPE2STR[bool])
return lines
|
python
|
def numericalparameters(self):
"""Numeric parameter declaration lines."""
lines = Lines()
if self.model.NUMERICAL:
lines.add(0, '@cython.final')
lines.add(0, 'cdef class NumConsts(object):')
for name in ('nmb_methods', 'nmb_stages'):
lines.add(1, 'cdef public %s %s' % (TYPE2STR[int], name))
for name in ('dt_increase', 'dt_decrease'):
lines.add(1, 'cdef public %s %s' % (TYPE2STR[float], name))
lines.add(1, 'cdef public configutils.Config pub')
lines.add(1, 'cdef public double[:, :, :] a_coefs')
lines.add(0, 'cdef class NumVars(object):')
for name in ('nmb_calls', 'idx_method', 'idx_stage'):
lines.add(1, 'cdef public %s %s' % (TYPE2STR[int], name))
for name in ('t0', 't1', 'dt', 'dt_est',
'error', 'last_error', 'extrapolated_error'):
lines.add(1, 'cdef public %s %s' % (TYPE2STR[float], name))
lines.add(1, 'cdef public %s f0_ready' % TYPE2STR[bool])
return lines
|
[
"def",
"numericalparameters",
"(",
"self",
")",
":",
"lines",
"=",
"Lines",
"(",
")",
"if",
"self",
".",
"model",
".",
"NUMERICAL",
":",
"lines",
".",
"add",
"(",
"0",
",",
"'@cython.final'",
")",
"lines",
".",
"add",
"(",
"0",
",",
"'cdef class NumConsts(object):'",
")",
"for",
"name",
"in",
"(",
"'nmb_methods'",
",",
"'nmb_stages'",
")",
":",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public %s %s'",
"%",
"(",
"TYPE2STR",
"[",
"int",
"]",
",",
"name",
")",
")",
"for",
"name",
"in",
"(",
"'dt_increase'",
",",
"'dt_decrease'",
")",
":",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public %s %s'",
"%",
"(",
"TYPE2STR",
"[",
"float",
"]",
",",
"name",
")",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public configutils.Config pub'",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public double[:, :, :] a_coefs'",
")",
"lines",
".",
"add",
"(",
"0",
",",
"'cdef class NumVars(object):'",
")",
"for",
"name",
"in",
"(",
"'nmb_calls'",
",",
"'idx_method'",
",",
"'idx_stage'",
")",
":",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public %s %s'",
"%",
"(",
"TYPE2STR",
"[",
"int",
"]",
",",
"name",
")",
")",
"for",
"name",
"in",
"(",
"'t0'",
",",
"'t1'",
",",
"'dt'",
",",
"'dt_est'",
",",
"'error'",
",",
"'last_error'",
",",
"'extrapolated_error'",
")",
":",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public %s %s'",
"%",
"(",
"TYPE2STR",
"[",
"float",
"]",
",",
"name",
")",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public %s f0_ready'",
"%",
"TYPE2STR",
"[",
"bool",
"]",
")",
"return",
"lines"
] |
Numeric parameter declaration lines.
|
[
"Numeric",
"parameter",
"declaration",
"lines",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L617-L636
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.modeldeclarations
|
def modeldeclarations(self):
"""Attribute declarations of the model class."""
lines = Lines()
lines.add(0, '@cython.final')
lines.add(0, 'cdef class Model(object):')
lines.add(1, 'cdef public int idx_sim')
lines.add(1, 'cdef public Parameters parameters')
lines.add(1, 'cdef public Sequences sequences')
if hasattr(self.model, 'numconsts'):
lines.add(1, 'cdef public NumConsts numconsts')
if hasattr(self.model, 'numvars'):
lines.add(1, 'cdef public NumVars numvars')
return lines
|
python
|
def modeldeclarations(self):
"""Attribute declarations of the model class."""
lines = Lines()
lines.add(0, '@cython.final')
lines.add(0, 'cdef class Model(object):')
lines.add(1, 'cdef public int idx_sim')
lines.add(1, 'cdef public Parameters parameters')
lines.add(1, 'cdef public Sequences sequences')
if hasattr(self.model, 'numconsts'):
lines.add(1, 'cdef public NumConsts numconsts')
if hasattr(self.model, 'numvars'):
lines.add(1, 'cdef public NumVars numvars')
return lines
|
[
"def",
"modeldeclarations",
"(",
"self",
")",
":",
"lines",
"=",
"Lines",
"(",
")",
"lines",
".",
"add",
"(",
"0",
",",
"'@cython.final'",
")",
"lines",
".",
"add",
"(",
"0",
",",
"'cdef class Model(object):'",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public int idx_sim'",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public Parameters parameters'",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public Sequences sequences'",
")",
"if",
"hasattr",
"(",
"self",
".",
"model",
",",
"'numconsts'",
")",
":",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public NumConsts numconsts'",
")",
"if",
"hasattr",
"(",
"self",
".",
"model",
",",
"'numvars'",
")",
":",
"lines",
".",
"add",
"(",
"1",
",",
"'cdef public NumVars numvars'",
")",
"return",
"lines"
] |
Attribute declarations of the model class.
|
[
"Attribute",
"declarations",
"of",
"the",
"model",
"class",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L639-L651
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.modelstandardfunctions
|
def modelstandardfunctions(self):
"""Standard functions of the model class."""
lines = Lines()
lines.extend(self.doit)
lines.extend(self.iofunctions)
lines.extend(self.new2old)
lines.extend(self.run)
lines.extend(self.update_inlets)
lines.extend(self.update_outlets)
lines.extend(self.update_receivers)
lines.extend(self.update_senders)
return lines
|
python
|
def modelstandardfunctions(self):
"""Standard functions of the model class."""
lines = Lines()
lines.extend(self.doit)
lines.extend(self.iofunctions)
lines.extend(self.new2old)
lines.extend(self.run)
lines.extend(self.update_inlets)
lines.extend(self.update_outlets)
lines.extend(self.update_receivers)
lines.extend(self.update_senders)
return lines
|
[
"def",
"modelstandardfunctions",
"(",
"self",
")",
":",
"lines",
"=",
"Lines",
"(",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"doit",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"iofunctions",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"new2old",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"run",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"update_inlets",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"update_outlets",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"update_receivers",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"update_senders",
")",
"return",
"lines"
] |
Standard functions of the model class.
|
[
"Standard",
"functions",
"of",
"the",
"model",
"class",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L654-L665
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.modelnumericfunctions
|
def modelnumericfunctions(self):
"""Numerical functions of the model class."""
lines = Lines()
lines.extend(self.solve)
lines.extend(self.calculate_single_terms)
lines.extend(self.calculate_full_terms)
lines.extend(self.get_point_states)
lines.extend(self.set_point_states)
lines.extend(self.set_result_states)
lines.extend(self.get_sum_fluxes)
lines.extend(self.set_point_fluxes)
lines.extend(self.set_result_fluxes)
lines.extend(self.integrate_fluxes)
lines.extend(self.reset_sum_fluxes)
lines.extend(self.addup_fluxes)
lines.extend(self.calculate_error)
lines.extend(self.extrapolate_error)
return lines
|
python
|
def modelnumericfunctions(self):
"""Numerical functions of the model class."""
lines = Lines()
lines.extend(self.solve)
lines.extend(self.calculate_single_terms)
lines.extend(self.calculate_full_terms)
lines.extend(self.get_point_states)
lines.extend(self.set_point_states)
lines.extend(self.set_result_states)
lines.extend(self.get_sum_fluxes)
lines.extend(self.set_point_fluxes)
lines.extend(self.set_result_fluxes)
lines.extend(self.integrate_fluxes)
lines.extend(self.reset_sum_fluxes)
lines.extend(self.addup_fluxes)
lines.extend(self.calculate_error)
lines.extend(self.extrapolate_error)
return lines
|
[
"def",
"modelnumericfunctions",
"(",
"self",
")",
":",
"lines",
"=",
"Lines",
"(",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"solve",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"calculate_single_terms",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"calculate_full_terms",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"get_point_states",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"set_point_states",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"set_result_states",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"get_sum_fluxes",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"set_point_fluxes",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"set_result_fluxes",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"integrate_fluxes",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"reset_sum_fluxes",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"addup_fluxes",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"calculate_error",
")",
"lines",
".",
"extend",
"(",
"self",
".",
"extrapolate_error",
")",
"return",
"lines"
] |
Numerical functions of the model class.
|
[
"Numerical",
"functions",
"of",
"the",
"model",
"class",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L668-L685
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.doit
|
def doit(self):
"""Do (most of) it function of the model class."""
print(' . doit')
lines = Lines()
lines.add(1, 'cpdef inline void doit(self, int idx) %s:' % _nogil)
lines.add(2, 'self.idx_sim = idx')
if getattr(self.model.sequences, 'inputs', None) is not None:
lines.add(2, 'self.load_data()')
if self.model.INLET_METHODS:
lines.add(2, 'self.update_inlets()')
if hasattr(self.model, 'solve'):
lines.add(2, 'self.solve()')
else:
lines.add(2, 'self.run()')
if getattr(self.model.sequences, 'states', None) is not None:
lines.add(2, 'self.new2old()')
if self.model.OUTLET_METHODS:
lines.add(2, 'self.update_outlets()')
return lines
|
python
|
def doit(self):
"""Do (most of) it function of the model class."""
print(' . doit')
lines = Lines()
lines.add(1, 'cpdef inline void doit(self, int idx) %s:' % _nogil)
lines.add(2, 'self.idx_sim = idx')
if getattr(self.model.sequences, 'inputs', None) is not None:
lines.add(2, 'self.load_data()')
if self.model.INLET_METHODS:
lines.add(2, 'self.update_inlets()')
if hasattr(self.model, 'solve'):
lines.add(2, 'self.solve()')
else:
lines.add(2, 'self.run()')
if getattr(self.model.sequences, 'states', None) is not None:
lines.add(2, 'self.new2old()')
if self.model.OUTLET_METHODS:
lines.add(2, 'self.update_outlets()')
return lines
|
[
"def",
"doit",
"(",
"self",
")",
":",
"print",
"(",
"' . doit'",
")",
"lines",
"=",
"Lines",
"(",
")",
"lines",
".",
"add",
"(",
"1",
",",
"'cpdef inline void doit(self, int idx) %s:'",
"%",
"_nogil",
")",
"lines",
".",
"add",
"(",
"2",
",",
"'self.idx_sim = idx'",
")",
"if",
"getattr",
"(",
"self",
".",
"model",
".",
"sequences",
",",
"'inputs'",
",",
"None",
")",
"is",
"not",
"None",
":",
"lines",
".",
"add",
"(",
"2",
",",
"'self.load_data()'",
")",
"if",
"self",
".",
"model",
".",
"INLET_METHODS",
":",
"lines",
".",
"add",
"(",
"2",
",",
"'self.update_inlets()'",
")",
"if",
"hasattr",
"(",
"self",
".",
"model",
",",
"'solve'",
")",
":",
"lines",
".",
"add",
"(",
"2",
",",
"'self.solve()'",
")",
"else",
":",
"lines",
".",
"add",
"(",
"2",
",",
"'self.run()'",
")",
"if",
"getattr",
"(",
"self",
".",
"model",
".",
"sequences",
",",
"'states'",
",",
"None",
")",
"is",
"not",
"None",
":",
"lines",
".",
"add",
"(",
"2",
",",
"'self.new2old()'",
")",
"if",
"self",
".",
"model",
".",
"OUTLET_METHODS",
":",
"lines",
".",
"add",
"(",
"2",
",",
"'self.update_outlets()'",
")",
"return",
"lines"
] |
Do (most of) it function of the model class.
|
[
"Do",
"(",
"most",
"of",
")",
"it",
"function",
"of",
"the",
"model",
"class",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L688-L706
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.iofunctions
|
def iofunctions(self):
"""Input/output functions of the model class."""
lines = Lines()
for func in ('open_files', 'close_files', 'load_data', 'save_data'):
if ((func == 'load_data') and
(getattr(self.model.sequences, 'inputs', None) is None)):
continue
if ((func == 'save_data') and
((getattr(self.model.sequences, 'fluxes', None) is None) and
(getattr(self.model.sequences, 'states', None) is None))):
continue
print(' . %s' % func)
nogil = func in ('load_data', 'save_data')
idx_as_arg = func == 'save_data'
lines.add(1, method_header(
func, nogil=nogil, idx_as_arg=idx_as_arg))
for subseqs in self.model.sequences:
if func == 'load_data':
applyfuncs = ('inputs',)
elif func == 'save_data':
applyfuncs = ('fluxes', 'states')
else:
applyfuncs = ('inputs', 'fluxes', 'states')
if subseqs.name in applyfuncs:
if func == 'close_files':
lines.add(2, 'self.sequences.%s.%s()'
% (subseqs.name, func))
else:
lines.add(2, 'self.sequences.%s.%s(self.idx_sim)'
% (subseqs.name, func))
return lines
|
python
|
def iofunctions(self):
"""Input/output functions of the model class."""
lines = Lines()
for func in ('open_files', 'close_files', 'load_data', 'save_data'):
if ((func == 'load_data') and
(getattr(self.model.sequences, 'inputs', None) is None)):
continue
if ((func == 'save_data') and
((getattr(self.model.sequences, 'fluxes', None) is None) and
(getattr(self.model.sequences, 'states', None) is None))):
continue
print(' . %s' % func)
nogil = func in ('load_data', 'save_data')
idx_as_arg = func == 'save_data'
lines.add(1, method_header(
func, nogil=nogil, idx_as_arg=idx_as_arg))
for subseqs in self.model.sequences:
if func == 'load_data':
applyfuncs = ('inputs',)
elif func == 'save_data':
applyfuncs = ('fluxes', 'states')
else:
applyfuncs = ('inputs', 'fluxes', 'states')
if subseqs.name in applyfuncs:
if func == 'close_files':
lines.add(2, 'self.sequences.%s.%s()'
% (subseqs.name, func))
else:
lines.add(2, 'self.sequences.%s.%s(self.idx_sim)'
% (subseqs.name, func))
return lines
|
[
"def",
"iofunctions",
"(",
"self",
")",
":",
"lines",
"=",
"Lines",
"(",
")",
"for",
"func",
"in",
"(",
"'open_files'",
",",
"'close_files'",
",",
"'load_data'",
",",
"'save_data'",
")",
":",
"if",
"(",
"(",
"func",
"==",
"'load_data'",
")",
"and",
"(",
"getattr",
"(",
"self",
".",
"model",
".",
"sequences",
",",
"'inputs'",
",",
"None",
")",
"is",
"None",
")",
")",
":",
"continue",
"if",
"(",
"(",
"func",
"==",
"'save_data'",
")",
"and",
"(",
"(",
"getattr",
"(",
"self",
".",
"model",
".",
"sequences",
",",
"'fluxes'",
",",
"None",
")",
"is",
"None",
")",
"and",
"(",
"getattr",
"(",
"self",
".",
"model",
".",
"sequences",
",",
"'states'",
",",
"None",
")",
"is",
"None",
")",
")",
")",
":",
"continue",
"print",
"(",
"' . %s'",
"%",
"func",
")",
"nogil",
"=",
"func",
"in",
"(",
"'load_data'",
",",
"'save_data'",
")",
"idx_as_arg",
"=",
"func",
"==",
"'save_data'",
"lines",
".",
"add",
"(",
"1",
",",
"method_header",
"(",
"func",
",",
"nogil",
"=",
"nogil",
",",
"idx_as_arg",
"=",
"idx_as_arg",
")",
")",
"for",
"subseqs",
"in",
"self",
".",
"model",
".",
"sequences",
":",
"if",
"func",
"==",
"'load_data'",
":",
"applyfuncs",
"=",
"(",
"'inputs'",
",",
")",
"elif",
"func",
"==",
"'save_data'",
":",
"applyfuncs",
"=",
"(",
"'fluxes'",
",",
"'states'",
")",
"else",
":",
"applyfuncs",
"=",
"(",
"'inputs'",
",",
"'fluxes'",
",",
"'states'",
")",
"if",
"subseqs",
".",
"name",
"in",
"applyfuncs",
":",
"if",
"func",
"==",
"'close_files'",
":",
"lines",
".",
"add",
"(",
"2",
",",
"'self.sequences.%s.%s()'",
"%",
"(",
"subseqs",
".",
"name",
",",
"func",
")",
")",
"else",
":",
"lines",
".",
"add",
"(",
"2",
",",
"'self.sequences.%s.%s(self.idx_sim)'",
"%",
"(",
"subseqs",
".",
"name",
",",
"func",
")",
")",
"return",
"lines"
] |
Input/output functions of the model class.
|
[
"Input",
"/",
"output",
"functions",
"of",
"the",
"model",
"class",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L709-L739
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.calculate_single_terms
|
def calculate_single_terms(self):
"""Lines of model method with the same name."""
lines = self._call_methods('calculate_single_terms',
self.model.PART_ODE_METHODS)
if lines:
lines.insert(1, (' self.numvars.nmb_calls ='
'self.numvars.nmb_calls+1'))
return lines
|
python
|
def calculate_single_terms(self):
"""Lines of model method with the same name."""
lines = self._call_methods('calculate_single_terms',
self.model.PART_ODE_METHODS)
if lines:
lines.insert(1, (' self.numvars.nmb_calls ='
'self.numvars.nmb_calls+1'))
return lines
|
[
"def",
"calculate_single_terms",
"(",
"self",
")",
":",
"lines",
"=",
"self",
".",
"_call_methods",
"(",
"'calculate_single_terms'",
",",
"self",
".",
"model",
".",
"PART_ODE_METHODS",
")",
"if",
"lines",
":",
"lines",
".",
"insert",
"(",
"1",
",",
"(",
"' self.numvars.nmb_calls ='",
"'self.numvars.nmb_calls+1'",
")",
")",
"return",
"lines"
] |
Lines of model method with the same name.
|
[
"Lines",
"of",
"model",
"method",
"with",
"the",
"same",
"name",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L818-L825
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
PyxWriter.listofmodeluserfunctions
|
def listofmodeluserfunctions(self):
"""User functions of the model class."""
lines = []
for (name, member) in vars(self.model.__class__).items():
if (inspect.isfunction(member) and
(name not in ('run', 'new2old')) and
('fastaccess' in inspect.getsource(member))):
lines.append((name, member))
run = vars(self.model.__class__).get('run')
if run is not None:
lines.append(('run', run))
for (name, member) in vars(self.model).items():
if (inspect.ismethod(member) and
('fastaccess' in inspect.getsource(member))):
lines.append((name, member))
return lines
|
python
|
def listofmodeluserfunctions(self):
"""User functions of the model class."""
lines = []
for (name, member) in vars(self.model.__class__).items():
if (inspect.isfunction(member) and
(name not in ('run', 'new2old')) and
('fastaccess' in inspect.getsource(member))):
lines.append((name, member))
run = vars(self.model.__class__).get('run')
if run is not None:
lines.append(('run', run))
for (name, member) in vars(self.model).items():
if (inspect.ismethod(member) and
('fastaccess' in inspect.getsource(member))):
lines.append((name, member))
return lines
|
[
"def",
"listofmodeluserfunctions",
"(",
"self",
")",
":",
"lines",
"=",
"[",
"]",
"for",
"(",
"name",
",",
"member",
")",
"in",
"vars",
"(",
"self",
".",
"model",
".",
"__class__",
")",
".",
"items",
"(",
")",
":",
"if",
"(",
"inspect",
".",
"isfunction",
"(",
"member",
")",
"and",
"(",
"name",
"not",
"in",
"(",
"'run'",
",",
"'new2old'",
")",
")",
"and",
"(",
"'fastaccess'",
"in",
"inspect",
".",
"getsource",
"(",
"member",
")",
")",
")",
":",
"lines",
".",
"append",
"(",
"(",
"name",
",",
"member",
")",
")",
"run",
"=",
"vars",
"(",
"self",
".",
"model",
".",
"__class__",
")",
".",
"get",
"(",
"'run'",
")",
"if",
"run",
"is",
"not",
"None",
":",
"lines",
".",
"append",
"(",
"(",
"'run'",
",",
"run",
")",
")",
"for",
"(",
"name",
",",
"member",
")",
"in",
"vars",
"(",
"self",
".",
"model",
")",
".",
"items",
"(",
")",
":",
"if",
"(",
"inspect",
".",
"ismethod",
"(",
"member",
")",
"and",
"(",
"'fastaccess'",
"in",
"inspect",
".",
"getsource",
"(",
"member",
")",
")",
")",
":",
"lines",
".",
"append",
"(",
"(",
"name",
",",
"member",
")",
")",
"return",
"lines"
] |
User functions of the model class.
|
[
"User",
"functions",
"of",
"the",
"model",
"class",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L834-L849
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
FuncConverter.cleanlines
|
def cleanlines(self):
"""Cleaned code lines.
Implemented cleanups:
* eventually remove method version
* remove docstrings
* remove comments
* remove empty lines
* remove line brackes within brackets
* replace `modelutils` with nothing
* remove complete lines containing `fastaccess`
* replace shortcuts with complete references
"""
code = inspect.getsource(self.func)
code = '\n'.join(code.split('"""')[::2])
code = code.replace('modelutils.', '')
for (name, shortcut) in zip(self.collectornames,
self.collectorshortcuts):
code = code.replace('%s.' % shortcut, 'self.%s.' % name)
code = self.remove_linebreaks_within_equations(code)
lines = code.splitlines()
self.remove_imath_operators(lines)
lines[0] = 'def %s(self):' % self.funcname
lines = [l.split('#')[0] for l in lines]
lines = [l for l in lines if 'fastaccess' not in l]
lines = [l.rstrip() for l in lines if l.rstrip()]
return Lines(*lines)
|
python
|
def cleanlines(self):
"""Cleaned code lines.
Implemented cleanups:
* eventually remove method version
* remove docstrings
* remove comments
* remove empty lines
* remove line brackes within brackets
* replace `modelutils` with nothing
* remove complete lines containing `fastaccess`
* replace shortcuts with complete references
"""
code = inspect.getsource(self.func)
code = '\n'.join(code.split('"""')[::2])
code = code.replace('modelutils.', '')
for (name, shortcut) in zip(self.collectornames,
self.collectorshortcuts):
code = code.replace('%s.' % shortcut, 'self.%s.' % name)
code = self.remove_linebreaks_within_equations(code)
lines = code.splitlines()
self.remove_imath_operators(lines)
lines[0] = 'def %s(self):' % self.funcname
lines = [l.split('#')[0] for l in lines]
lines = [l for l in lines if 'fastaccess' not in l]
lines = [l.rstrip() for l in lines if l.rstrip()]
return Lines(*lines)
|
[
"def",
"cleanlines",
"(",
"self",
")",
":",
"code",
"=",
"inspect",
".",
"getsource",
"(",
"self",
".",
"func",
")",
"code",
"=",
"'\\n'",
".",
"join",
"(",
"code",
".",
"split",
"(",
"'\"\"\"'",
")",
"[",
":",
":",
"2",
"]",
")",
"code",
"=",
"code",
".",
"replace",
"(",
"'modelutils.'",
",",
"''",
")",
"for",
"(",
"name",
",",
"shortcut",
")",
"in",
"zip",
"(",
"self",
".",
"collectornames",
",",
"self",
".",
"collectorshortcuts",
")",
":",
"code",
"=",
"code",
".",
"replace",
"(",
"'%s.'",
"%",
"shortcut",
",",
"'self.%s.'",
"%",
"name",
")",
"code",
"=",
"self",
".",
"remove_linebreaks_within_equations",
"(",
"code",
")",
"lines",
"=",
"code",
".",
"splitlines",
"(",
")",
"self",
".",
"remove_imath_operators",
"(",
"lines",
")",
"lines",
"[",
"0",
"]",
"=",
"'def %s(self):'",
"%",
"self",
".",
"funcname",
"lines",
"=",
"[",
"l",
".",
"split",
"(",
"'#'",
")",
"[",
"0",
"]",
"for",
"l",
"in",
"lines",
"]",
"lines",
"=",
"[",
"l",
"for",
"l",
"in",
"lines",
"if",
"'fastaccess'",
"not",
"in",
"l",
"]",
"lines",
"=",
"[",
"l",
".",
"rstrip",
"(",
")",
"for",
"l",
"in",
"lines",
"if",
"l",
".",
"rstrip",
"(",
")",
"]",
"return",
"Lines",
"(",
"*",
"lines",
")"
] |
Cleaned code lines.
Implemented cleanups:
* eventually remove method version
* remove docstrings
* remove comments
* remove empty lines
* remove line brackes within brackets
* replace `modelutils` with nothing
* remove complete lines containing `fastaccess`
* replace shortcuts with complete references
|
[
"Cleaned",
"code",
"lines",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L1142-L1168
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
FuncConverter.remove_linebreaks_within_equations
|
def remove_linebreaks_within_equations(code):
r"""Remove line breaks within equations.
This is not a exhaustive test, but shows how the method works:
>>> code = 'asdf = \\\n(a\n+b)'
>>> from hydpy.cythons.modelutils import FuncConverter
>>> FuncConverter.remove_linebreaks_within_equations(code)
'asdf = (a+b)'
"""
code = code.replace('\\\n', '')
chars = []
counter = 0
for char in code:
if char in ('(', '[', '{'):
counter += 1
elif char in (')', ']', '}'):
counter -= 1
if not (counter and (char == '\n')):
chars.append(char)
return ''.join(chars)
|
python
|
def remove_linebreaks_within_equations(code):
r"""Remove line breaks within equations.
This is not a exhaustive test, but shows how the method works:
>>> code = 'asdf = \\\n(a\n+b)'
>>> from hydpy.cythons.modelutils import FuncConverter
>>> FuncConverter.remove_linebreaks_within_equations(code)
'asdf = (a+b)'
"""
code = code.replace('\\\n', '')
chars = []
counter = 0
for char in code:
if char in ('(', '[', '{'):
counter += 1
elif char in (')', ']', '}'):
counter -= 1
if not (counter and (char == '\n')):
chars.append(char)
return ''.join(chars)
|
[
"def",
"remove_linebreaks_within_equations",
"(",
"code",
")",
":",
"code",
"=",
"code",
".",
"replace",
"(",
"'\\\\\\n'",
",",
"''",
")",
"chars",
"=",
"[",
"]",
"counter",
"=",
"0",
"for",
"char",
"in",
"code",
":",
"if",
"char",
"in",
"(",
"'('",
",",
"'['",
",",
"'{'",
")",
":",
"counter",
"+=",
"1",
"elif",
"char",
"in",
"(",
"')'",
",",
"']'",
",",
"'}'",
")",
":",
"counter",
"-=",
"1",
"if",
"not",
"(",
"counter",
"and",
"(",
"char",
"==",
"'\\n'",
")",
")",
":",
"chars",
".",
"append",
"(",
"char",
")",
"return",
"''",
".",
"join",
"(",
"chars",
")"
] |
r"""Remove line breaks within equations.
This is not a exhaustive test, but shows how the method works:
>>> code = 'asdf = \\\n(a\n+b)'
>>> from hydpy.cythons.modelutils import FuncConverter
>>> FuncConverter.remove_linebreaks_within_equations(code)
'asdf = (a+b)'
|
[
"r",
"Remove",
"line",
"breaks",
"within",
"equations",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L1171-L1191
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
FuncConverter.remove_imath_operators
|
def remove_imath_operators(lines):
"""Remove mathematical expressions that require Pythons global
interpreter locking mechanism.
This is not a exhaustive test, but shows how the method works:
>>> lines = [' x += 1*1']
>>> from hydpy.cythons.modelutils import FuncConverter
>>> FuncConverter.remove_imath_operators(lines)
>>> lines
[' x = x + (1*1)']
"""
for idx, line in enumerate(lines):
for operator in ('+=', '-=', '**=', '*=', '//=', '/=', '%='):
sublines = line.split(operator)
if len(sublines) > 1:
indent = line.count(' ') - line.lstrip().count(' ')
sublines = [sl.strip() for sl in sublines]
line = ('%s%s = %s %s (%s)'
% (indent*' ', sublines[0], sublines[0],
operator[:-1], sublines[1]))
lines[idx] = line
|
python
|
def remove_imath_operators(lines):
"""Remove mathematical expressions that require Pythons global
interpreter locking mechanism.
This is not a exhaustive test, but shows how the method works:
>>> lines = [' x += 1*1']
>>> from hydpy.cythons.modelutils import FuncConverter
>>> FuncConverter.remove_imath_operators(lines)
>>> lines
[' x = x + (1*1)']
"""
for idx, line in enumerate(lines):
for operator in ('+=', '-=', '**=', '*=', '//=', '/=', '%='):
sublines = line.split(operator)
if len(sublines) > 1:
indent = line.count(' ') - line.lstrip().count(' ')
sublines = [sl.strip() for sl in sublines]
line = ('%s%s = %s %s (%s)'
% (indent*' ', sublines[0], sublines[0],
operator[:-1], sublines[1]))
lines[idx] = line
|
[
"def",
"remove_imath_operators",
"(",
"lines",
")",
":",
"for",
"idx",
",",
"line",
"in",
"enumerate",
"(",
"lines",
")",
":",
"for",
"operator",
"in",
"(",
"'+='",
",",
"'-='",
",",
"'**='",
",",
"'*='",
",",
"'//='",
",",
"'/='",
",",
"'%='",
")",
":",
"sublines",
"=",
"line",
".",
"split",
"(",
"operator",
")",
"if",
"len",
"(",
"sublines",
")",
">",
"1",
":",
"indent",
"=",
"line",
".",
"count",
"(",
"' '",
")",
"-",
"line",
".",
"lstrip",
"(",
")",
".",
"count",
"(",
"' '",
")",
"sublines",
"=",
"[",
"sl",
".",
"strip",
"(",
")",
"for",
"sl",
"in",
"sublines",
"]",
"line",
"=",
"(",
"'%s%s = %s %s (%s)'",
"%",
"(",
"indent",
"*",
"' '",
",",
"sublines",
"[",
"0",
"]",
",",
"sublines",
"[",
"0",
"]",
",",
"operator",
"[",
":",
"-",
"1",
"]",
",",
"sublines",
"[",
"1",
"]",
")",
")",
"lines",
"[",
"idx",
"]",
"=",
"line"
] |
Remove mathematical expressions that require Pythons global
interpreter locking mechanism.
This is not a exhaustive test, but shows how the method works:
>>> lines = [' x += 1*1']
>>> from hydpy.cythons.modelutils import FuncConverter
>>> FuncConverter.remove_imath_operators(lines)
>>> lines
[' x = x + (1*1)']
|
[
"Remove",
"mathematical",
"expressions",
"that",
"require",
"Pythons",
"global",
"interpreter",
"locking",
"mechanism",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L1194-L1215
|
hydpy-dev/hydpy
|
hydpy/cythons/modelutils.py
|
FuncConverter.pyxlines
|
def pyxlines(self):
"""Cython code lines.
Assumptions:
* Function shall be a method
* Method shall be inlined
* Method returns nothing
* Method arguments are of type `int` (except self)
* Local variables are generally of type `int` but of type `double`
when their name starts with `d_`
"""
lines = [' '+line for line in self.cleanlines]
lines[0] = lines[0].replace('def ', 'cpdef inline void ')
lines[0] = lines[0].replace('):', ') %s:' % _nogil)
for name in self.untypedarguments:
lines[0] = lines[0].replace(', %s ' % name, ', int %s ' % name)
lines[0] = lines[0].replace(', %s)' % name, ', int %s)' % name)
for name in self.untypedinternalvarnames:
if name.startswith('d_'):
lines.insert(1, ' cdef double ' + name)
else:
lines.insert(1, ' cdef int ' + name)
return Lines(*lines)
|
python
|
def pyxlines(self):
"""Cython code lines.
Assumptions:
* Function shall be a method
* Method shall be inlined
* Method returns nothing
* Method arguments are of type `int` (except self)
* Local variables are generally of type `int` but of type `double`
when their name starts with `d_`
"""
lines = [' '+line for line in self.cleanlines]
lines[0] = lines[0].replace('def ', 'cpdef inline void ')
lines[0] = lines[0].replace('):', ') %s:' % _nogil)
for name in self.untypedarguments:
lines[0] = lines[0].replace(', %s ' % name, ', int %s ' % name)
lines[0] = lines[0].replace(', %s)' % name, ', int %s)' % name)
for name in self.untypedinternalvarnames:
if name.startswith('d_'):
lines.insert(1, ' cdef double ' + name)
else:
lines.insert(1, ' cdef int ' + name)
return Lines(*lines)
|
[
"def",
"pyxlines",
"(",
"self",
")",
":",
"lines",
"=",
"[",
"' '",
"+",
"line",
"for",
"line",
"in",
"self",
".",
"cleanlines",
"]",
"lines",
"[",
"0",
"]",
"=",
"lines",
"[",
"0",
"]",
".",
"replace",
"(",
"'def '",
",",
"'cpdef inline void '",
")",
"lines",
"[",
"0",
"]",
"=",
"lines",
"[",
"0",
"]",
".",
"replace",
"(",
"'):'",
",",
"') %s:'",
"%",
"_nogil",
")",
"for",
"name",
"in",
"self",
".",
"untypedarguments",
":",
"lines",
"[",
"0",
"]",
"=",
"lines",
"[",
"0",
"]",
".",
"replace",
"(",
"', %s '",
"%",
"name",
",",
"', int %s '",
"%",
"name",
")",
"lines",
"[",
"0",
"]",
"=",
"lines",
"[",
"0",
"]",
".",
"replace",
"(",
"', %s)'",
"%",
"name",
",",
"', int %s)'",
"%",
"name",
")",
"for",
"name",
"in",
"self",
".",
"untypedinternalvarnames",
":",
"if",
"name",
".",
"startswith",
"(",
"'d_'",
")",
":",
"lines",
".",
"insert",
"(",
"1",
",",
"' cdef double '",
"+",
"name",
")",
"else",
":",
"lines",
".",
"insert",
"(",
"1",
",",
"' cdef int '",
"+",
"name",
")",
"return",
"Lines",
"(",
"*",
"lines",
")"
] |
Cython code lines.
Assumptions:
* Function shall be a method
* Method shall be inlined
* Method returns nothing
* Method arguments are of type `int` (except self)
* Local variables are generally of type `int` but of type `double`
when their name starts with `d_`
|
[
"Cython",
"code",
"lines",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/cythons/modelutils.py#L1218-L1240
|
hydpy-dev/hydpy
|
hydpy/auxs/smoothtools.py
|
calc_smoothpar_logistic2
|
def calc_smoothpar_logistic2(metapar):
"""Return the smoothing parameter corresponding to the given meta
parameter when using |smooth_logistic2|.
Calculate the smoothing parameter value corresponding the meta parameter
value 2.5:
>>> from hydpy.auxs.smoothtools import calc_smoothpar_logistic2
>>> smoothpar = calc_smoothpar_logistic2(2.5)
Using this smoothing parameter value, the output of function
|smooth_logistic2| differs by
1 % from the related `true` discontinuous step function for the
input values -2.5 and 2.5 (which are located at a distance of 2.5
from the position of the discontinuity):
>>> from hydpy.cythons import smoothutils
>>> from hydpy import round_
>>> round_(smoothutils.smooth_logistic2(-2.5, smoothpar))
0.01
>>> round_(smoothutils.smooth_logistic2(2.5, smoothpar))
2.51
For zero or negative meta parameter values, a zero smoothing parameter
value is returned:
>>> round_(calc_smoothpar_logistic2(0.0))
0.0
>>> round_(calc_smoothpar_logistic2(-1.0))
0.0
"""
if metapar <= 0.:
return 0.
return optimize.newton(_error_smoothpar_logistic2,
.3 * metapar**.84,
_smooth_logistic2_derivative,
args=(metapar,))
|
python
|
def calc_smoothpar_logistic2(metapar):
"""Return the smoothing parameter corresponding to the given meta
parameter when using |smooth_logistic2|.
Calculate the smoothing parameter value corresponding the meta parameter
value 2.5:
>>> from hydpy.auxs.smoothtools import calc_smoothpar_logistic2
>>> smoothpar = calc_smoothpar_logistic2(2.5)
Using this smoothing parameter value, the output of function
|smooth_logistic2| differs by
1 % from the related `true` discontinuous step function for the
input values -2.5 and 2.5 (which are located at a distance of 2.5
from the position of the discontinuity):
>>> from hydpy.cythons import smoothutils
>>> from hydpy import round_
>>> round_(smoothutils.smooth_logistic2(-2.5, smoothpar))
0.01
>>> round_(smoothutils.smooth_logistic2(2.5, smoothpar))
2.51
For zero or negative meta parameter values, a zero smoothing parameter
value is returned:
>>> round_(calc_smoothpar_logistic2(0.0))
0.0
>>> round_(calc_smoothpar_logistic2(-1.0))
0.0
"""
if metapar <= 0.:
return 0.
return optimize.newton(_error_smoothpar_logistic2,
.3 * metapar**.84,
_smooth_logistic2_derivative,
args=(metapar,))
|
[
"def",
"calc_smoothpar_logistic2",
"(",
"metapar",
")",
":",
"if",
"metapar",
"<=",
"0.",
":",
"return",
"0.",
"return",
"optimize",
".",
"newton",
"(",
"_error_smoothpar_logistic2",
",",
".3",
"*",
"metapar",
"**",
".84",
",",
"_smooth_logistic2_derivative",
",",
"args",
"=",
"(",
"metapar",
",",
")",
")"
] |
Return the smoothing parameter corresponding to the given meta
parameter when using |smooth_logistic2|.
Calculate the smoothing parameter value corresponding the meta parameter
value 2.5:
>>> from hydpy.auxs.smoothtools import calc_smoothpar_logistic2
>>> smoothpar = calc_smoothpar_logistic2(2.5)
Using this smoothing parameter value, the output of function
|smooth_logistic2| differs by
1 % from the related `true` discontinuous step function for the
input values -2.5 and 2.5 (which are located at a distance of 2.5
from the position of the discontinuity):
>>> from hydpy.cythons import smoothutils
>>> from hydpy import round_
>>> round_(smoothutils.smooth_logistic2(-2.5, smoothpar))
0.01
>>> round_(smoothutils.smooth_logistic2(2.5, smoothpar))
2.51
For zero or negative meta parameter values, a zero smoothing parameter
value is returned:
>>> round_(calc_smoothpar_logistic2(0.0))
0.0
>>> round_(calc_smoothpar_logistic2(-1.0))
0.0
|
[
"Return",
"the",
"smoothing",
"parameter",
"corresponding",
"to",
"the",
"given",
"meta",
"parameter",
"when",
"using",
"|smooth_logistic2|",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/auxs/smoothtools.py#L78-L114
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Date.from_array
|
def from_array(cls, array):
"""Return a |Date| instance based on date information (year,
month, day, hour, minute, second) stored as the first entries of
the successive rows of a |numpy.ndarray|.
>>> from hydpy import Date
>>> import numpy
>>> array1d = numpy.array([1992, 10, 8, 15, 15, 42, 999])
>>> Date.from_array(array1d)
Date('1992-10-08 15:15:42')
>>> array3d = numpy.zeros((7, 2, 2))
>>> array3d[:, 0, 0] = array1d
>>> Date.from_array(array3d)
Date('1992-10-08 15:15:42')
.. note::
The date defined by the given |numpy.ndarray| cannot
include any time zone information and corresponds to
|Options.utcoffset|, which defaults to UTC+01:00.
"""
intarray = numpy.array(array, dtype=int)
for dummy in range(1, array.ndim):
intarray = intarray[:, 0]
return cls(datetime.datetime(*intarray[:6]))
|
python
|
def from_array(cls, array):
"""Return a |Date| instance based on date information (year,
month, day, hour, minute, second) stored as the first entries of
the successive rows of a |numpy.ndarray|.
>>> from hydpy import Date
>>> import numpy
>>> array1d = numpy.array([1992, 10, 8, 15, 15, 42, 999])
>>> Date.from_array(array1d)
Date('1992-10-08 15:15:42')
>>> array3d = numpy.zeros((7, 2, 2))
>>> array3d[:, 0, 0] = array1d
>>> Date.from_array(array3d)
Date('1992-10-08 15:15:42')
.. note::
The date defined by the given |numpy.ndarray| cannot
include any time zone information and corresponds to
|Options.utcoffset|, which defaults to UTC+01:00.
"""
intarray = numpy.array(array, dtype=int)
for dummy in range(1, array.ndim):
intarray = intarray[:, 0]
return cls(datetime.datetime(*intarray[:6]))
|
[
"def",
"from_array",
"(",
"cls",
",",
"array",
")",
":",
"intarray",
"=",
"numpy",
".",
"array",
"(",
"array",
",",
"dtype",
"=",
"int",
")",
"for",
"dummy",
"in",
"range",
"(",
"1",
",",
"array",
".",
"ndim",
")",
":",
"intarray",
"=",
"intarray",
"[",
":",
",",
"0",
"]",
"return",
"cls",
"(",
"datetime",
".",
"datetime",
"(",
"*",
"intarray",
"[",
":",
"6",
"]",
")",
")"
] |
Return a |Date| instance based on date information (year,
month, day, hour, minute, second) stored as the first entries of
the successive rows of a |numpy.ndarray|.
>>> from hydpy import Date
>>> import numpy
>>> array1d = numpy.array([1992, 10, 8, 15, 15, 42, 999])
>>> Date.from_array(array1d)
Date('1992-10-08 15:15:42')
>>> array3d = numpy.zeros((7, 2, 2))
>>> array3d[:, 0, 0] = array1d
>>> Date.from_array(array3d)
Date('1992-10-08 15:15:42')
.. note::
The date defined by the given |numpy.ndarray| cannot
include any time zone information and corresponds to
|Options.utcoffset|, which defaults to UTC+01:00.
|
[
"Return",
"a",
"|Date|",
"instance",
"based",
"on",
"date",
"information",
"(",
"year",
"month",
"day",
"hour",
"minute",
"second",
")",
"stored",
"as",
"the",
"first",
"entries",
"of",
"the",
"successive",
"rows",
"of",
"a",
"|numpy",
".",
"ndarray|",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L256-L281
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Date.to_array
|
def to_array(self):
"""Return a 1-dimensional |numpy| |numpy.ndarray| with six entries
defining the actual date (year, month, day, hour, minute, second).
>>> from hydpy import Date
>>> Date('1992-10-8 15:15:42').to_array()
array([ 1992., 10., 8., 15., 15., 42.])
.. note::
The date defined by the returned |numpy.ndarray| does not
include any time zone information and corresponds to
|Options.utcoffset|, which defaults to UTC+01:00.
"""
return numpy.array([self.year, self.month, self.day, self.hour,
self.minute, self.second], dtype=float)
|
python
|
def to_array(self):
"""Return a 1-dimensional |numpy| |numpy.ndarray| with six entries
defining the actual date (year, month, day, hour, minute, second).
>>> from hydpy import Date
>>> Date('1992-10-8 15:15:42').to_array()
array([ 1992., 10., 8., 15., 15., 42.])
.. note::
The date defined by the returned |numpy.ndarray| does not
include any time zone information and corresponds to
|Options.utcoffset|, which defaults to UTC+01:00.
"""
return numpy.array([self.year, self.month, self.day, self.hour,
self.minute, self.second], dtype=float)
|
[
"def",
"to_array",
"(",
"self",
")",
":",
"return",
"numpy",
".",
"array",
"(",
"[",
"self",
".",
"year",
",",
"self",
".",
"month",
",",
"self",
".",
"day",
",",
"self",
".",
"hour",
",",
"self",
".",
"minute",
",",
"self",
".",
"second",
"]",
",",
"dtype",
"=",
"float",
")"
] |
Return a 1-dimensional |numpy| |numpy.ndarray| with six entries
defining the actual date (year, month, day, hour, minute, second).
>>> from hydpy import Date
>>> Date('1992-10-8 15:15:42').to_array()
array([ 1992., 10., 8., 15., 15., 42.])
.. note::
The date defined by the returned |numpy.ndarray| does not
include any time zone information and corresponds to
|Options.utcoffset|, which defaults to UTC+01:00.
|
[
"Return",
"a",
"1",
"-",
"dimensional",
"|numpy|",
"|numpy",
".",
"ndarray|",
"with",
"six",
"entries",
"defining",
"the",
"actual",
"date",
"(",
"year",
"month",
"day",
"hour",
"minute",
"second",
")",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L283-L298
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Date.from_cfunits
|
def from_cfunits(cls, units) -> 'Date':
"""Return a |Date| object representing the reference date of the
given `units` string agreeing with the NetCDF-CF conventions.
The following example string is taken from the `Time Coordinate`_
chapter of the NetCDF-CF conventions documentation (modified).
Note that the first entry (the unit) is ignored:
>>> from hydpy import Date
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42 -6:00')
Date('1992-10-08 22:15:42')
>>> Date.from_cfunits(' day since 1992-10-8 15:15:00')
Date('1992-10-08 15:15:00')
>>> Date.from_cfunits('seconds since 1992-10-8 -6:00')
Date('1992-10-08 07:00:00')
>>> Date.from_cfunits('m since 1992-10-8')
Date('1992-10-08 00:00:00')
Without modification, when "0" is included as the decimal fractions
of a second, the example string from `Time Coordinate`_ can also
be passed. However, fractions different from "0" result in
an error:
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42.')
Date('1992-10-08 15:15:42')
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42.00')
Date('1992-10-08 15:15:42')
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42. -6:00')
Date('1992-10-08 22:15:42')
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42.0 -6:00')
Date('1992-10-08 22:15:42')
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42.005 -6:00')
Traceback (most recent call last):
...
ValueError: While trying to parse the date of the NetCDF-CF "units" \
string `seconds since 1992-10-8 15:15:42.005 -6:00`, the following error \
occurred: No other decimal fraction of a second than "0" allowed.
"""
try:
string = units[units.find('since')+6:]
idx = string.find('.')
if idx != -1:
jdx = None
for jdx, char in enumerate(string[idx+1:]):
if not char.isnumeric():
break
if char != '0':
raise ValueError(
'No other decimal fraction of a second '
'than "0" allowed.')
else:
if jdx is None:
jdx = idx+1
else:
jdx += 1
string = f'{string[:idx]}{string[idx+jdx+1:]}'
return cls(string)
except BaseException:
objecttools.augment_excmessage(
f'While trying to parse the date of the NetCDF-CF "units" '
f'string `{units}`')
|
python
|
def from_cfunits(cls, units) -> 'Date':
"""Return a |Date| object representing the reference date of the
given `units` string agreeing with the NetCDF-CF conventions.
The following example string is taken from the `Time Coordinate`_
chapter of the NetCDF-CF conventions documentation (modified).
Note that the first entry (the unit) is ignored:
>>> from hydpy import Date
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42 -6:00')
Date('1992-10-08 22:15:42')
>>> Date.from_cfunits(' day since 1992-10-8 15:15:00')
Date('1992-10-08 15:15:00')
>>> Date.from_cfunits('seconds since 1992-10-8 -6:00')
Date('1992-10-08 07:00:00')
>>> Date.from_cfunits('m since 1992-10-8')
Date('1992-10-08 00:00:00')
Without modification, when "0" is included as the decimal fractions
of a second, the example string from `Time Coordinate`_ can also
be passed. However, fractions different from "0" result in
an error:
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42.')
Date('1992-10-08 15:15:42')
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42.00')
Date('1992-10-08 15:15:42')
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42. -6:00')
Date('1992-10-08 22:15:42')
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42.0 -6:00')
Date('1992-10-08 22:15:42')
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42.005 -6:00')
Traceback (most recent call last):
...
ValueError: While trying to parse the date of the NetCDF-CF "units" \
string `seconds since 1992-10-8 15:15:42.005 -6:00`, the following error \
occurred: No other decimal fraction of a second than "0" allowed.
"""
try:
string = units[units.find('since')+6:]
idx = string.find('.')
if idx != -1:
jdx = None
for jdx, char in enumerate(string[idx+1:]):
if not char.isnumeric():
break
if char != '0':
raise ValueError(
'No other decimal fraction of a second '
'than "0" allowed.')
else:
if jdx is None:
jdx = idx+1
else:
jdx += 1
string = f'{string[:idx]}{string[idx+jdx+1:]}'
return cls(string)
except BaseException:
objecttools.augment_excmessage(
f'While trying to parse the date of the NetCDF-CF "units" '
f'string `{units}`')
|
[
"def",
"from_cfunits",
"(",
"cls",
",",
"units",
")",
"->",
"'Date'",
":",
"try",
":",
"string",
"=",
"units",
"[",
"units",
".",
"find",
"(",
"'since'",
")",
"+",
"6",
":",
"]",
"idx",
"=",
"string",
".",
"find",
"(",
"'.'",
")",
"if",
"idx",
"!=",
"-",
"1",
":",
"jdx",
"=",
"None",
"for",
"jdx",
",",
"char",
"in",
"enumerate",
"(",
"string",
"[",
"idx",
"+",
"1",
":",
"]",
")",
":",
"if",
"not",
"char",
".",
"isnumeric",
"(",
")",
":",
"break",
"if",
"char",
"!=",
"'0'",
":",
"raise",
"ValueError",
"(",
"'No other decimal fraction of a second '",
"'than \"0\" allowed.'",
")",
"else",
":",
"if",
"jdx",
"is",
"None",
":",
"jdx",
"=",
"idx",
"+",
"1",
"else",
":",
"jdx",
"+=",
"1",
"string",
"=",
"f'{string[:idx]}{string[idx+jdx+1:]}'",
"return",
"cls",
"(",
"string",
")",
"except",
"BaseException",
":",
"objecttools",
".",
"augment_excmessage",
"(",
"f'While trying to parse the date of the NetCDF-CF \"units\" '",
"f'string `{units}`'",
")"
] |
Return a |Date| object representing the reference date of the
given `units` string agreeing with the NetCDF-CF conventions.
The following example string is taken from the `Time Coordinate`_
chapter of the NetCDF-CF conventions documentation (modified).
Note that the first entry (the unit) is ignored:
>>> from hydpy import Date
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42 -6:00')
Date('1992-10-08 22:15:42')
>>> Date.from_cfunits(' day since 1992-10-8 15:15:00')
Date('1992-10-08 15:15:00')
>>> Date.from_cfunits('seconds since 1992-10-8 -6:00')
Date('1992-10-08 07:00:00')
>>> Date.from_cfunits('m since 1992-10-8')
Date('1992-10-08 00:00:00')
Without modification, when "0" is included as the decimal fractions
of a second, the example string from `Time Coordinate`_ can also
be passed. However, fractions different from "0" result in
an error:
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42.')
Date('1992-10-08 15:15:42')
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42.00')
Date('1992-10-08 15:15:42')
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42. -6:00')
Date('1992-10-08 22:15:42')
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42.0 -6:00')
Date('1992-10-08 22:15:42')
>>> Date.from_cfunits('seconds since 1992-10-8 15:15:42.005 -6:00')
Traceback (most recent call last):
...
ValueError: While trying to parse the date of the NetCDF-CF "units" \
string `seconds since 1992-10-8 15:15:42.005 -6:00`, the following error \
occurred: No other decimal fraction of a second than "0" allowed.
|
[
"Return",
"a",
"|Date|",
"object",
"representing",
"the",
"reference",
"date",
"of",
"the",
"given",
"units",
"string",
"agreeing",
"with",
"the",
"NetCDF",
"-",
"CF",
"conventions",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L301-L361
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Date.to_cfunits
|
def to_cfunits(self, unit='hours', utcoffset=None):
"""Return a `units` string agreeing with the NetCDF-CF conventions.
By default, |Date.to_cfunits| takes `hours` as time unit, and the
the actual value of |Options.utcoffset| as time zone information:
>>> from hydpy import Date
>>> date = Date('1992-10-08 15:15:42')
>>> date.to_cfunits()
'hours since 1992-10-08 15:15:42 +01:00'
Other time units are allowed (no checks are performed, so select
something useful):
>>> date.to_cfunits(unit='minutes')
'minutes since 1992-10-08 15:15:42 +01:00'
For changing the time zone, pass the corresponding offset in minutes:
>>> date.to_cfunits(unit='sec', utcoffset=-60)
'sec since 1992-10-08 13:15:42 -01:00'
"""
if utcoffset is None:
utcoffset = hydpy.pub.options.utcoffset
string = self.to_string('iso2', utcoffset)
string = ' '.join((string[:-6], string[-6:]))
return f'{unit} since {string}'
|
python
|
def to_cfunits(self, unit='hours', utcoffset=None):
"""Return a `units` string agreeing with the NetCDF-CF conventions.
By default, |Date.to_cfunits| takes `hours` as time unit, and the
the actual value of |Options.utcoffset| as time zone information:
>>> from hydpy import Date
>>> date = Date('1992-10-08 15:15:42')
>>> date.to_cfunits()
'hours since 1992-10-08 15:15:42 +01:00'
Other time units are allowed (no checks are performed, so select
something useful):
>>> date.to_cfunits(unit='minutes')
'minutes since 1992-10-08 15:15:42 +01:00'
For changing the time zone, pass the corresponding offset in minutes:
>>> date.to_cfunits(unit='sec', utcoffset=-60)
'sec since 1992-10-08 13:15:42 -01:00'
"""
if utcoffset is None:
utcoffset = hydpy.pub.options.utcoffset
string = self.to_string('iso2', utcoffset)
string = ' '.join((string[:-6], string[-6:]))
return f'{unit} since {string}'
|
[
"def",
"to_cfunits",
"(",
"self",
",",
"unit",
"=",
"'hours'",
",",
"utcoffset",
"=",
"None",
")",
":",
"if",
"utcoffset",
"is",
"None",
":",
"utcoffset",
"=",
"hydpy",
".",
"pub",
".",
"options",
".",
"utcoffset",
"string",
"=",
"self",
".",
"to_string",
"(",
"'iso2'",
",",
"utcoffset",
")",
"string",
"=",
"' '",
".",
"join",
"(",
"(",
"string",
"[",
":",
"-",
"6",
"]",
",",
"string",
"[",
"-",
"6",
":",
"]",
")",
")",
"return",
"f'{unit} since {string}'"
] |
Return a `units` string agreeing with the NetCDF-CF conventions.
By default, |Date.to_cfunits| takes `hours` as time unit, and the
the actual value of |Options.utcoffset| as time zone information:
>>> from hydpy import Date
>>> date = Date('1992-10-08 15:15:42')
>>> date.to_cfunits()
'hours since 1992-10-08 15:15:42 +01:00'
Other time units are allowed (no checks are performed, so select
something useful):
>>> date.to_cfunits(unit='minutes')
'minutes since 1992-10-08 15:15:42 +01:00'
For changing the time zone, pass the corresponding offset in minutes:
>>> date.to_cfunits(unit='sec', utcoffset=-60)
'sec since 1992-10-08 13:15:42 -01:00'
|
[
"Return",
"a",
"units",
"string",
"agreeing",
"with",
"the",
"NetCDF",
"-",
"CF",
"conventions",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L363-L389
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Date._set_thing
|
def _set_thing(self, thing, value):
"""Convenience method for `_set_year`, `_set_month`..."""
try:
value = int(value)
except (TypeError, ValueError):
raise TypeError(
f'Changing the {thing} of a `Date` instance is only '
f'allowed via numbers, but the given value `{value}` '
f'is of type `{type(value)}` instead.')
kwargs = {}
for unit in ('year', 'month', 'day', 'hour', 'minute', 'second'):
kwargs[unit] = getattr(self, unit)
kwargs[thing] = value
self.datetime = datetime.datetime(**kwargs)
|
python
|
def _set_thing(self, thing, value):
"""Convenience method for `_set_year`, `_set_month`..."""
try:
value = int(value)
except (TypeError, ValueError):
raise TypeError(
f'Changing the {thing} of a `Date` instance is only '
f'allowed via numbers, but the given value `{value}` '
f'is of type `{type(value)}` instead.')
kwargs = {}
for unit in ('year', 'month', 'day', 'hour', 'minute', 'second'):
kwargs[unit] = getattr(self, unit)
kwargs[thing] = value
self.datetime = datetime.datetime(**kwargs)
|
[
"def",
"_set_thing",
"(",
"self",
",",
"thing",
",",
"value",
")",
":",
"try",
":",
"value",
"=",
"int",
"(",
"value",
")",
"except",
"(",
"TypeError",
",",
"ValueError",
")",
":",
"raise",
"TypeError",
"(",
"f'Changing the {thing} of a `Date` instance is only '",
"f'allowed via numbers, but the given value `{value}` '",
"f'is of type `{type(value)}` instead.'",
")",
"kwargs",
"=",
"{",
"}",
"for",
"unit",
"in",
"(",
"'year'",
",",
"'month'",
",",
"'day'",
",",
"'hour'",
",",
"'minute'",
",",
"'second'",
")",
":",
"kwargs",
"[",
"unit",
"]",
"=",
"getattr",
"(",
"self",
",",
"unit",
")",
"kwargs",
"[",
"thing",
"]",
"=",
"value",
"self",
".",
"datetime",
"=",
"datetime",
".",
"datetime",
"(",
"*",
"*",
"kwargs",
")"
] |
Convenience method for `_set_year`, `_set_month`...
|
[
"Convenience",
"method",
"for",
"_set_year",
"_set_month",
"..."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L455-L468
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Date.wateryear
|
def wateryear(self):
"""The actual hydrological year according to the selected
reference month.
The reference mont reference |Date.refmonth| defaults to November:
>>> october = Date('1996.10.01')
>>> november = Date('1996.11.01')
>>> october.wateryear
1996
>>> november.wateryear
1997
Note that changing |Date.refmonth| affects all |Date| objects:
>>> october.refmonth = 10
>>> october.wateryear
1997
>>> november.wateryear
1997
>>> october.refmonth = 'November'
>>> october.wateryear
1996
>>> november.wateryear
1997
"""
if self.month < self._firstmonth_wateryear:
return self.year
return self.year + 1
|
python
|
def wateryear(self):
"""The actual hydrological year according to the selected
reference month.
The reference mont reference |Date.refmonth| defaults to November:
>>> october = Date('1996.10.01')
>>> november = Date('1996.11.01')
>>> october.wateryear
1996
>>> november.wateryear
1997
Note that changing |Date.refmonth| affects all |Date| objects:
>>> october.refmonth = 10
>>> october.wateryear
1997
>>> november.wateryear
1997
>>> october.refmonth = 'November'
>>> october.wateryear
1996
>>> november.wateryear
1997
"""
if self.month < self._firstmonth_wateryear:
return self.year
return self.year + 1
|
[
"def",
"wateryear",
"(",
"self",
")",
":",
"if",
"self",
".",
"month",
"<",
"self",
".",
"_firstmonth_wateryear",
":",
"return",
"self",
".",
"year",
"return",
"self",
".",
"year",
"+",
"1"
] |
The actual hydrological year according to the selected
reference month.
The reference mont reference |Date.refmonth| defaults to November:
>>> october = Date('1996.10.01')
>>> november = Date('1996.11.01')
>>> october.wateryear
1996
>>> november.wateryear
1997
Note that changing |Date.refmonth| affects all |Date| objects:
>>> october.refmonth = 10
>>> october.wateryear
1997
>>> november.wateryear
1997
>>> october.refmonth = 'November'
>>> october.wateryear
1996
>>> november.wateryear
1997
|
[
"The",
"actual",
"hydrological",
"year",
"according",
"to",
"the",
"selected",
"reference",
"month",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L582-L610
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Date.to_string
|
def to_string(self, style=None, utcoffset=None):
"""Return a |str| object representing the actual date in
accordance with the given style and the eventually given
UTC offset (in minutes).
Without any input arguments, the actual |Date.style| is used
to return a date string in your local time zone:
>>> from hydpy import Date
>>> date = Date('01.11.1997 00:00:00')
>>> date.to_string()
'01.11.1997 00:00:00'
Passing a style string affects the returned |str| object, but
not the |Date.style| property:
>>> date.style
'din1'
>>> date.to_string(style='iso2')
'1997-11-01 00:00:00'
>>> date.style
'din1'
When passing the `utcoffset` in minutes, the offset string is
appended:
>>> date.to_string(style='iso2', utcoffset=60)
'1997-11-01 00:00:00+01:00'
If the given offset does not correspond to your local offset
defined by |Options.utcoffset| (which defaults to UTC+01:00),
the date string is adapted:
>>> date.to_string(style='iso1', utcoffset=0)
'1997-10-31T23:00:00+00:00'
"""
if not style:
style = self.style
if utcoffset is None:
string = ''
date = self.datetime
else:
sign = '+' if utcoffset >= 0 else '-'
hours = abs(utcoffset // 60)
minutes = abs(utcoffset % 60)
string = f'{sign}{hours:02d}:{minutes:02d}'
offset = utcoffset-hydpy.pub.options.utcoffset
date = self.datetime + datetime.timedelta(minutes=offset)
return date.strftime(self._formatstrings[style]) + string
|
python
|
def to_string(self, style=None, utcoffset=None):
"""Return a |str| object representing the actual date in
accordance with the given style and the eventually given
UTC offset (in minutes).
Without any input arguments, the actual |Date.style| is used
to return a date string in your local time zone:
>>> from hydpy import Date
>>> date = Date('01.11.1997 00:00:00')
>>> date.to_string()
'01.11.1997 00:00:00'
Passing a style string affects the returned |str| object, but
not the |Date.style| property:
>>> date.style
'din1'
>>> date.to_string(style='iso2')
'1997-11-01 00:00:00'
>>> date.style
'din1'
When passing the `utcoffset` in minutes, the offset string is
appended:
>>> date.to_string(style='iso2', utcoffset=60)
'1997-11-01 00:00:00+01:00'
If the given offset does not correspond to your local offset
defined by |Options.utcoffset| (which defaults to UTC+01:00),
the date string is adapted:
>>> date.to_string(style='iso1', utcoffset=0)
'1997-10-31T23:00:00+00:00'
"""
if not style:
style = self.style
if utcoffset is None:
string = ''
date = self.datetime
else:
sign = '+' if utcoffset >= 0 else '-'
hours = abs(utcoffset // 60)
minutes = abs(utcoffset % 60)
string = f'{sign}{hours:02d}:{minutes:02d}'
offset = utcoffset-hydpy.pub.options.utcoffset
date = self.datetime + datetime.timedelta(minutes=offset)
return date.strftime(self._formatstrings[style]) + string
|
[
"def",
"to_string",
"(",
"self",
",",
"style",
"=",
"None",
",",
"utcoffset",
"=",
"None",
")",
":",
"if",
"not",
"style",
":",
"style",
"=",
"self",
".",
"style",
"if",
"utcoffset",
"is",
"None",
":",
"string",
"=",
"''",
"date",
"=",
"self",
".",
"datetime",
"else",
":",
"sign",
"=",
"'+'",
"if",
"utcoffset",
">=",
"0",
"else",
"'-'",
"hours",
"=",
"abs",
"(",
"utcoffset",
"//",
"60",
")",
"minutes",
"=",
"abs",
"(",
"utcoffset",
"%",
"60",
")",
"string",
"=",
"f'{sign}{hours:02d}:{minutes:02d}'",
"offset",
"=",
"utcoffset",
"-",
"hydpy",
".",
"pub",
".",
"options",
".",
"utcoffset",
"date",
"=",
"self",
".",
"datetime",
"+",
"datetime",
".",
"timedelta",
"(",
"minutes",
"=",
"offset",
")",
"return",
"date",
".",
"strftime",
"(",
"self",
".",
"_formatstrings",
"[",
"style",
"]",
")",
"+",
"string"
] |
Return a |str| object representing the actual date in
accordance with the given style and the eventually given
UTC offset (in minutes).
Without any input arguments, the actual |Date.style| is used
to return a date string in your local time zone:
>>> from hydpy import Date
>>> date = Date('01.11.1997 00:00:00')
>>> date.to_string()
'01.11.1997 00:00:00'
Passing a style string affects the returned |str| object, but
not the |Date.style| property:
>>> date.style
'din1'
>>> date.to_string(style='iso2')
'1997-11-01 00:00:00'
>>> date.style
'din1'
When passing the `utcoffset` in minutes, the offset string is
appended:
>>> date.to_string(style='iso2', utcoffset=60)
'1997-11-01 00:00:00+01:00'
If the given offset does not correspond to your local offset
defined by |Options.utcoffset| (which defaults to UTC+01:00),
the date string is adapted:
>>> date.to_string(style='iso1', utcoffset=0)
'1997-10-31T23:00:00+00:00'
|
[
"Return",
"a",
"|str|",
"object",
"representing",
"the",
"actual",
"date",
"in",
"accordance",
"with",
"the",
"given",
"style",
"and",
"the",
"eventually",
"given",
"UTC",
"offset",
"(",
"in",
"minutes",
")",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L686-L734
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Period.fromseconds
|
def fromseconds(cls, seconds):
"""Return a |Period| instance based on a given number of seconds."""
try:
seconds = int(seconds)
except TypeError:
seconds = int(seconds.flatten()[0])
return cls(datetime.timedelta(0, int(seconds)))
|
python
|
def fromseconds(cls, seconds):
"""Return a |Period| instance based on a given number of seconds."""
try:
seconds = int(seconds)
except TypeError:
seconds = int(seconds.flatten()[0])
return cls(datetime.timedelta(0, int(seconds)))
|
[
"def",
"fromseconds",
"(",
"cls",
",",
"seconds",
")",
":",
"try",
":",
"seconds",
"=",
"int",
"(",
"seconds",
")",
"except",
"TypeError",
":",
"seconds",
"=",
"int",
"(",
"seconds",
".",
"flatten",
"(",
")",
"[",
"0",
"]",
")",
"return",
"cls",
"(",
"datetime",
".",
"timedelta",
"(",
"0",
",",
"int",
"(",
"seconds",
")",
")",
")"
] |
Return a |Period| instance based on a given number of seconds.
|
[
"Return",
"a",
"|Period|",
"instance",
"based",
"on",
"a",
"given",
"number",
"of",
"seconds",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L945-L951
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Period._guessunit
|
def _guessunit(self):
"""Guess the unit of the period as the largest one, which results in
an integer duration.
"""
if not self.days % 1:
return 'd'
elif not self.hours % 1:
return 'h'
elif not self.minutes % 1:
return 'm'
elif not self.seconds % 1:
return 's'
else:
raise ValueError(
'The stepsize is not a multiple of one '
'second, which is not allowed.')
|
python
|
def _guessunit(self):
"""Guess the unit of the period as the largest one, which results in
an integer duration.
"""
if not self.days % 1:
return 'd'
elif not self.hours % 1:
return 'h'
elif not self.minutes % 1:
return 'm'
elif not self.seconds % 1:
return 's'
else:
raise ValueError(
'The stepsize is not a multiple of one '
'second, which is not allowed.')
|
[
"def",
"_guessunit",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"days",
"%",
"1",
":",
"return",
"'d'",
"elif",
"not",
"self",
".",
"hours",
"%",
"1",
":",
"return",
"'h'",
"elif",
"not",
"self",
".",
"minutes",
"%",
"1",
":",
"return",
"'m'",
"elif",
"not",
"self",
".",
"seconds",
"%",
"1",
":",
"return",
"'s'",
"else",
":",
"raise",
"ValueError",
"(",
"'The stepsize is not a multiple of one '",
"'second, which is not allowed.'",
")"
] |
Guess the unit of the period as the largest one, which results in
an integer duration.
|
[
"Guess",
"the",
"unit",
"of",
"the",
"period",
"as",
"the",
"largest",
"one",
"which",
"results",
"in",
"an",
"integer",
"duration",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L972-L987
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Timegrid.from_array
|
def from_array(cls, array):
"""Returns a |Timegrid| instance based on two date and one period
information stored in the first 13 rows of a |numpy.ndarray| object.
"""
try:
return cls(Date.from_array(array[:6]),
Date.from_array(array[6:12]),
Period.fromseconds(array[12]))
except IndexError:
raise IndexError(
f'To define a Timegrid instance via an array, 13 '
f'numbers are required. However, the given array '
f'consist of {len(array)} entries/rows only.')
|
python
|
def from_array(cls, array):
"""Returns a |Timegrid| instance based on two date and one period
information stored in the first 13 rows of a |numpy.ndarray| object.
"""
try:
return cls(Date.from_array(array[:6]),
Date.from_array(array[6:12]),
Period.fromseconds(array[12]))
except IndexError:
raise IndexError(
f'To define a Timegrid instance via an array, 13 '
f'numbers are required. However, the given array '
f'consist of {len(array)} entries/rows only.')
|
[
"def",
"from_array",
"(",
"cls",
",",
"array",
")",
":",
"try",
":",
"return",
"cls",
"(",
"Date",
".",
"from_array",
"(",
"array",
"[",
":",
"6",
"]",
")",
",",
"Date",
".",
"from_array",
"(",
"array",
"[",
"6",
":",
"12",
"]",
")",
",",
"Period",
".",
"fromseconds",
"(",
"array",
"[",
"12",
"]",
")",
")",
"except",
"IndexError",
":",
"raise",
"IndexError",
"(",
"f'To define a Timegrid instance via an array, 13 '",
"f'numbers are required. However, the given array '",
"f'consist of {len(array)} entries/rows only.'",
")"
] |
Returns a |Timegrid| instance based on two date and one period
information stored in the first 13 rows of a |numpy.ndarray| object.
|
[
"Returns",
"a",
"|Timegrid|",
"instance",
"based",
"on",
"two",
"date",
"and",
"one",
"period",
"information",
"stored",
"in",
"the",
"first",
"13",
"rows",
"of",
"a",
"|numpy",
".",
"ndarray|",
"object",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L1285-L1297
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Timegrid.to_array
|
def to_array(self):
"""Returns a 1-dimensional |numpy| |numpy.ndarray| with thirteen
entries first defining the start date, secondly defining the end
date and thirdly the step size in seconds.
"""
values = numpy.empty(13, dtype=float)
values[:6] = self.firstdate.to_array()
values[6:12] = self.lastdate.to_array()
values[12] = self.stepsize.seconds
return values
|
python
|
def to_array(self):
"""Returns a 1-dimensional |numpy| |numpy.ndarray| with thirteen
entries first defining the start date, secondly defining the end
date and thirdly the step size in seconds.
"""
values = numpy.empty(13, dtype=float)
values[:6] = self.firstdate.to_array()
values[6:12] = self.lastdate.to_array()
values[12] = self.stepsize.seconds
return values
|
[
"def",
"to_array",
"(",
"self",
")",
":",
"values",
"=",
"numpy",
".",
"empty",
"(",
"13",
",",
"dtype",
"=",
"float",
")",
"values",
"[",
":",
"6",
"]",
"=",
"self",
".",
"firstdate",
".",
"to_array",
"(",
")",
"values",
"[",
"6",
":",
"12",
"]",
"=",
"self",
".",
"lastdate",
".",
"to_array",
"(",
")",
"values",
"[",
"12",
"]",
"=",
"self",
".",
"stepsize",
".",
"seconds",
"return",
"values"
] |
Returns a 1-dimensional |numpy| |numpy.ndarray| with thirteen
entries first defining the start date, secondly defining the end
date and thirdly the step size in seconds.
|
[
"Returns",
"a",
"1",
"-",
"dimensional",
"|numpy|",
"|numpy",
".",
"ndarray|",
"with",
"thirteen",
"entries",
"first",
"defining",
"the",
"start",
"date",
"secondly",
"defining",
"the",
"end",
"date",
"and",
"thirdly",
"the",
"step",
"size",
"in",
"seconds",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L1299-L1308
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Timegrid.from_timepoints
|
def from_timepoints(cls, timepoints, refdate, unit='hours'):
"""Return a |Timegrid| object representing the given starting
`timepoints` in relation to the given `refdate`.
The following examples identical with the ones of
|Timegrid.to_timepoints| but reversed.
At least two given time points must be increasing and
equidistant. By default, they are assumed in hours since
the given reference date:
>>> from hydpy import Timegrid
>>> Timegrid.from_timepoints(
... [0.0, 6.0, 12.0, 18.0], '01.01.2000')
Timegrid('01.01.2000 00:00:00',
'02.01.2000 00:00:00',
'6h')
>>> Timegrid.from_timepoints(
... [24.0, 30.0, 36.0, 42.0], '1999-12-31')
Timegrid('2000-01-01 00:00:00',
'2000-01-02 00:00:00',
'6h')
Other time units (`days` or `min`) must be passed explicitely
(only the first character counts):
>>> Timegrid.from_timepoints(
... [0.0, 0.25, 0.5, 0.75], '01.01.2000', unit='d')
Timegrid('01.01.2000 00:00:00',
'02.01.2000 00:00:00',
'6h')
>>> Timegrid.from_timepoints(
... [1.0, 1.25, 1.5, 1.75], '1999-12-31', unit='day')
Timegrid('2000-01-01 00:00:00',
'2000-01-02 00:00:00',
'6h')
"""
refdate = Date(refdate)
unit = Period.from_cfunits(unit)
delta = timepoints[1]-timepoints[0]
firstdate = refdate+timepoints[0]*unit
lastdate = refdate+(timepoints[-1]+delta)*unit
stepsize = (lastdate-firstdate)/len(timepoints)
return cls(firstdate, lastdate, stepsize)
|
python
|
def from_timepoints(cls, timepoints, refdate, unit='hours'):
"""Return a |Timegrid| object representing the given starting
`timepoints` in relation to the given `refdate`.
The following examples identical with the ones of
|Timegrid.to_timepoints| but reversed.
At least two given time points must be increasing and
equidistant. By default, they are assumed in hours since
the given reference date:
>>> from hydpy import Timegrid
>>> Timegrid.from_timepoints(
... [0.0, 6.0, 12.0, 18.0], '01.01.2000')
Timegrid('01.01.2000 00:00:00',
'02.01.2000 00:00:00',
'6h')
>>> Timegrid.from_timepoints(
... [24.0, 30.0, 36.0, 42.0], '1999-12-31')
Timegrid('2000-01-01 00:00:00',
'2000-01-02 00:00:00',
'6h')
Other time units (`days` or `min`) must be passed explicitely
(only the first character counts):
>>> Timegrid.from_timepoints(
... [0.0, 0.25, 0.5, 0.75], '01.01.2000', unit='d')
Timegrid('01.01.2000 00:00:00',
'02.01.2000 00:00:00',
'6h')
>>> Timegrid.from_timepoints(
... [1.0, 1.25, 1.5, 1.75], '1999-12-31', unit='day')
Timegrid('2000-01-01 00:00:00',
'2000-01-02 00:00:00',
'6h')
"""
refdate = Date(refdate)
unit = Period.from_cfunits(unit)
delta = timepoints[1]-timepoints[0]
firstdate = refdate+timepoints[0]*unit
lastdate = refdate+(timepoints[-1]+delta)*unit
stepsize = (lastdate-firstdate)/len(timepoints)
return cls(firstdate, lastdate, stepsize)
|
[
"def",
"from_timepoints",
"(",
"cls",
",",
"timepoints",
",",
"refdate",
",",
"unit",
"=",
"'hours'",
")",
":",
"refdate",
"=",
"Date",
"(",
"refdate",
")",
"unit",
"=",
"Period",
".",
"from_cfunits",
"(",
"unit",
")",
"delta",
"=",
"timepoints",
"[",
"1",
"]",
"-",
"timepoints",
"[",
"0",
"]",
"firstdate",
"=",
"refdate",
"+",
"timepoints",
"[",
"0",
"]",
"*",
"unit",
"lastdate",
"=",
"refdate",
"+",
"(",
"timepoints",
"[",
"-",
"1",
"]",
"+",
"delta",
")",
"*",
"unit",
"stepsize",
"=",
"(",
"lastdate",
"-",
"firstdate",
")",
"/",
"len",
"(",
"timepoints",
")",
"return",
"cls",
"(",
"firstdate",
",",
"lastdate",
",",
"stepsize",
")"
] |
Return a |Timegrid| object representing the given starting
`timepoints` in relation to the given `refdate`.
The following examples identical with the ones of
|Timegrid.to_timepoints| but reversed.
At least two given time points must be increasing and
equidistant. By default, they are assumed in hours since
the given reference date:
>>> from hydpy import Timegrid
>>> Timegrid.from_timepoints(
... [0.0, 6.0, 12.0, 18.0], '01.01.2000')
Timegrid('01.01.2000 00:00:00',
'02.01.2000 00:00:00',
'6h')
>>> Timegrid.from_timepoints(
... [24.0, 30.0, 36.0, 42.0], '1999-12-31')
Timegrid('2000-01-01 00:00:00',
'2000-01-02 00:00:00',
'6h')
Other time units (`days` or `min`) must be passed explicitely
(only the first character counts):
>>> Timegrid.from_timepoints(
... [0.0, 0.25, 0.5, 0.75], '01.01.2000', unit='d')
Timegrid('01.01.2000 00:00:00',
'02.01.2000 00:00:00',
'6h')
>>> Timegrid.from_timepoints(
... [1.0, 1.25, 1.5, 1.75], '1999-12-31', unit='day')
Timegrid('2000-01-01 00:00:00',
'2000-01-02 00:00:00',
'6h')
|
[
"Return",
"a",
"|Timegrid|",
"object",
"representing",
"the",
"given",
"starting",
"timepoints",
"in",
"relation",
"to",
"the",
"given",
"refdate",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L1311-L1354
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Timegrid.to_timepoints
|
def to_timepoints(self, unit='hours', offset=None):
"""Return an |numpy.ndarray| representing the starting time points
of the |Timegrid| object.
The following examples identical with the ones of
|Timegrid.from_timepoints| but reversed.
By default, the time points are given in hours:
>>> from hydpy import Timegrid
>>> timegrid = Timegrid('2000-01-01', '2000-01-02', '6h')
>>> timegrid.to_timepoints()
array([ 0., 6., 12., 18.])
Other time units (`days` or `min`) can be defined (only the first
character counts):
>>> timegrid.to_timepoints(unit='d')
array([ 0. , 0.25, 0.5 , 0.75])
Additionally, one can pass an `offset` that must be of type |int|
or an valid |Period| initialization argument:
>>> timegrid.to_timepoints(offset=24)
array([ 24., 30., 36., 42.])
>>> timegrid.to_timepoints(offset='1d')
array([ 24., 30., 36., 42.])
>>> timegrid.to_timepoints(unit='day', offset='1d')
array([ 1. , 1.25, 1.5 , 1.75])
"""
unit = Period.from_cfunits(unit)
if offset is None:
offset = 0.
else:
try:
offset = Period(offset)/unit
except TypeError:
offset = offset
step = self.stepsize/unit
nmb = len(self)
variable = numpy.linspace(offset, offset+step*(nmb-1), nmb)
return variable
|
python
|
def to_timepoints(self, unit='hours', offset=None):
"""Return an |numpy.ndarray| representing the starting time points
of the |Timegrid| object.
The following examples identical with the ones of
|Timegrid.from_timepoints| but reversed.
By default, the time points are given in hours:
>>> from hydpy import Timegrid
>>> timegrid = Timegrid('2000-01-01', '2000-01-02', '6h')
>>> timegrid.to_timepoints()
array([ 0., 6., 12., 18.])
Other time units (`days` or `min`) can be defined (only the first
character counts):
>>> timegrid.to_timepoints(unit='d')
array([ 0. , 0.25, 0.5 , 0.75])
Additionally, one can pass an `offset` that must be of type |int|
or an valid |Period| initialization argument:
>>> timegrid.to_timepoints(offset=24)
array([ 24., 30., 36., 42.])
>>> timegrid.to_timepoints(offset='1d')
array([ 24., 30., 36., 42.])
>>> timegrid.to_timepoints(unit='day', offset='1d')
array([ 1. , 1.25, 1.5 , 1.75])
"""
unit = Period.from_cfunits(unit)
if offset is None:
offset = 0.
else:
try:
offset = Period(offset)/unit
except TypeError:
offset = offset
step = self.stepsize/unit
nmb = len(self)
variable = numpy.linspace(offset, offset+step*(nmb-1), nmb)
return variable
|
[
"def",
"to_timepoints",
"(",
"self",
",",
"unit",
"=",
"'hours'",
",",
"offset",
"=",
"None",
")",
":",
"unit",
"=",
"Period",
".",
"from_cfunits",
"(",
"unit",
")",
"if",
"offset",
"is",
"None",
":",
"offset",
"=",
"0.",
"else",
":",
"try",
":",
"offset",
"=",
"Period",
"(",
"offset",
")",
"/",
"unit",
"except",
"TypeError",
":",
"offset",
"=",
"offset",
"step",
"=",
"self",
".",
"stepsize",
"/",
"unit",
"nmb",
"=",
"len",
"(",
"self",
")",
"variable",
"=",
"numpy",
".",
"linspace",
"(",
"offset",
",",
"offset",
"+",
"step",
"*",
"(",
"nmb",
"-",
"1",
")",
",",
"nmb",
")",
"return",
"variable"
] |
Return an |numpy.ndarray| representing the starting time points
of the |Timegrid| object.
The following examples identical with the ones of
|Timegrid.from_timepoints| but reversed.
By default, the time points are given in hours:
>>> from hydpy import Timegrid
>>> timegrid = Timegrid('2000-01-01', '2000-01-02', '6h')
>>> timegrid.to_timepoints()
array([ 0., 6., 12., 18.])
Other time units (`days` or `min`) can be defined (only the first
character counts):
>>> timegrid.to_timepoints(unit='d')
array([ 0. , 0.25, 0.5 , 0.75])
Additionally, one can pass an `offset` that must be of type |int|
or an valid |Period| initialization argument:
>>> timegrid.to_timepoints(offset=24)
array([ 24., 30., 36., 42.])
>>> timegrid.to_timepoints(offset='1d')
array([ 24., 30., 36., 42.])
>>> timegrid.to_timepoints(unit='day', offset='1d')
array([ 1. , 1.25, 1.5 , 1.75])
|
[
"Return",
"an",
"|numpy",
".",
"ndarray|",
"representing",
"the",
"starting",
"time",
"points",
"of",
"the",
"|Timegrid|",
"object",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L1356-L1397
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Timegrid.array2series
|
def array2series(self, array):
"""Prefix the information of the actual Timegrid object to the given
array and return it.
The Timegrid information is stored in the first thirteen values of
the first axis of the returned series. Initialize a Timegrid object
and apply its `array2series` method on a simple list containing
numbers:
>>> from hydpy import Timegrid
>>> timegrid = Timegrid('2000-11-01 00:00', '2000-11-01 04:00', '1h')
>>> series = timegrid.array2series([1, 2, 3.5, '5.0'])
The first six entries contain the first date of the timegrid (year,
month, day, hour, minute, second):
>>> from hydpy import round_
>>> round_(series[:6])
2000.0, 11.0, 1.0, 0.0, 0.0, 0.0
The six subsequent entries contain the last date:
>>> round_(series[6:12])
2000.0, 11.0, 1.0, 4.0, 0.0, 0.0
The thirteens value is the step size in seconds:
>>> round_(series[12])
3600.0
The last four value are the ones of the given vector:
>>> round_(series[-4:])
1.0, 2.0, 3.5, 5.0
The given array can have an arbitrary number of dimensions:
>>> import numpy
>>> array = numpy.eye(4)
>>> series = timegrid.array2series(array)
Now the timegrid information is stored in the first column:
>>> round_(series[:13, 0])
2000.0, 11.0, 1.0, 0.0, 0.0, 0.0, 2000.0, 11.0, 1.0, 4.0, 0.0, 0.0, \
3600.0
All other columns of the first thirteen rows contain nan values, e.g.:
>>> round_(series[12, :])
3600.0, nan, nan, nan
The original values are stored in the last four rows, e.g.:
>>> round_(series[13, :])
1.0, 0.0, 0.0, 0.0
Inappropriate array objects result in error messages like:
>>> timegrid.array2series([[1, 2], [3]])
Traceback (most recent call last):
...
ValueError: While trying to prefix timegrid information to the given \
array, the following error occurred: setting an array element with a sequence.
If the given array does not fit to the defined timegrid, a special
error message is returned:
>>> timegrid.array2series([[1, 2], [3, 4]])
Traceback (most recent call last):
...
ValueError: When converting an array to a sequence, the lengths of \
the timegrid and the given array must be equal, but the length of the \
timegrid object is `4` and the length of the array object is `2`.
"""
try:
array = numpy.array(array, dtype=float)
except BaseException:
objecttools.augment_excmessage(
'While trying to prefix timegrid information to the '
'given array')
if len(array) != len(self):
raise ValueError(
f'When converting an array to a sequence, the lengths of the '
f'timegrid and the given array must be equal, but the length '
f'of the timegrid object is `{len(self)}` and the length of '
f'the array object is `{len(array)}`.')
shape = list(array.shape)
shape[0] += 13
series = numpy.full(shape, numpy.nan)
slices = [slice(0, 13)]
subshape = [13]
for dummy in range(1, series.ndim):
slices.append(slice(0, 1))
subshape.append(1)
series[tuple(slices)] = self.to_array().reshape(subshape)
series[13:] = array
return series
|
python
|
def array2series(self, array):
"""Prefix the information of the actual Timegrid object to the given
array and return it.
The Timegrid information is stored in the first thirteen values of
the first axis of the returned series. Initialize a Timegrid object
and apply its `array2series` method on a simple list containing
numbers:
>>> from hydpy import Timegrid
>>> timegrid = Timegrid('2000-11-01 00:00', '2000-11-01 04:00', '1h')
>>> series = timegrid.array2series([1, 2, 3.5, '5.0'])
The first six entries contain the first date of the timegrid (year,
month, day, hour, minute, second):
>>> from hydpy import round_
>>> round_(series[:6])
2000.0, 11.0, 1.0, 0.0, 0.0, 0.0
The six subsequent entries contain the last date:
>>> round_(series[6:12])
2000.0, 11.0, 1.0, 4.0, 0.0, 0.0
The thirteens value is the step size in seconds:
>>> round_(series[12])
3600.0
The last four value are the ones of the given vector:
>>> round_(series[-4:])
1.0, 2.0, 3.5, 5.0
The given array can have an arbitrary number of dimensions:
>>> import numpy
>>> array = numpy.eye(4)
>>> series = timegrid.array2series(array)
Now the timegrid information is stored in the first column:
>>> round_(series[:13, 0])
2000.0, 11.0, 1.0, 0.0, 0.0, 0.0, 2000.0, 11.0, 1.0, 4.0, 0.0, 0.0, \
3600.0
All other columns of the first thirteen rows contain nan values, e.g.:
>>> round_(series[12, :])
3600.0, nan, nan, nan
The original values are stored in the last four rows, e.g.:
>>> round_(series[13, :])
1.0, 0.0, 0.0, 0.0
Inappropriate array objects result in error messages like:
>>> timegrid.array2series([[1, 2], [3]])
Traceback (most recent call last):
...
ValueError: While trying to prefix timegrid information to the given \
array, the following error occurred: setting an array element with a sequence.
If the given array does not fit to the defined timegrid, a special
error message is returned:
>>> timegrid.array2series([[1, 2], [3, 4]])
Traceback (most recent call last):
...
ValueError: When converting an array to a sequence, the lengths of \
the timegrid and the given array must be equal, but the length of the \
timegrid object is `4` and the length of the array object is `2`.
"""
try:
array = numpy.array(array, dtype=float)
except BaseException:
objecttools.augment_excmessage(
'While trying to prefix timegrid information to the '
'given array')
if len(array) != len(self):
raise ValueError(
f'When converting an array to a sequence, the lengths of the '
f'timegrid and the given array must be equal, but the length '
f'of the timegrid object is `{len(self)}` and the length of '
f'the array object is `{len(array)}`.')
shape = list(array.shape)
shape[0] += 13
series = numpy.full(shape, numpy.nan)
slices = [slice(0, 13)]
subshape = [13]
for dummy in range(1, series.ndim):
slices.append(slice(0, 1))
subshape.append(1)
series[tuple(slices)] = self.to_array().reshape(subshape)
series[13:] = array
return series
|
[
"def",
"array2series",
"(",
"self",
",",
"array",
")",
":",
"try",
":",
"array",
"=",
"numpy",
".",
"array",
"(",
"array",
",",
"dtype",
"=",
"float",
")",
"except",
"BaseException",
":",
"objecttools",
".",
"augment_excmessage",
"(",
"'While trying to prefix timegrid information to the '",
"'given array'",
")",
"if",
"len",
"(",
"array",
")",
"!=",
"len",
"(",
"self",
")",
":",
"raise",
"ValueError",
"(",
"f'When converting an array to a sequence, the lengths of the '",
"f'timegrid and the given array must be equal, but the length '",
"f'of the timegrid object is `{len(self)}` and the length of '",
"f'the array object is `{len(array)}`.'",
")",
"shape",
"=",
"list",
"(",
"array",
".",
"shape",
")",
"shape",
"[",
"0",
"]",
"+=",
"13",
"series",
"=",
"numpy",
".",
"full",
"(",
"shape",
",",
"numpy",
".",
"nan",
")",
"slices",
"=",
"[",
"slice",
"(",
"0",
",",
"13",
")",
"]",
"subshape",
"=",
"[",
"13",
"]",
"for",
"dummy",
"in",
"range",
"(",
"1",
",",
"series",
".",
"ndim",
")",
":",
"slices",
".",
"append",
"(",
"slice",
"(",
"0",
",",
"1",
")",
")",
"subshape",
".",
"append",
"(",
"1",
")",
"series",
"[",
"tuple",
"(",
"slices",
")",
"]",
"=",
"self",
".",
"to_array",
"(",
")",
".",
"reshape",
"(",
"subshape",
")",
"series",
"[",
"13",
":",
"]",
"=",
"array",
"return",
"series"
] |
Prefix the information of the actual Timegrid object to the given
array and return it.
The Timegrid information is stored in the first thirteen values of
the first axis of the returned series. Initialize a Timegrid object
and apply its `array2series` method on a simple list containing
numbers:
>>> from hydpy import Timegrid
>>> timegrid = Timegrid('2000-11-01 00:00', '2000-11-01 04:00', '1h')
>>> series = timegrid.array2series([1, 2, 3.5, '5.0'])
The first six entries contain the first date of the timegrid (year,
month, day, hour, minute, second):
>>> from hydpy import round_
>>> round_(series[:6])
2000.0, 11.0, 1.0, 0.0, 0.0, 0.0
The six subsequent entries contain the last date:
>>> round_(series[6:12])
2000.0, 11.0, 1.0, 4.0, 0.0, 0.0
The thirteens value is the step size in seconds:
>>> round_(series[12])
3600.0
The last four value are the ones of the given vector:
>>> round_(series[-4:])
1.0, 2.0, 3.5, 5.0
The given array can have an arbitrary number of dimensions:
>>> import numpy
>>> array = numpy.eye(4)
>>> series = timegrid.array2series(array)
Now the timegrid information is stored in the first column:
>>> round_(series[:13, 0])
2000.0, 11.0, 1.0, 0.0, 0.0, 0.0, 2000.0, 11.0, 1.0, 4.0, 0.0, 0.0, \
3600.0
All other columns of the first thirteen rows contain nan values, e.g.:
>>> round_(series[12, :])
3600.0, nan, nan, nan
The original values are stored in the last four rows, e.g.:
>>> round_(series[13, :])
1.0, 0.0, 0.0, 0.0
Inappropriate array objects result in error messages like:
>>> timegrid.array2series([[1, 2], [3]])
Traceback (most recent call last):
...
ValueError: While trying to prefix timegrid information to the given \
array, the following error occurred: setting an array element with a sequence.
If the given array does not fit to the defined timegrid, a special
error message is returned:
>>> timegrid.array2series([[1, 2], [3, 4]])
Traceback (most recent call last):
...
ValueError: When converting an array to a sequence, the lengths of \
the timegrid and the given array must be equal, but the length of the \
timegrid object is `4` and the length of the array object is `2`.
|
[
"Prefix",
"the",
"information",
"of",
"the",
"actual",
"Timegrid",
"object",
"to",
"the",
"given",
"array",
"and",
"return",
"it",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L1399-L1496
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Timegrid.verify
|
def verify(self):
"""Raise an |ValueError| if the dates or the step size of the time
frame are inconsistent.
"""
if self.firstdate >= self.lastdate:
raise ValueError(
f'Unplausible timegrid. The first given date '
f'{self.firstdate}, the second given date is {self.lastdate}.')
if (self.lastdate-self.firstdate) % self.stepsize:
raise ValueError(
f'Unplausible timegrid. The period span between the given '
f'dates {self.firstdate} and {self.lastdate} is not '
f'a multiple of the given step size {self.stepsize}.')
|
python
|
def verify(self):
"""Raise an |ValueError| if the dates or the step size of the time
frame are inconsistent.
"""
if self.firstdate >= self.lastdate:
raise ValueError(
f'Unplausible timegrid. The first given date '
f'{self.firstdate}, the second given date is {self.lastdate}.')
if (self.lastdate-self.firstdate) % self.stepsize:
raise ValueError(
f'Unplausible timegrid. The period span between the given '
f'dates {self.firstdate} and {self.lastdate} is not '
f'a multiple of the given step size {self.stepsize}.')
|
[
"def",
"verify",
"(",
"self",
")",
":",
"if",
"self",
".",
"firstdate",
">=",
"self",
".",
"lastdate",
":",
"raise",
"ValueError",
"(",
"f'Unplausible timegrid. The first given date '",
"f'{self.firstdate}, the second given date is {self.lastdate}.'",
")",
"if",
"(",
"self",
".",
"lastdate",
"-",
"self",
".",
"firstdate",
")",
"%",
"self",
".",
"stepsize",
":",
"raise",
"ValueError",
"(",
"f'Unplausible timegrid. The period span between the given '",
"f'dates {self.firstdate} and {self.lastdate} is not '",
"f'a multiple of the given step size {self.stepsize}.'",
")"
] |
Raise an |ValueError| if the dates or the step size of the time
frame are inconsistent.
|
[
"Raise",
"an",
"|ValueError|",
"if",
"the",
"dates",
"or",
"the",
"step",
"size",
"of",
"the",
"time",
"frame",
"are",
"inconsistent",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L1498-L1510
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Timegrid.assignrepr
|
def assignrepr(self, prefix, style=None, utcoffset=None):
"""Return a |repr| string with an prefixed assignement.
Without option arguments given, printing the returned string
looks like:
>>> from hydpy import Timegrid
>>> timegrid = Timegrid('1996-11-01 00:00:00',
... '1997-11-01 00:00:00',
... '1d')
>>> print(timegrid.assignrepr(prefix='timegrid = '))
timegrid = Timegrid('1996-11-01 00:00:00',
'1997-11-01 00:00:00',
'1d')
The optional arguments are passed to method |Date.to_repr|
without any modifications:
>>> print(timegrid.assignrepr(
... prefix='', style='iso1', utcoffset=120))
Timegrid('1996-11-01T01:00:00+02:00',
'1997-11-01T01:00:00+02:00',
'1d')
"""
skip = len(prefix) + 9
blanks = ' ' * skip
return (f"{prefix}Timegrid('"
f"{self.firstdate.to_string(style, utcoffset)}',\n"
f"{blanks}'{self.lastdate.to_string(style, utcoffset)}',\n"
f"{blanks}'{str(self.stepsize)}')")
|
python
|
def assignrepr(self, prefix, style=None, utcoffset=None):
"""Return a |repr| string with an prefixed assignement.
Without option arguments given, printing the returned string
looks like:
>>> from hydpy import Timegrid
>>> timegrid = Timegrid('1996-11-01 00:00:00',
... '1997-11-01 00:00:00',
... '1d')
>>> print(timegrid.assignrepr(prefix='timegrid = '))
timegrid = Timegrid('1996-11-01 00:00:00',
'1997-11-01 00:00:00',
'1d')
The optional arguments are passed to method |Date.to_repr|
without any modifications:
>>> print(timegrid.assignrepr(
... prefix='', style='iso1', utcoffset=120))
Timegrid('1996-11-01T01:00:00+02:00',
'1997-11-01T01:00:00+02:00',
'1d')
"""
skip = len(prefix) + 9
blanks = ' ' * skip
return (f"{prefix}Timegrid('"
f"{self.firstdate.to_string(style, utcoffset)}',\n"
f"{blanks}'{self.lastdate.to_string(style, utcoffset)}',\n"
f"{blanks}'{str(self.stepsize)}')")
|
[
"def",
"assignrepr",
"(",
"self",
",",
"prefix",
",",
"style",
"=",
"None",
",",
"utcoffset",
"=",
"None",
")",
":",
"skip",
"=",
"len",
"(",
"prefix",
")",
"+",
"9",
"blanks",
"=",
"' '",
"*",
"skip",
"return",
"(",
"f\"{prefix}Timegrid('\"",
"f\"{self.firstdate.to_string(style, utcoffset)}',\\n\"",
"f\"{blanks}'{self.lastdate.to_string(style, utcoffset)}',\\n\"",
"f\"{blanks}'{str(self.stepsize)}')\"",
")"
] |
Return a |repr| string with an prefixed assignement.
Without option arguments given, printing the returned string
looks like:
>>> from hydpy import Timegrid
>>> timegrid = Timegrid('1996-11-01 00:00:00',
... '1997-11-01 00:00:00',
... '1d')
>>> print(timegrid.assignrepr(prefix='timegrid = '))
timegrid = Timegrid('1996-11-01 00:00:00',
'1997-11-01 00:00:00',
'1d')
The optional arguments are passed to method |Date.to_repr|
without any modifications:
>>> print(timegrid.assignrepr(
... prefix='', style='iso1', utcoffset=120))
Timegrid('1996-11-01T01:00:00+02:00',
'1997-11-01T01:00:00+02:00',
'1d')
|
[
"Return",
"a",
"|repr|",
"string",
"with",
"an",
"prefixed",
"assignement",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L1562-L1591
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Timegrids.verify
|
def verify(self):
"""Raise an |ValueError| it the different time grids are
inconsistent."""
self.init.verify()
self.sim.verify()
if self.init.firstdate > self.sim.firstdate:
raise ValueError(
f'The first date of the initialisation period '
f'({self.init.firstdate}) must not be later '
f'than the first date of the simulation period '
f'({self.sim.firstdate}).')
elif self.init.lastdate < self.sim.lastdate:
raise ValueError(
f'The last date of the initialisation period '
f'({self.init.lastdate}) must not be earlier '
f'than the last date of the simulation period '
f'({self.sim.lastdate}).')
elif self.init.stepsize != self.sim.stepsize:
raise ValueError(
f'The initialization stepsize ({self.init.stepsize}) '
f'must be identical with the simulation stepsize '
f'({self.sim.stepsize}).')
else:
try:
self.init[self.sim.firstdate]
except ValueError:
raise ValueError(
'The simulation time grid is not properly '
'alligned on the initialization time grid.')
|
python
|
def verify(self):
"""Raise an |ValueError| it the different time grids are
inconsistent."""
self.init.verify()
self.sim.verify()
if self.init.firstdate > self.sim.firstdate:
raise ValueError(
f'The first date of the initialisation period '
f'({self.init.firstdate}) must not be later '
f'than the first date of the simulation period '
f'({self.sim.firstdate}).')
elif self.init.lastdate < self.sim.lastdate:
raise ValueError(
f'The last date of the initialisation period '
f'({self.init.lastdate}) must not be earlier '
f'than the last date of the simulation period '
f'({self.sim.lastdate}).')
elif self.init.stepsize != self.sim.stepsize:
raise ValueError(
f'The initialization stepsize ({self.init.stepsize}) '
f'must be identical with the simulation stepsize '
f'({self.sim.stepsize}).')
else:
try:
self.init[self.sim.firstdate]
except ValueError:
raise ValueError(
'The simulation time grid is not properly '
'alligned on the initialization time grid.')
|
[
"def",
"verify",
"(",
"self",
")",
":",
"self",
".",
"init",
".",
"verify",
"(",
")",
"self",
".",
"sim",
".",
"verify",
"(",
")",
"if",
"self",
".",
"init",
".",
"firstdate",
">",
"self",
".",
"sim",
".",
"firstdate",
":",
"raise",
"ValueError",
"(",
"f'The first date of the initialisation period '",
"f'({self.init.firstdate}) must not be later '",
"f'than the first date of the simulation period '",
"f'({self.sim.firstdate}).'",
")",
"elif",
"self",
".",
"init",
".",
"lastdate",
"<",
"self",
".",
"sim",
".",
"lastdate",
":",
"raise",
"ValueError",
"(",
"f'The last date of the initialisation period '",
"f'({self.init.lastdate}) must not be earlier '",
"f'than the last date of the simulation period '",
"f'({self.sim.lastdate}).'",
")",
"elif",
"self",
".",
"init",
".",
"stepsize",
"!=",
"self",
".",
"sim",
".",
"stepsize",
":",
"raise",
"ValueError",
"(",
"f'The initialization stepsize ({self.init.stepsize}) '",
"f'must be identical with the simulation stepsize '",
"f'({self.sim.stepsize}).'",
")",
"else",
":",
"try",
":",
"self",
".",
"init",
"[",
"self",
".",
"sim",
".",
"firstdate",
"]",
"except",
"ValueError",
":",
"raise",
"ValueError",
"(",
"'The simulation time grid is not properly '",
"'alligned on the initialization time grid.'",
")"
] |
Raise an |ValueError| it the different time grids are
inconsistent.
|
[
"Raise",
"an",
"|ValueError|",
"it",
"the",
"different",
"time",
"grids",
"are",
"inconsistent",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L1786-L1814
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
Timegrids.assignrepr
|
def assignrepr(self, prefix):
"""Return a |repr| string with a prefixed assignment."""
caller = 'Timegrids('
blanks = ' ' * (len(prefix) + len(caller))
prefix = f'{prefix}{caller}'
lines = [f'{self.init.assignrepr(prefix)},']
if self.sim != self.init:
lines.append(f'{self.sim.assignrepr(blanks)},')
lines[-1] = lines[-1][:-1] + ')'
return '\n'.join(lines)
|
python
|
def assignrepr(self, prefix):
"""Return a |repr| string with a prefixed assignment."""
caller = 'Timegrids('
blanks = ' ' * (len(prefix) + len(caller))
prefix = f'{prefix}{caller}'
lines = [f'{self.init.assignrepr(prefix)},']
if self.sim != self.init:
lines.append(f'{self.sim.assignrepr(blanks)},')
lines[-1] = lines[-1][:-1] + ')'
return '\n'.join(lines)
|
[
"def",
"assignrepr",
"(",
"self",
",",
"prefix",
")",
":",
"caller",
"=",
"'Timegrids('",
"blanks",
"=",
"' '",
"*",
"(",
"len",
"(",
"prefix",
")",
"+",
"len",
"(",
"caller",
")",
")",
"prefix",
"=",
"f'{prefix}{caller}'",
"lines",
"=",
"[",
"f'{self.init.assignrepr(prefix)},'",
"]",
"if",
"self",
".",
"sim",
"!=",
"self",
".",
"init",
":",
"lines",
".",
"append",
"(",
"f'{self.sim.assignrepr(blanks)},'",
")",
"lines",
"[",
"-",
"1",
"]",
"=",
"lines",
"[",
"-",
"1",
"]",
"[",
":",
"-",
"1",
"]",
"+",
"')'",
"return",
"'\\n'",
".",
"join",
"(",
"lines",
")"
] |
Return a |repr| string with a prefixed assignment.
|
[
"Return",
"a",
"|repr|",
"string",
"with",
"a",
"prefixed",
"assignment",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L1847-L1856
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
TOY.seconds_passed
|
def seconds_passed(self):
"""Amount of time passed in seconds since the beginning of the year.
In the first example, the year is only one minute and thirty seconds
old:
>>> from hydpy.core.timetools import TOY
>>> TOY('1_1_0_1_30').seconds_passed
90
The second example shows that the 29th February is generally included:
>>> TOY('3').seconds_passed
5184000
"""
return int((Date(self).datetime -
self._STARTDATE.datetime).total_seconds())
|
python
|
def seconds_passed(self):
"""Amount of time passed in seconds since the beginning of the year.
In the first example, the year is only one minute and thirty seconds
old:
>>> from hydpy.core.timetools import TOY
>>> TOY('1_1_0_1_30').seconds_passed
90
The second example shows that the 29th February is generally included:
>>> TOY('3').seconds_passed
5184000
"""
return int((Date(self).datetime -
self._STARTDATE.datetime).total_seconds())
|
[
"def",
"seconds_passed",
"(",
"self",
")",
":",
"return",
"int",
"(",
"(",
"Date",
"(",
"self",
")",
".",
"datetime",
"-",
"self",
".",
"_STARTDATE",
".",
"datetime",
")",
".",
"total_seconds",
"(",
")",
")"
] |
Amount of time passed in seconds since the beginning of the year.
In the first example, the year is only one minute and thirty seconds
old:
>>> from hydpy.core.timetools import TOY
>>> TOY('1_1_0_1_30').seconds_passed
90
The second example shows that the 29th February is generally included:
>>> TOY('3').seconds_passed
5184000
|
[
"Amount",
"of",
"time",
"passed",
"in",
"seconds",
"since",
"the",
"beginning",
"of",
"the",
"year",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L2080-L2096
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
TOY.seconds_left
|
def seconds_left(self):
"""Remaining part of the year in seconds.
In the first example, only one minute and thirty seconds of the year
remain:
>>> from hydpy.core.timetools import TOY
>>> TOY('12_31_23_58_30').seconds_left
90
The second example shows that the 29th February is generally included:
>>> TOY('2').seconds_left
28944000
"""
return int((self._ENDDATE.datetime -
Date(self).datetime).total_seconds())
|
python
|
def seconds_left(self):
"""Remaining part of the year in seconds.
In the first example, only one minute and thirty seconds of the year
remain:
>>> from hydpy.core.timetools import TOY
>>> TOY('12_31_23_58_30').seconds_left
90
The second example shows that the 29th February is generally included:
>>> TOY('2').seconds_left
28944000
"""
return int((self._ENDDATE.datetime -
Date(self).datetime).total_seconds())
|
[
"def",
"seconds_left",
"(",
"self",
")",
":",
"return",
"int",
"(",
"(",
"self",
".",
"_ENDDATE",
".",
"datetime",
"-",
"Date",
"(",
"self",
")",
".",
"datetime",
")",
".",
"total_seconds",
"(",
")",
")"
] |
Remaining part of the year in seconds.
In the first example, only one minute and thirty seconds of the year
remain:
>>> from hydpy.core.timetools import TOY
>>> TOY('12_31_23_58_30').seconds_left
90
The second example shows that the 29th February is generally included:
>>> TOY('2').seconds_left
28944000
|
[
"Remaining",
"part",
"of",
"the",
"year",
"in",
"seconds",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L2099-L2115
|
hydpy-dev/hydpy
|
hydpy/core/timetools.py
|
TOY.centred_timegrid
|
def centred_timegrid(cls, simulationstep):
"""Return a |Timegrid| object defining the central time points
of the year 2000 for the given simulation step.
>>> from hydpy.core.timetools import TOY
>>> TOY.centred_timegrid('1d')
Timegrid('2000-01-01 12:00:00',
'2001-01-01 12:00:00',
'1d')
"""
simulationstep = Period(simulationstep)
return Timegrid(
cls._STARTDATE+simulationstep/2,
cls._ENDDATE+simulationstep/2,
simulationstep)
|
python
|
def centred_timegrid(cls, simulationstep):
"""Return a |Timegrid| object defining the central time points
of the year 2000 for the given simulation step.
>>> from hydpy.core.timetools import TOY
>>> TOY.centred_timegrid('1d')
Timegrid('2000-01-01 12:00:00',
'2001-01-01 12:00:00',
'1d')
"""
simulationstep = Period(simulationstep)
return Timegrid(
cls._STARTDATE+simulationstep/2,
cls._ENDDATE+simulationstep/2,
simulationstep)
|
[
"def",
"centred_timegrid",
"(",
"cls",
",",
"simulationstep",
")",
":",
"simulationstep",
"=",
"Period",
"(",
"simulationstep",
")",
"return",
"Timegrid",
"(",
"cls",
".",
"_STARTDATE",
"+",
"simulationstep",
"/",
"2",
",",
"cls",
".",
"_ENDDATE",
"+",
"simulationstep",
"/",
"2",
",",
"simulationstep",
")"
] |
Return a |Timegrid| object defining the central time points
of the year 2000 for the given simulation step.
>>> from hydpy.core.timetools import TOY
>>> TOY.centred_timegrid('1d')
Timegrid('2000-01-01 12:00:00',
'2001-01-01 12:00:00',
'1d')
|
[
"Return",
"a",
"|Timegrid|",
"object",
"defining",
"the",
"central",
"time",
"points",
"of",
"the",
"year",
"2000",
"for",
"the",
"given",
"simulation",
"step",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/timetools.py#L2118-L2132
|
hydpy-dev/hydpy
|
hydpy/core/objecttools.py
|
dir_
|
def dir_(self):
"""The prefered way for HydPy objects to respond to |dir|.
Note the depencence on the `pub.options.dirverbose`. If this option is
set `True`, all attributes and methods of the given instance and its
class (including those inherited from the parent classes) are returned:
>>> from hydpy import pub
>>> pub.options.dirverbose = True
>>> from hydpy.core.objecttools import dir_
>>> class Test(object):
... only_public_attribute = None
>>> print(len(dir_(Test())) > 1) # Long list, try it yourself...
True
If the option is set to `False`, only the `public` attributes and methods
(which do need begin with `_`) are returned:
>>> pub.options.dirverbose = False
>>> print(dir_(Test())) # Short list with one single entry...
['only_public_attribute']
If none of those does exists, |dir_| returns a list with a single string
containing a single empty space (which seems to work better for most
IDEs than returning an emtpy list):
>>> del Test.only_public_attribute
>>> print(dir_(Test()))
[' ']
"""
names = set()
for thing in list(inspect.getmro(type(self))) + [self]:
for key in vars(thing).keys():
if hydpy.pub.options.dirverbose or not key.startswith('_'):
names.add(key)
if names:
names = list(names)
else:
names = [' ']
return names
|
python
|
def dir_(self):
"""The prefered way for HydPy objects to respond to |dir|.
Note the depencence on the `pub.options.dirverbose`. If this option is
set `True`, all attributes and methods of the given instance and its
class (including those inherited from the parent classes) are returned:
>>> from hydpy import pub
>>> pub.options.dirverbose = True
>>> from hydpy.core.objecttools import dir_
>>> class Test(object):
... only_public_attribute = None
>>> print(len(dir_(Test())) > 1) # Long list, try it yourself...
True
If the option is set to `False`, only the `public` attributes and methods
(which do need begin with `_`) are returned:
>>> pub.options.dirverbose = False
>>> print(dir_(Test())) # Short list with one single entry...
['only_public_attribute']
If none of those does exists, |dir_| returns a list with a single string
containing a single empty space (which seems to work better for most
IDEs than returning an emtpy list):
>>> del Test.only_public_attribute
>>> print(dir_(Test()))
[' ']
"""
names = set()
for thing in list(inspect.getmro(type(self))) + [self]:
for key in vars(thing).keys():
if hydpy.pub.options.dirverbose or not key.startswith('_'):
names.add(key)
if names:
names = list(names)
else:
names = [' ']
return names
|
[
"def",
"dir_",
"(",
"self",
")",
":",
"names",
"=",
"set",
"(",
")",
"for",
"thing",
"in",
"list",
"(",
"inspect",
".",
"getmro",
"(",
"type",
"(",
"self",
")",
")",
")",
"+",
"[",
"self",
"]",
":",
"for",
"key",
"in",
"vars",
"(",
"thing",
")",
".",
"keys",
"(",
")",
":",
"if",
"hydpy",
".",
"pub",
".",
"options",
".",
"dirverbose",
"or",
"not",
"key",
".",
"startswith",
"(",
"'_'",
")",
":",
"names",
".",
"add",
"(",
"key",
")",
"if",
"names",
":",
"names",
"=",
"list",
"(",
"names",
")",
"else",
":",
"names",
"=",
"[",
"' '",
"]",
"return",
"names"
] |
The prefered way for HydPy objects to respond to |dir|.
Note the depencence on the `pub.options.dirverbose`. If this option is
set `True`, all attributes and methods of the given instance and its
class (including those inherited from the parent classes) are returned:
>>> from hydpy import pub
>>> pub.options.dirverbose = True
>>> from hydpy.core.objecttools import dir_
>>> class Test(object):
... only_public_attribute = None
>>> print(len(dir_(Test())) > 1) # Long list, try it yourself...
True
If the option is set to `False`, only the `public` attributes and methods
(which do need begin with `_`) are returned:
>>> pub.options.dirverbose = False
>>> print(dir_(Test())) # Short list with one single entry...
['only_public_attribute']
If none of those does exists, |dir_| returns a list with a single string
containing a single empty space (which seems to work better for most
IDEs than returning an emtpy list):
>>> del Test.only_public_attribute
>>> print(dir_(Test()))
[' ']
|
[
"The",
"prefered",
"way",
"for",
"HydPy",
"objects",
"to",
"respond",
"to",
"|dir|",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/objecttools.py#L20-L59
|
hydpy-dev/hydpy
|
hydpy/core/objecttools.py
|
classname
|
def classname(self):
"""Return the class name of the given instance object or class.
>>> from hydpy.core.objecttools import classname
>>> from hydpy import pub
>>> print(classname(float))
float
>>> print(classname(pub.options))
Options
"""
if inspect.isclass(self):
string = str(self)
else:
string = str(type(self))
try:
string = string.split("'")[1]
except IndexError:
pass
return string.split('.')[-1]
|
python
|
def classname(self):
"""Return the class name of the given instance object or class.
>>> from hydpy.core.objecttools import classname
>>> from hydpy import pub
>>> print(classname(float))
float
>>> print(classname(pub.options))
Options
"""
if inspect.isclass(self):
string = str(self)
else:
string = str(type(self))
try:
string = string.split("'")[1]
except IndexError:
pass
return string.split('.')[-1]
|
[
"def",
"classname",
"(",
"self",
")",
":",
"if",
"inspect",
".",
"isclass",
"(",
"self",
")",
":",
"string",
"=",
"str",
"(",
"self",
")",
"else",
":",
"string",
"=",
"str",
"(",
"type",
"(",
"self",
")",
")",
"try",
":",
"string",
"=",
"string",
".",
"split",
"(",
"\"'\"",
")",
"[",
"1",
"]",
"except",
"IndexError",
":",
"pass",
"return",
"string",
".",
"split",
"(",
"'.'",
")",
"[",
"-",
"1",
"]"
] |
Return the class name of the given instance object or class.
>>> from hydpy.core.objecttools import classname
>>> from hydpy import pub
>>> print(classname(float))
float
>>> print(classname(pub.options))
Options
|
[
"Return",
"the",
"class",
"name",
"of",
"the",
"given",
"instance",
"object",
"or",
"class",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/objecttools.py#L62-L80
|
hydpy-dev/hydpy
|
hydpy/core/objecttools.py
|
name
|
def name(self):
"""Name of the class of the given instance in lower case letters.
This function is thought to be implemented as a property. Otherwise
it would violate the principle not to access or manipulate private
attributes ("_name"):
>>> from hydpy.core.objecttools import name
>>> class Test(object):
... name = property(name)
>>> test1 = Test()
>>> test1.name
'test'
>>> test1._name
'test'
The private attribute is added for performance reasons only. Note that
it is a class attribute:
>>> test2 = Test()
>>> test2._name
'test'
"""
cls = type(self)
try:
return cls.__dict__['_name']
except KeyError:
setattr(cls, '_name', instancename(self))
return cls.__dict__['_name']
|
python
|
def name(self):
"""Name of the class of the given instance in lower case letters.
This function is thought to be implemented as a property. Otherwise
it would violate the principle not to access or manipulate private
attributes ("_name"):
>>> from hydpy.core.objecttools import name
>>> class Test(object):
... name = property(name)
>>> test1 = Test()
>>> test1.name
'test'
>>> test1._name
'test'
The private attribute is added for performance reasons only. Note that
it is a class attribute:
>>> test2 = Test()
>>> test2._name
'test'
"""
cls = type(self)
try:
return cls.__dict__['_name']
except KeyError:
setattr(cls, '_name', instancename(self))
return cls.__dict__['_name']
|
[
"def",
"name",
"(",
"self",
")",
":",
"cls",
"=",
"type",
"(",
"self",
")",
"try",
":",
"return",
"cls",
".",
"__dict__",
"[",
"'_name'",
"]",
"except",
"KeyError",
":",
"setattr",
"(",
"cls",
",",
"'_name'",
",",
"instancename",
"(",
"self",
")",
")",
"return",
"cls",
".",
"__dict__",
"[",
"'_name'",
"]"
] |
Name of the class of the given instance in lower case letters.
This function is thought to be implemented as a property. Otherwise
it would violate the principle not to access or manipulate private
attributes ("_name"):
>>> from hydpy.core.objecttools import name
>>> class Test(object):
... name = property(name)
>>> test1 = Test()
>>> test1.name
'test'
>>> test1._name
'test'
The private attribute is added for performance reasons only. Note that
it is a class attribute:
>>> test2 = Test()
>>> test2._name
'test'
|
[
"Name",
"of",
"the",
"class",
"of",
"the",
"given",
"instance",
"in",
"lower",
"case",
"letters",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/objecttools.py#L109-L137
|
hydpy-dev/hydpy
|
hydpy/core/objecttools.py
|
valid_variable_identifier
|
def valid_variable_identifier(string):
"""Raises an |ValueError| if the given name is not a valid Python
identifier.
For example, the string `test_1` (with underscore) is valid...
>>> from hydpy.core.objecttools import valid_variable_identifier
>>> valid_variable_identifier('test_1')
...but the string `test 1` (with white space) is not:
>>> valid_variable_identifier('test 1')
Traceback (most recent call last):
...
ValueError: The given name string `test 1` does not define a valid \
variable identifier. Valid identifiers do not contain characters like \
`-` or empty spaces, do not start with numbers, cannot be mistaken with \
Python built-ins like `for`...)
Also, names of Python built ins are not allowed:
>>> valid_variable_identifier('print') # doctest: +ELLIPSIS
Traceback (most recent call last):
...
ValueError: The given name string `print` does not define...
"""
string = str(string)
try:
exec('%s = None' % string)
if string in dir(builtins):
raise SyntaxError()
except SyntaxError:
raise ValueError(
'The given name string `%s` does not define a valid variable '
'identifier. Valid identifiers do not contain characters like '
'`-` or empty spaces, do not start with numbers, cannot be '
'mistaken with Python built-ins like `for`...)'
% string)
|
python
|
def valid_variable_identifier(string):
"""Raises an |ValueError| if the given name is not a valid Python
identifier.
For example, the string `test_1` (with underscore) is valid...
>>> from hydpy.core.objecttools import valid_variable_identifier
>>> valid_variable_identifier('test_1')
...but the string `test 1` (with white space) is not:
>>> valid_variable_identifier('test 1')
Traceback (most recent call last):
...
ValueError: The given name string `test 1` does not define a valid \
variable identifier. Valid identifiers do not contain characters like \
`-` or empty spaces, do not start with numbers, cannot be mistaken with \
Python built-ins like `for`...)
Also, names of Python built ins are not allowed:
>>> valid_variable_identifier('print') # doctest: +ELLIPSIS
Traceback (most recent call last):
...
ValueError: The given name string `print` does not define...
"""
string = str(string)
try:
exec('%s = None' % string)
if string in dir(builtins):
raise SyntaxError()
except SyntaxError:
raise ValueError(
'The given name string `%s` does not define a valid variable '
'identifier. Valid identifiers do not contain characters like '
'`-` or empty spaces, do not start with numbers, cannot be '
'mistaken with Python built-ins like `for`...)'
% string)
|
[
"def",
"valid_variable_identifier",
"(",
"string",
")",
":",
"string",
"=",
"str",
"(",
"string",
")",
"try",
":",
"exec",
"(",
"'%s = None'",
"%",
"string",
")",
"if",
"string",
"in",
"dir",
"(",
"builtins",
")",
":",
"raise",
"SyntaxError",
"(",
")",
"except",
"SyntaxError",
":",
"raise",
"ValueError",
"(",
"'The given name string `%s` does not define a valid variable '",
"'identifier. Valid identifiers do not contain characters like '",
"'`-` or empty spaces, do not start with numbers, cannot be '",
"'mistaken with Python built-ins like `for`...)'",
"%",
"string",
")"
] |
Raises an |ValueError| if the given name is not a valid Python
identifier.
For example, the string `test_1` (with underscore) is valid...
>>> from hydpy.core.objecttools import valid_variable_identifier
>>> valid_variable_identifier('test_1')
...but the string `test 1` (with white space) is not:
>>> valid_variable_identifier('test 1')
Traceback (most recent call last):
...
ValueError: The given name string `test 1` does not define a valid \
variable identifier. Valid identifiers do not contain characters like \
`-` or empty spaces, do not start with numbers, cannot be mistaken with \
Python built-ins like `for`...)
Also, names of Python built ins are not allowed:
>>> valid_variable_identifier('print') # doctest: +ELLIPSIS
Traceback (most recent call last):
...
ValueError: The given name string `print` does not define...
|
[
"Raises",
"an",
"|ValueError|",
"if",
"the",
"given",
"name",
"is",
"not",
"a",
"valid",
"Python",
"identifier",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/objecttools.py#L272-L309
|
hydpy-dev/hydpy
|
hydpy/core/objecttools.py
|
augment_excmessage
|
def augment_excmessage(prefix=None, suffix=None) -> NoReturn:
"""Augment an exception message with additional information while keeping
the original traceback.
You can prefix and/or suffix text. If you prefix something (which happens
much more often in the HydPy framework), the sub-clause ', the following
error occurred:' is automatically included:
>>> from hydpy.core import objecttools
>>> import textwrap
>>> try:
... 1 + '1'
... except BaseException:
... prefix = 'While showing how prefixing works'
... suffix = '(This is a final remark.)'
... objecttools.augment_excmessage(prefix, suffix)
Traceback (most recent call last):
...
TypeError: While showing how prefixing works, the following error \
occurred: unsupported operand type(s) for +: 'int' and 'str' \
(This is a final remark.)
Some exceptions derived by site-packages do not support exception
chaining due to requiring multiple initialisation arguments.
In such cases, |augment_excmessage| generates an exception with the
same name on the fly and raises it afterwards, which is pointed out
by the exception name mentioning to the "objecttools" module:
>>> class WrongError(BaseException):
... def __init__(self, arg1, arg2):
... pass
>>> try:
... raise WrongError('info 1', 'info 2')
... except BaseException:
... objecttools.augment_excmessage(
... 'While showing how prefixing works')
Traceback (most recent call last):
...
hydpy.core.objecttools.hydpy.core.objecttools.WrongError: While showing \
how prefixing works, the following error occurred: ('info 1', 'info 2')
"""
exc_old = sys.exc_info()[1]
message = str(exc_old)
if prefix is not None:
message = f'{prefix}, the following error occurred: {message}'
if suffix is not None:
message = f'{message} {suffix}'
try:
exc_new = type(exc_old)(message)
except BaseException:
exc_name = str(type(exc_old)).split("'")[1]
exc_type = type(exc_name, (BaseException,), {})
exc_type.__module = exc_old.__module__
raise exc_type(message) from exc_old
raise exc_new from exc_old
|
python
|
def augment_excmessage(prefix=None, suffix=None) -> NoReturn:
"""Augment an exception message with additional information while keeping
the original traceback.
You can prefix and/or suffix text. If you prefix something (which happens
much more often in the HydPy framework), the sub-clause ', the following
error occurred:' is automatically included:
>>> from hydpy.core import objecttools
>>> import textwrap
>>> try:
... 1 + '1'
... except BaseException:
... prefix = 'While showing how prefixing works'
... suffix = '(This is a final remark.)'
... objecttools.augment_excmessage(prefix, suffix)
Traceback (most recent call last):
...
TypeError: While showing how prefixing works, the following error \
occurred: unsupported operand type(s) for +: 'int' and 'str' \
(This is a final remark.)
Some exceptions derived by site-packages do not support exception
chaining due to requiring multiple initialisation arguments.
In such cases, |augment_excmessage| generates an exception with the
same name on the fly and raises it afterwards, which is pointed out
by the exception name mentioning to the "objecttools" module:
>>> class WrongError(BaseException):
... def __init__(self, arg1, arg2):
... pass
>>> try:
... raise WrongError('info 1', 'info 2')
... except BaseException:
... objecttools.augment_excmessage(
... 'While showing how prefixing works')
Traceback (most recent call last):
...
hydpy.core.objecttools.hydpy.core.objecttools.WrongError: While showing \
how prefixing works, the following error occurred: ('info 1', 'info 2')
"""
exc_old = sys.exc_info()[1]
message = str(exc_old)
if prefix is not None:
message = f'{prefix}, the following error occurred: {message}'
if suffix is not None:
message = f'{message} {suffix}'
try:
exc_new = type(exc_old)(message)
except BaseException:
exc_name = str(type(exc_old)).split("'")[1]
exc_type = type(exc_name, (BaseException,), {})
exc_type.__module = exc_old.__module__
raise exc_type(message) from exc_old
raise exc_new from exc_old
|
[
"def",
"augment_excmessage",
"(",
"prefix",
"=",
"None",
",",
"suffix",
"=",
"None",
")",
"->",
"NoReturn",
":",
"exc_old",
"=",
"sys",
".",
"exc_info",
"(",
")",
"[",
"1",
"]",
"message",
"=",
"str",
"(",
"exc_old",
")",
"if",
"prefix",
"is",
"not",
"None",
":",
"message",
"=",
"f'{prefix}, the following error occurred: {message}'",
"if",
"suffix",
"is",
"not",
"None",
":",
"message",
"=",
"f'{message} {suffix}'",
"try",
":",
"exc_new",
"=",
"type",
"(",
"exc_old",
")",
"(",
"message",
")",
"except",
"BaseException",
":",
"exc_name",
"=",
"str",
"(",
"type",
"(",
"exc_old",
")",
")",
".",
"split",
"(",
"\"'\"",
")",
"[",
"1",
"]",
"exc_type",
"=",
"type",
"(",
"exc_name",
",",
"(",
"BaseException",
",",
")",
",",
"{",
"}",
")",
"exc_type",
".",
"__module",
"=",
"exc_old",
".",
"__module__",
"raise",
"exc_type",
"(",
"message",
")",
"from",
"exc_old",
"raise",
"exc_new",
"from",
"exc_old"
] |
Augment an exception message with additional information while keeping
the original traceback.
You can prefix and/or suffix text. If you prefix something (which happens
much more often in the HydPy framework), the sub-clause ', the following
error occurred:' is automatically included:
>>> from hydpy.core import objecttools
>>> import textwrap
>>> try:
... 1 + '1'
... except BaseException:
... prefix = 'While showing how prefixing works'
... suffix = '(This is a final remark.)'
... objecttools.augment_excmessage(prefix, suffix)
Traceback (most recent call last):
...
TypeError: While showing how prefixing works, the following error \
occurred: unsupported operand type(s) for +: 'int' and 'str' \
(This is a final remark.)
Some exceptions derived by site-packages do not support exception
chaining due to requiring multiple initialisation arguments.
In such cases, |augment_excmessage| generates an exception with the
same name on the fly and raises it afterwards, which is pointed out
by the exception name mentioning to the "objecttools" module:
>>> class WrongError(BaseException):
... def __init__(self, arg1, arg2):
... pass
>>> try:
... raise WrongError('info 1', 'info 2')
... except BaseException:
... objecttools.augment_excmessage(
... 'While showing how prefixing works')
Traceback (most recent call last):
...
hydpy.core.objecttools.hydpy.core.objecttools.WrongError: While showing \
how prefixing works, the following error occurred: ('info 1', 'info 2')
|
[
"Augment",
"an",
"exception",
"message",
"with",
"additional",
"information",
"while",
"keeping",
"the",
"original",
"traceback",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/objecttools.py#L312-L366
|
hydpy-dev/hydpy
|
hydpy/core/objecttools.py
|
excmessage_decorator
|
def excmessage_decorator(description) -> Callable:
"""Wrap a function with |augment_excmessage|.
Function |excmessage_decorator| is a means to apply function
|augment_excmessage| more efficiently. Suppose you would apply
function |augment_excmessage| in a function that adds and returns
to numbers:
>>> from hydpy.core import objecttools
>>> def add(x, y):
... try:
... return x + y
... except BaseException:
... objecttools.augment_excmessage(
... 'While trying to add `x` and `y`')
This works as excepted...
>>> add(1, 2)
3
>>> add(1, [])
Traceback (most recent call last):
...
TypeError: While trying to add `x` and `y`, the following error \
occurred: unsupported operand type(s) for +: 'int' and 'list'
...but can be achieved with much less code using |excmessage_decorator|:
>>> @objecttools.excmessage_decorator(
... 'add `x` and `y`')
... def add(x, y):
... return x+y
>>> add(1, 2)
3
>>> add(1, [])
Traceback (most recent call last):
...
TypeError: While trying to add `x` and `y`, the following error \
occurred: unsupported operand type(s) for +: 'int' and 'list'
Additionally, exception messages related to wrong function calls
are now also augmented:
>>> add(1)
Traceback (most recent call last):
...
TypeError: While trying to add `x` and `y`, the following error \
occurred: add() missing 1 required positional argument: 'y'
|excmessage_decorator| evaluates the given string like an f-string,
allowing to mention the argument values of the called function and
to make use of all string modification functions provided by modules
|objecttools|:
>>> @objecttools.excmessage_decorator(
... 'add `x` ({repr_(x, 2)}) and `y` ({repr_(y, 2)})')
... def add(x, y):
... return x+y
>>> add(1.1111, 'wrong')
Traceback (most recent call last):
...
TypeError: While trying to add `x` (1.11) and `y` (wrong), the following \
error occurred: unsupported operand type(s) for +: 'float' and 'str'
>>> add(1)
Traceback (most recent call last):
...
TypeError: While trying to add `x` (1) and `y` (?), the following error \
occurred: add() missing 1 required positional argument: 'y'
>>> add(y=1)
Traceback (most recent call last):
...
TypeError: While trying to add `x` (?) and `y` (1), the following error \
occurred: add() missing 1 required positional argument: 'x'
Apply |excmessage_decorator| on methods also works fine:
>>> class Adder:
... def __init__(self):
... self.value = 0
... @objecttools.excmessage_decorator(
... 'add an instance of class `{classname(self)}` with value '
... '`{repr_(other, 2)}` of type `{classname(other)}`')
... def __iadd__(self, other):
... self.value += other
... return self
>>> adder = Adder()
>>> adder += 1
>>> adder.value
1
>>> adder += 'wrong'
Traceback (most recent call last):
...
TypeError: While trying to add an instance of class `Adder` with value \
`wrong` of type `str`, the following error occurred: unsupported operand \
type(s) for +=: 'int' and 'str'
It is made sure that no information of the decorated function is lost:
>>> add.__name__
'add'
"""
@wrapt.decorator
def wrapper(wrapped, instance, args, kwargs):
"""Apply |augment_excmessage| when the wrapped function fails."""
# pylint: disable=unused-argument
try:
return wrapped(*args, **kwargs)
except BaseException:
info = kwargs.copy()
info['self'] = instance
argnames = inspect.getfullargspec(wrapped).args
if argnames[0] == 'self':
argnames = argnames[1:]
for argname, arg in zip(argnames, args):
info[argname] = arg
for argname in argnames:
if argname not in info:
info[argname] = '?'
message = eval(
f"f'While trying to {description}'", globals(), info)
augment_excmessage(message)
return wrapper
|
python
|
def excmessage_decorator(description) -> Callable:
"""Wrap a function with |augment_excmessage|.
Function |excmessage_decorator| is a means to apply function
|augment_excmessage| more efficiently. Suppose you would apply
function |augment_excmessage| in a function that adds and returns
to numbers:
>>> from hydpy.core import objecttools
>>> def add(x, y):
... try:
... return x + y
... except BaseException:
... objecttools.augment_excmessage(
... 'While trying to add `x` and `y`')
This works as excepted...
>>> add(1, 2)
3
>>> add(1, [])
Traceback (most recent call last):
...
TypeError: While trying to add `x` and `y`, the following error \
occurred: unsupported operand type(s) for +: 'int' and 'list'
...but can be achieved with much less code using |excmessage_decorator|:
>>> @objecttools.excmessage_decorator(
... 'add `x` and `y`')
... def add(x, y):
... return x+y
>>> add(1, 2)
3
>>> add(1, [])
Traceback (most recent call last):
...
TypeError: While trying to add `x` and `y`, the following error \
occurred: unsupported operand type(s) for +: 'int' and 'list'
Additionally, exception messages related to wrong function calls
are now also augmented:
>>> add(1)
Traceback (most recent call last):
...
TypeError: While trying to add `x` and `y`, the following error \
occurred: add() missing 1 required positional argument: 'y'
|excmessage_decorator| evaluates the given string like an f-string,
allowing to mention the argument values of the called function and
to make use of all string modification functions provided by modules
|objecttools|:
>>> @objecttools.excmessage_decorator(
... 'add `x` ({repr_(x, 2)}) and `y` ({repr_(y, 2)})')
... def add(x, y):
... return x+y
>>> add(1.1111, 'wrong')
Traceback (most recent call last):
...
TypeError: While trying to add `x` (1.11) and `y` (wrong), the following \
error occurred: unsupported operand type(s) for +: 'float' and 'str'
>>> add(1)
Traceback (most recent call last):
...
TypeError: While trying to add `x` (1) and `y` (?), the following error \
occurred: add() missing 1 required positional argument: 'y'
>>> add(y=1)
Traceback (most recent call last):
...
TypeError: While trying to add `x` (?) and `y` (1), the following error \
occurred: add() missing 1 required positional argument: 'x'
Apply |excmessage_decorator| on methods also works fine:
>>> class Adder:
... def __init__(self):
... self.value = 0
... @objecttools.excmessage_decorator(
... 'add an instance of class `{classname(self)}` with value '
... '`{repr_(other, 2)}` of type `{classname(other)}`')
... def __iadd__(self, other):
... self.value += other
... return self
>>> adder = Adder()
>>> adder += 1
>>> adder.value
1
>>> adder += 'wrong'
Traceback (most recent call last):
...
TypeError: While trying to add an instance of class `Adder` with value \
`wrong` of type `str`, the following error occurred: unsupported operand \
type(s) for +=: 'int' and 'str'
It is made sure that no information of the decorated function is lost:
>>> add.__name__
'add'
"""
@wrapt.decorator
def wrapper(wrapped, instance, args, kwargs):
"""Apply |augment_excmessage| when the wrapped function fails."""
# pylint: disable=unused-argument
try:
return wrapped(*args, **kwargs)
except BaseException:
info = kwargs.copy()
info['self'] = instance
argnames = inspect.getfullargspec(wrapped).args
if argnames[0] == 'self':
argnames = argnames[1:]
for argname, arg in zip(argnames, args):
info[argname] = arg
for argname in argnames:
if argname not in info:
info[argname] = '?'
message = eval(
f"f'While trying to {description}'", globals(), info)
augment_excmessage(message)
return wrapper
|
[
"def",
"excmessage_decorator",
"(",
"description",
")",
"->",
"Callable",
":",
"@",
"wrapt",
".",
"decorator",
"def",
"wrapper",
"(",
"wrapped",
",",
"instance",
",",
"args",
",",
"kwargs",
")",
":",
"\"\"\"Apply |augment_excmessage| when the wrapped function fails.\"\"\"",
"# pylint: disable=unused-argument",
"try",
":",
"return",
"wrapped",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"except",
"BaseException",
":",
"info",
"=",
"kwargs",
".",
"copy",
"(",
")",
"info",
"[",
"'self'",
"]",
"=",
"instance",
"argnames",
"=",
"inspect",
".",
"getfullargspec",
"(",
"wrapped",
")",
".",
"args",
"if",
"argnames",
"[",
"0",
"]",
"==",
"'self'",
":",
"argnames",
"=",
"argnames",
"[",
"1",
":",
"]",
"for",
"argname",
",",
"arg",
"in",
"zip",
"(",
"argnames",
",",
"args",
")",
":",
"info",
"[",
"argname",
"]",
"=",
"arg",
"for",
"argname",
"in",
"argnames",
":",
"if",
"argname",
"not",
"in",
"info",
":",
"info",
"[",
"argname",
"]",
"=",
"'?'",
"message",
"=",
"eval",
"(",
"f\"f'While trying to {description}'\"",
",",
"globals",
"(",
")",
",",
"info",
")",
"augment_excmessage",
"(",
"message",
")",
"return",
"wrapper"
] |
Wrap a function with |augment_excmessage|.
Function |excmessage_decorator| is a means to apply function
|augment_excmessage| more efficiently. Suppose you would apply
function |augment_excmessage| in a function that adds and returns
to numbers:
>>> from hydpy.core import objecttools
>>> def add(x, y):
... try:
... return x + y
... except BaseException:
... objecttools.augment_excmessage(
... 'While trying to add `x` and `y`')
This works as excepted...
>>> add(1, 2)
3
>>> add(1, [])
Traceback (most recent call last):
...
TypeError: While trying to add `x` and `y`, the following error \
occurred: unsupported operand type(s) for +: 'int' and 'list'
...but can be achieved with much less code using |excmessage_decorator|:
>>> @objecttools.excmessage_decorator(
... 'add `x` and `y`')
... def add(x, y):
... return x+y
>>> add(1, 2)
3
>>> add(1, [])
Traceback (most recent call last):
...
TypeError: While trying to add `x` and `y`, the following error \
occurred: unsupported operand type(s) for +: 'int' and 'list'
Additionally, exception messages related to wrong function calls
are now also augmented:
>>> add(1)
Traceback (most recent call last):
...
TypeError: While trying to add `x` and `y`, the following error \
occurred: add() missing 1 required positional argument: 'y'
|excmessage_decorator| evaluates the given string like an f-string,
allowing to mention the argument values of the called function and
to make use of all string modification functions provided by modules
|objecttools|:
>>> @objecttools.excmessage_decorator(
... 'add `x` ({repr_(x, 2)}) and `y` ({repr_(y, 2)})')
... def add(x, y):
... return x+y
>>> add(1.1111, 'wrong')
Traceback (most recent call last):
...
TypeError: While trying to add `x` (1.11) and `y` (wrong), the following \
error occurred: unsupported operand type(s) for +: 'float' and 'str'
>>> add(1)
Traceback (most recent call last):
...
TypeError: While trying to add `x` (1) and `y` (?), the following error \
occurred: add() missing 1 required positional argument: 'y'
>>> add(y=1)
Traceback (most recent call last):
...
TypeError: While trying to add `x` (?) and `y` (1), the following error \
occurred: add() missing 1 required positional argument: 'x'
Apply |excmessage_decorator| on methods also works fine:
>>> class Adder:
... def __init__(self):
... self.value = 0
... @objecttools.excmessage_decorator(
... 'add an instance of class `{classname(self)}` with value '
... '`{repr_(other, 2)}` of type `{classname(other)}`')
... def __iadd__(self, other):
... self.value += other
... return self
>>> adder = Adder()
>>> adder += 1
>>> adder.value
1
>>> adder += 'wrong'
Traceback (most recent call last):
...
TypeError: While trying to add an instance of class `Adder` with value \
`wrong` of type `str`, the following error occurred: unsupported operand \
type(s) for +=: 'int' and 'str'
It is made sure that no information of the decorated function is lost:
>>> add.__name__
'add'
|
[
"Wrap",
"a",
"function",
"with",
"|augment_excmessage|",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/objecttools.py#L369-L494
|
hydpy-dev/hydpy
|
hydpy/core/objecttools.py
|
print_values
|
def print_values(values, width=70):
"""Print the given values in multiple lines with a certain maximum width.
By default, each line contains at most 70 characters:
>>> from hydpy import print_values
>>> print_values(range(21))
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20
You can change this default behaviour by passing an alternative
number of characters:
>>> print_values(range(21), width=30)
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20
"""
for line in textwrap.wrap(repr_values(values), width=width):
print(line)
|
python
|
def print_values(values, width=70):
"""Print the given values in multiple lines with a certain maximum width.
By default, each line contains at most 70 characters:
>>> from hydpy import print_values
>>> print_values(range(21))
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20
You can change this default behaviour by passing an alternative
number of characters:
>>> print_values(range(21), width=30)
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20
"""
for line in textwrap.wrap(repr_values(values), width=width):
print(line)
|
[
"def",
"print_values",
"(",
"values",
",",
"width",
"=",
"70",
")",
":",
"for",
"line",
"in",
"textwrap",
".",
"wrap",
"(",
"repr_values",
"(",
"values",
")",
",",
"width",
"=",
"width",
")",
":",
"print",
"(",
"line",
")"
] |
Print the given values in multiple lines with a certain maximum width.
By default, each line contains at most 70 characters:
>>> from hydpy import print_values
>>> print_values(range(21))
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20
You can change this default behaviour by passing an alternative
number of characters:
>>> print_values(range(21), width=30)
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20
|
[
"Print",
"the",
"given",
"values",
"in",
"multiple",
"lines",
"with",
"a",
"certain",
"maximum",
"width",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/objecttools.py#L801-L820
|
hydpy-dev/hydpy
|
hydpy/core/objecttools.py
|
assignrepr_values
|
def assignrepr_values(values, prefix, width=None, _fakeend=0):
"""Return a prefixed, wrapped and properly aligned string representation
of the given values using function |repr|.
>>> from hydpy.core.objecttools import assignrepr_values
>>> print(assignrepr_values(range(1, 13), 'test(', 20) + ')')
test(1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12)
If no width is given, no wrapping is performed:
>>> print(assignrepr_values(range(1, 13), 'test(') + ')')
test(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
To circumvent defining too long string representations, make use of the
ellipsis option:
>>> from hydpy import pub
>>> with pub.options.ellipsis(1):
... print(assignrepr_values(range(1, 13), 'test(', 20) + ')')
test(1, ...,12)
>>> with pub.options.ellipsis(5):
... print(assignrepr_values(range(1, 13), 'test(', 20) + ')')
test(1, 2, 3, 4, 5,
...,8, 9, 10,
11, 12)
>>> with pub.options.ellipsis(6):
... print(assignrepr_values(range(1, 13), 'test(', 20) + ')')
test(1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12)
"""
ellipsis_ = hydpy.pub.options.ellipsis
if (ellipsis_ > 0) and (len(values) > 2*ellipsis_):
string = (repr_values(values[:ellipsis_]) +
', ...,' +
repr_values(values[-ellipsis_:]))
else:
string = repr_values(values)
blanks = ' '*len(prefix)
if width is None:
wrapped = [string]
_fakeend = 0
else:
width -= len(prefix)
wrapped = textwrap.wrap(string+'_'*_fakeend, width)
if not wrapped:
wrapped = ['']
lines = []
for (idx, line) in enumerate(wrapped):
if idx == 0:
lines.append('%s%s' % (prefix, line))
else:
lines.append('%s%s' % (blanks, line))
string = '\n'.join(lines)
return string[:len(string)-_fakeend]
|
python
|
def assignrepr_values(values, prefix, width=None, _fakeend=0):
"""Return a prefixed, wrapped and properly aligned string representation
of the given values using function |repr|.
>>> from hydpy.core.objecttools import assignrepr_values
>>> print(assignrepr_values(range(1, 13), 'test(', 20) + ')')
test(1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12)
If no width is given, no wrapping is performed:
>>> print(assignrepr_values(range(1, 13), 'test(') + ')')
test(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
To circumvent defining too long string representations, make use of the
ellipsis option:
>>> from hydpy import pub
>>> with pub.options.ellipsis(1):
... print(assignrepr_values(range(1, 13), 'test(', 20) + ')')
test(1, ...,12)
>>> with pub.options.ellipsis(5):
... print(assignrepr_values(range(1, 13), 'test(', 20) + ')')
test(1, 2, 3, 4, 5,
...,8, 9, 10,
11, 12)
>>> with pub.options.ellipsis(6):
... print(assignrepr_values(range(1, 13), 'test(', 20) + ')')
test(1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12)
"""
ellipsis_ = hydpy.pub.options.ellipsis
if (ellipsis_ > 0) and (len(values) > 2*ellipsis_):
string = (repr_values(values[:ellipsis_]) +
', ...,' +
repr_values(values[-ellipsis_:]))
else:
string = repr_values(values)
blanks = ' '*len(prefix)
if width is None:
wrapped = [string]
_fakeend = 0
else:
width -= len(prefix)
wrapped = textwrap.wrap(string+'_'*_fakeend, width)
if not wrapped:
wrapped = ['']
lines = []
for (idx, line) in enumerate(wrapped):
if idx == 0:
lines.append('%s%s' % (prefix, line))
else:
lines.append('%s%s' % (blanks, line))
string = '\n'.join(lines)
return string[:len(string)-_fakeend]
|
[
"def",
"assignrepr_values",
"(",
"values",
",",
"prefix",
",",
"width",
"=",
"None",
",",
"_fakeend",
"=",
"0",
")",
":",
"ellipsis_",
"=",
"hydpy",
".",
"pub",
".",
"options",
".",
"ellipsis",
"if",
"(",
"ellipsis_",
">",
"0",
")",
"and",
"(",
"len",
"(",
"values",
")",
">",
"2",
"*",
"ellipsis_",
")",
":",
"string",
"=",
"(",
"repr_values",
"(",
"values",
"[",
":",
"ellipsis_",
"]",
")",
"+",
"', ...,'",
"+",
"repr_values",
"(",
"values",
"[",
"-",
"ellipsis_",
":",
"]",
")",
")",
"else",
":",
"string",
"=",
"repr_values",
"(",
"values",
")",
"blanks",
"=",
"' '",
"*",
"len",
"(",
"prefix",
")",
"if",
"width",
"is",
"None",
":",
"wrapped",
"=",
"[",
"string",
"]",
"_fakeend",
"=",
"0",
"else",
":",
"width",
"-=",
"len",
"(",
"prefix",
")",
"wrapped",
"=",
"textwrap",
".",
"wrap",
"(",
"string",
"+",
"'_'",
"*",
"_fakeend",
",",
"width",
")",
"if",
"not",
"wrapped",
":",
"wrapped",
"=",
"[",
"''",
"]",
"lines",
"=",
"[",
"]",
"for",
"(",
"idx",
",",
"line",
")",
"in",
"enumerate",
"(",
"wrapped",
")",
":",
"if",
"idx",
"==",
"0",
":",
"lines",
".",
"append",
"(",
"'%s%s'",
"%",
"(",
"prefix",
",",
"line",
")",
")",
"else",
":",
"lines",
".",
"append",
"(",
"'%s%s'",
"%",
"(",
"blanks",
",",
"line",
")",
")",
"string",
"=",
"'\\n'",
".",
"join",
"(",
"lines",
")",
"return",
"string",
"[",
":",
"len",
"(",
"string",
")",
"-",
"_fakeend",
"]"
] |
Return a prefixed, wrapped and properly aligned string representation
of the given values using function |repr|.
>>> from hydpy.core.objecttools import assignrepr_values
>>> print(assignrepr_values(range(1, 13), 'test(', 20) + ')')
test(1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12)
If no width is given, no wrapping is performed:
>>> print(assignrepr_values(range(1, 13), 'test(') + ')')
test(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
To circumvent defining too long string representations, make use of the
ellipsis option:
>>> from hydpy import pub
>>> with pub.options.ellipsis(1):
... print(assignrepr_values(range(1, 13), 'test(', 20) + ')')
test(1, ...,12)
>>> with pub.options.ellipsis(5):
... print(assignrepr_values(range(1, 13), 'test(', 20) + ')')
test(1, 2, 3, 4, 5,
...,8, 9, 10,
11, 12)
>>> with pub.options.ellipsis(6):
... print(assignrepr_values(range(1, 13), 'test(', 20) + ')')
test(1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12)
|
[
"Return",
"a",
"prefixed",
"wrapped",
"and",
"properly",
"aligned",
"string",
"representation",
"of",
"the",
"given",
"values",
"using",
"function",
"|repr|",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/objecttools.py#L871-L930
|
hydpy-dev/hydpy
|
hydpy/core/objecttools.py
|
assignrepr_values2
|
def assignrepr_values2(values, prefix):
"""Return a prefixed and properly aligned string representation
of the given 2-dimensional value matrix using function |repr|.
>>> from hydpy.core.objecttools import assignrepr_values2
>>> import numpy
>>> print(assignrepr_values2(numpy.eye(3), 'test(') + ')')
test(1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 1.0)
Functions |assignrepr_values2| works also on empty iterables:
>>> print(assignrepr_values2([[]], 'test(') + ')')
test()
"""
lines = []
blanks = ' '*len(prefix)
for (idx, subvalues) in enumerate(values):
if idx == 0:
lines.append('%s%s,' % (prefix, repr_values(subvalues)))
else:
lines.append('%s%s,' % (blanks, repr_values(subvalues)))
lines[-1] = lines[-1][:-1]
return '\n'.join(lines)
|
python
|
def assignrepr_values2(values, prefix):
"""Return a prefixed and properly aligned string representation
of the given 2-dimensional value matrix using function |repr|.
>>> from hydpy.core.objecttools import assignrepr_values2
>>> import numpy
>>> print(assignrepr_values2(numpy.eye(3), 'test(') + ')')
test(1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 1.0)
Functions |assignrepr_values2| works also on empty iterables:
>>> print(assignrepr_values2([[]], 'test(') + ')')
test()
"""
lines = []
blanks = ' '*len(prefix)
for (idx, subvalues) in enumerate(values):
if idx == 0:
lines.append('%s%s,' % (prefix, repr_values(subvalues)))
else:
lines.append('%s%s,' % (blanks, repr_values(subvalues)))
lines[-1] = lines[-1][:-1]
return '\n'.join(lines)
|
[
"def",
"assignrepr_values2",
"(",
"values",
",",
"prefix",
")",
":",
"lines",
"=",
"[",
"]",
"blanks",
"=",
"' '",
"*",
"len",
"(",
"prefix",
")",
"for",
"(",
"idx",
",",
"subvalues",
")",
"in",
"enumerate",
"(",
"values",
")",
":",
"if",
"idx",
"==",
"0",
":",
"lines",
".",
"append",
"(",
"'%s%s,'",
"%",
"(",
"prefix",
",",
"repr_values",
"(",
"subvalues",
")",
")",
")",
"else",
":",
"lines",
".",
"append",
"(",
"'%s%s,'",
"%",
"(",
"blanks",
",",
"repr_values",
"(",
"subvalues",
")",
")",
")",
"lines",
"[",
"-",
"1",
"]",
"=",
"lines",
"[",
"-",
"1",
"]",
"[",
":",
"-",
"1",
"]",
"return",
"'\\n'",
".",
"join",
"(",
"lines",
")"
] |
Return a prefixed and properly aligned string representation
of the given 2-dimensional value matrix using function |repr|.
>>> from hydpy.core.objecttools import assignrepr_values2
>>> import numpy
>>> print(assignrepr_values2(numpy.eye(3), 'test(') + ')')
test(1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 1.0)
Functions |assignrepr_values2| works also on empty iterables:
>>> print(assignrepr_values2([[]], 'test(') + ')')
test()
|
[
"Return",
"a",
"prefixed",
"and",
"properly",
"aligned",
"string",
"representation",
"of",
"the",
"given",
"2",
"-",
"dimensional",
"value",
"matrix",
"using",
"function",
"|repr|",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/objecttools.py#L1050-L1074
|
hydpy-dev/hydpy
|
hydpy/core/objecttools.py
|
_assignrepr_bracketed2
|
def _assignrepr_bracketed2(assignrepr_bracketed1, values, prefix, width=None):
"""Return a prefixed, wrapped and properly aligned bracketed string
representation of the given 2-dimensional value matrix using function
|repr|."""
brackets = getattr(assignrepr_bracketed1, '_brackets')
prefix += brackets[0]
lines = []
blanks = ' '*len(prefix)
for (idx, subvalues) in enumerate(values):
if idx == 0:
lines.append(assignrepr_bracketed1(subvalues, prefix, width))
else:
lines.append(assignrepr_bracketed1(subvalues, blanks, width))
lines[-1] += ','
if (len(values) > 1) or (brackets != '()'):
lines[-1] = lines[-1][:-1]
lines[-1] += brackets[1]
return '\n'.join(lines)
|
python
|
def _assignrepr_bracketed2(assignrepr_bracketed1, values, prefix, width=None):
"""Return a prefixed, wrapped and properly aligned bracketed string
representation of the given 2-dimensional value matrix using function
|repr|."""
brackets = getattr(assignrepr_bracketed1, '_brackets')
prefix += brackets[0]
lines = []
blanks = ' '*len(prefix)
for (idx, subvalues) in enumerate(values):
if idx == 0:
lines.append(assignrepr_bracketed1(subvalues, prefix, width))
else:
lines.append(assignrepr_bracketed1(subvalues, blanks, width))
lines[-1] += ','
if (len(values) > 1) or (brackets != '()'):
lines[-1] = lines[-1][:-1]
lines[-1] += brackets[1]
return '\n'.join(lines)
|
[
"def",
"_assignrepr_bracketed2",
"(",
"assignrepr_bracketed1",
",",
"values",
",",
"prefix",
",",
"width",
"=",
"None",
")",
":",
"brackets",
"=",
"getattr",
"(",
"assignrepr_bracketed1",
",",
"'_brackets'",
")",
"prefix",
"+=",
"brackets",
"[",
"0",
"]",
"lines",
"=",
"[",
"]",
"blanks",
"=",
"' '",
"*",
"len",
"(",
"prefix",
")",
"for",
"(",
"idx",
",",
"subvalues",
")",
"in",
"enumerate",
"(",
"values",
")",
":",
"if",
"idx",
"==",
"0",
":",
"lines",
".",
"append",
"(",
"assignrepr_bracketed1",
"(",
"subvalues",
",",
"prefix",
",",
"width",
")",
")",
"else",
":",
"lines",
".",
"append",
"(",
"assignrepr_bracketed1",
"(",
"subvalues",
",",
"blanks",
",",
"width",
")",
")",
"lines",
"[",
"-",
"1",
"]",
"+=",
"','",
"if",
"(",
"len",
"(",
"values",
")",
">",
"1",
")",
"or",
"(",
"brackets",
"!=",
"'()'",
")",
":",
"lines",
"[",
"-",
"1",
"]",
"=",
"lines",
"[",
"-",
"1",
"]",
"[",
":",
"-",
"1",
"]",
"lines",
"[",
"-",
"1",
"]",
"+=",
"brackets",
"[",
"1",
"]",
"return",
"'\\n'",
".",
"join",
"(",
"lines",
")"
] |
Return a prefixed, wrapped and properly aligned bracketed string
representation of the given 2-dimensional value matrix using function
|repr|.
|
[
"Return",
"a",
"prefixed",
"wrapped",
"and",
"properly",
"aligned",
"bracketed",
"string",
"representation",
"of",
"the",
"given",
"2",
"-",
"dimensional",
"value",
"matrix",
"using",
"function",
"|repr|",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/objecttools.py#L1077-L1094
|
hydpy-dev/hydpy
|
hydpy/core/objecttools.py
|
round_
|
def round_(values, decimals=None, width=0,
lfill=None, rfill=None, **kwargs):
"""Prints values with a maximum number of digits in doctests.
See the documentation on function |repr| for more details. And
note thate the option keyword arguments are passed to the print function.
Usually one would apply function |round_| on a single or a vector
of numbers:
>>> from hydpy import round_
>>> round_(1./3., decimals=6)
0.333333
>>> round_((1./2., 1./3., 1./4.), decimals=4)
0.5, 0.3333, 0.25
Additionally, one can supply a `width` and a `rfill` argument:
>>> round_(1.0, width=6, rfill='0')
1.0000
Alternatively, one can use the `lfill` arguments, which
might e.g. be usefull for aligning different strings:
>>> round_('test', width=6, lfill='_')
__test
Using both the `lfill` and the `rfill` argument raises an error:
>>> round_(1.0, lfill='_', rfill='0')
Traceback (most recent call last):
...
ValueError: For function `round_` values are passed for both \
arguments `lfill` and `rfill`. This is not allowed.
"""
if decimals is None:
decimals = hydpy.pub.options.reprdigits
with hydpy.pub.options.reprdigits(decimals):
if isinstance(values, abctools.IterableNonStringABC):
string = repr_values(values)
else:
string = repr_(values)
if (lfill is not None) and (rfill is not None):
raise ValueError(
'For function `round_` values are passed for both arguments '
'`lfill` and `rfill`. This is not allowed.')
if (lfill is not None) or (rfill is not None):
width = max(width, len(string))
if lfill is not None:
string = string.rjust(width, lfill)
else:
string = string.ljust(width, rfill)
print(string, **kwargs)
|
python
|
def round_(values, decimals=None, width=0,
lfill=None, rfill=None, **kwargs):
"""Prints values with a maximum number of digits in doctests.
See the documentation on function |repr| for more details. And
note thate the option keyword arguments are passed to the print function.
Usually one would apply function |round_| on a single or a vector
of numbers:
>>> from hydpy import round_
>>> round_(1./3., decimals=6)
0.333333
>>> round_((1./2., 1./3., 1./4.), decimals=4)
0.5, 0.3333, 0.25
Additionally, one can supply a `width` and a `rfill` argument:
>>> round_(1.0, width=6, rfill='0')
1.0000
Alternatively, one can use the `lfill` arguments, which
might e.g. be usefull for aligning different strings:
>>> round_('test', width=6, lfill='_')
__test
Using both the `lfill` and the `rfill` argument raises an error:
>>> round_(1.0, lfill='_', rfill='0')
Traceback (most recent call last):
...
ValueError: For function `round_` values are passed for both \
arguments `lfill` and `rfill`. This is not allowed.
"""
if decimals is None:
decimals = hydpy.pub.options.reprdigits
with hydpy.pub.options.reprdigits(decimals):
if isinstance(values, abctools.IterableNonStringABC):
string = repr_values(values)
else:
string = repr_(values)
if (lfill is not None) and (rfill is not None):
raise ValueError(
'For function `round_` values are passed for both arguments '
'`lfill` and `rfill`. This is not allowed.')
if (lfill is not None) or (rfill is not None):
width = max(width, len(string))
if lfill is not None:
string = string.rjust(width, lfill)
else:
string = string.ljust(width, rfill)
print(string, **kwargs)
|
[
"def",
"round_",
"(",
"values",
",",
"decimals",
"=",
"None",
",",
"width",
"=",
"0",
",",
"lfill",
"=",
"None",
",",
"rfill",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"decimals",
"is",
"None",
":",
"decimals",
"=",
"hydpy",
".",
"pub",
".",
"options",
".",
"reprdigits",
"with",
"hydpy",
".",
"pub",
".",
"options",
".",
"reprdigits",
"(",
"decimals",
")",
":",
"if",
"isinstance",
"(",
"values",
",",
"abctools",
".",
"IterableNonStringABC",
")",
":",
"string",
"=",
"repr_values",
"(",
"values",
")",
"else",
":",
"string",
"=",
"repr_",
"(",
"values",
")",
"if",
"(",
"lfill",
"is",
"not",
"None",
")",
"and",
"(",
"rfill",
"is",
"not",
"None",
")",
":",
"raise",
"ValueError",
"(",
"'For function `round_` values are passed for both arguments '",
"'`lfill` and `rfill`. This is not allowed.'",
")",
"if",
"(",
"lfill",
"is",
"not",
"None",
")",
"or",
"(",
"rfill",
"is",
"not",
"None",
")",
":",
"width",
"=",
"max",
"(",
"width",
",",
"len",
"(",
"string",
")",
")",
"if",
"lfill",
"is",
"not",
"None",
":",
"string",
"=",
"string",
".",
"rjust",
"(",
"width",
",",
"lfill",
")",
"else",
":",
"string",
"=",
"string",
".",
"ljust",
"(",
"width",
",",
"rfill",
")",
"print",
"(",
"string",
",",
"*",
"*",
"kwargs",
")"
] |
Prints values with a maximum number of digits in doctests.
See the documentation on function |repr| for more details. And
note thate the option keyword arguments are passed to the print function.
Usually one would apply function |round_| on a single or a vector
of numbers:
>>> from hydpy import round_
>>> round_(1./3., decimals=6)
0.333333
>>> round_((1./2., 1./3., 1./4.), decimals=4)
0.5, 0.3333, 0.25
Additionally, one can supply a `width` and a `rfill` argument:
>>> round_(1.0, width=6, rfill='0')
1.0000
Alternatively, one can use the `lfill` arguments, which
might e.g. be usefull for aligning different strings:
>>> round_('test', width=6, lfill='_')
__test
Using both the `lfill` and the `rfill` argument raises an error:
>>> round_(1.0, lfill='_', rfill='0')
Traceback (most recent call last):
...
ValueError: For function `round_` values are passed for both \
arguments `lfill` and `rfill`. This is not allowed.
|
[
"Prints",
"values",
"with",
"a",
"maximum",
"number",
"of",
"digits",
"in",
"doctests",
"."
] |
train
|
https://github.com/hydpy-dev/hydpy/blob/1bc6a82cf30786521d86b36e27900c6717d3348d/hydpy/core/objecttools.py#L1324-L1375
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.