INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Special declaration lines for the given |IOSequence| object. | 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)
lin... |
Open file statements. | 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... |
Close file statements. | 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_fil... |
Load data statements. | 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.a... |
Set_pointer functions for link sequences. | 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:
... |
Set_pointer function for 0 - dimensional link sequences. | 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:
... |
Allocate memory for 1 - dimensional link sequences. | 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.a... |
Deallocate memory for 1 - dimensional link sequences. | 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 |
Set_pointer function for 1 - dimensional link sequences. | 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 subseq... |
Numeric parameter declaration lines. | 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(... |
Attribute declarations of the model class. | 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.ad... |
Standard functions of the model class. | 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.updat... |
Numerical functions of the model class. | 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_poin... |
Do ( most of ) it function of the model class. | 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... |
Input/ output functions of the model class. | 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)):
con... |
Lines of model method with the same name. | 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 ='
... |
User functions of the model class. | 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.g... |
Cleaned code lines. | 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
... |
r Remove line breaks 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_withi... |
Remove mathematical expressions that require Pythons global interpreter locking mechanism. | 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
... |
Cython code lines. | 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`
... |
Return the smoothing parameter corresponding to the given meta parameter when using |smooth_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
... |
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|. | 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... |
Return a 1 - dimensional |numpy| |numpy. ndarray| with six entries defining the actual date ( year month day hour minute second ). | 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.])... |
Return a |Date| object representing the reference date of the given units string agreeing with the NetCDF - CF conventions. | 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 (mo... |
Return a units string agreeing with the NetCDF - CF conventions. | 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
... |
Convenience method for _set_year _set_month... | 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 numbe... |
The actual hydrological year according to the selected reference month. | 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
... |
Return a |str| object representing the actual date in accordance with the given style and the eventually given UTC offset ( in minutes ). | 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 you... |
Return a |Period| instance based on a given number of seconds. | 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))) |
Guess the unit of the period as the largest one which results in an integer duration. | 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 ... |
Returns a |Timegrid| instance based on two date and one period information stored in the first 13 rows of a |numpy. ndarray| object. | 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]),
... |
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. | 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(... |
Return a |Timegrid| object representing the given starting timepoints in relation to the given refdate. | 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 give... |
Return an |numpy. ndarray| representing the starting time points of the |Timegrid| object. | 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 h... |
Prefix the information of the actual Timegrid object to the given array and return it. | 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 `array2s... |
Raise an |ValueError| if the dates or the step size of the time frame are inconsistent. | 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... |
Return a |repr| string with an prefixed assignement. | 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',
... ... |
Raise an |ValueError| it the different time grids are inconsistent. | 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 '
... |
Return a |repr| string with a prefixed assignment. | 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.ap... |
Amount of time passed in seconds since the beginning of the year. | 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 ... |
Remaining part of the year in seconds. | 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 2... |
Return a |Timegrid| object defining the central time points of the year 2000 for the given simulation step. | 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',
'200... |
The prefered way for HydPy objects to respond to |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 h... |
Return the class name of the given instance object or class. | 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 = ... |
Name of the class of the given instance in lower case letters. | 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 ... |
Raises an |ValueError| if the given name is not a valid Python 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 t... |
Augment an exception message with additional information while keeping the original traceback. | 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 follo... |
Wrap a function with |augment_excmessage|. | 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:... |
Print the given values in multiple lines with a certain maximum width. | 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,
... |
Return a prefixed wrapped and properly aligned string representation of the given values using function |repr|. | 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) + ')')
t... |
Return a prefixed and properly aligned string representation of the given 2 - dimensional value matrix using function |repr|. | 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(') + ')'... |
Return a prefixed wrapped and properly aligned bracketed string representation of the given 2 - dimensional value matrix using function |repr|. | 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 += bracket... |
Prints values with a maximum number of digits in doctests. | 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 w... |
Return a generator that extracts certain objects from values. | def extract(values, types, skip=False):
"""Return a generator that extracts certain objects from `values`.
This function is thought for supporting the definition of functions
with arguments, that can be objects of of contain types or that can
be iterables containing these objects.
The following ex... |
Return an enumeration string based on the given values. | def enumeration(values, converter=str, default=''):
"""Return an enumeration string based on the given values.
The following four examples show the standard output of function
|enumeration|:
>>> from hydpy.core.objecttools import enumeration
>>> enumeration(('text', 3, []))
'text, 3, and []'
... |
Trim upper values in accordance with: math: IC \\ leq ICMAX. | def trim(self, lower=None, upper=None):
"""Trim upper values in accordance with :math:`IC \\leq ICMAX`.
>>> from hydpy.models.hland import *
>>> parameterstep('1d')
>>> nmbzones(5)
>>> icmax(2.0)
>>> states.ic(-1.0, 0.0, 1.0, 2.0, 3.0)
>>> states.ic
ic(0.... |
Trim values in accordance with: math: WC \\ leq WHC \\ cdot SP. | def trim(self, lower=None, upper=None):
"""Trim values in accordance with :math:`WC \\leq WHC \\cdot SP`.
>>> from hydpy.models.hland import *
>>> parameterstep('1d')
>>> nmbzones(7)
>>> whc(0.1)
>>> states.wc.values = -1.0, 0.0, 1.0, -1.0, 0.0, 0.5, 1.0
>>> stat... |
Trim values in accordance with: math: WC \\ leq WHC \\ cdot SP. | def trim(self, lower=None, upper=None):
"""Trim values in accordance with :math:`WC \\leq WHC \\cdot SP`.
>>> from hydpy.models.hland import *
>>> parameterstep('1d')
>>> nmbzones(7)
>>> whc(0.1)
>>> states.sp = 0.0, 0.0, 0.0, 5.0, 5.0, 5.0, 5.0
>>> states.wc(-1.... |
Trim negative value whenever there is no internal lake within the respective subbasin. | def trim(self, lower=None, upper=None):
"""Trim negative value whenever there is no internal lake within
the respective subbasin.
>>> from hydpy.models.hland import *
>>> parameterstep('1d')
>>> nmbzones(2)
>>> zonetype(FIELD, ILAKE)
>>> states.lz(-1.0)
>... |
Call method |InputSequences. load_data| of all handled |InputSequences| objects. | def load_data(self, idx):
"""Call method |InputSequences.load_data| of all handled
|InputSequences| objects."""
for subseqs in self:
if isinstance(subseqs, abctools.InputSequencesABC):
subseqs.load_data(idx) |
Call method save_data| of all handled |IOSequences| objects registered under |OutputSequencesABC|. | def save_data(self, idx):
"""Call method `save_data|` of all handled |IOSequences|
objects registered under |OutputSequencesABC|."""
for subseqs in self:
if isinstance(subseqs, abctools.OutputSequencesABC):
subseqs.save_data(idx) |
Nested dictionary containing the values of all condition sequences. | def conditions(self) -> Dict[str, Dict[str, Union[float, numpy.ndarray]]]:
"""Nested dictionary containing the values of all condition
sequences.
See the documentation on property |HydPy.conditions| for further
information.
"""
conditions = {}
for subname in NAME... |
Read the initial conditions from a file and assign them to the respective |StateSequence| and/ or |LogSequence| objects handled by the actual |Sequences| object. | def load_conditions(self, filename=None):
"""Read the initial conditions from a file and assign them to the
respective |StateSequence| and/or |LogSequence| objects handled by
the actual |Sequences| object.
If no filename or dirname is passed, the ones defined by the
|ConditionMa... |
Query the actual conditions of the |StateSequence| and/ or |LogSequence| objects handled by the actual |Sequences| object and write them into a initial condition file. | def save_conditions(self, filename=None):
"""Query the actual conditions of the |StateSequence| and/or
|LogSequence| objects handled by the actual |Sequences| object and
write them into a initial condition file.
If no filename or dirname is passed, the ones defined by the
|Condi... |
Absolute path of the directory of the internal data file. | def dirpath_int(self):
"""Absolute path of the directory of the internal data file.
Normally, each sequence queries its current "internal" directory
path from the |SequenceManager| object stored in module |pub|:
>>> from hydpy import pub, repr_, TestIO
>>> from hydpy.core.filet... |
Move internal data from disk to RAM. | def disk2ram(self):
"""Move internal data from disk to RAM."""
values = self.series
self.deactivate_disk()
self.ramflag = True
self.__set_array(values)
self.update_fastaccess() |
Move internal data from RAM to disk. | def ram2disk(self):
"""Move internal data from RAM to disk."""
values = self.series
self.deactivate_ram()
self.diskflag = True
self._save_int(values)
self.update_fastaccess() |
Shape of the whole time series ( time being the first dimension ). | def seriesshape(self):
"""Shape of the whole time series (time being the first dimension)."""
seriesshape = [len(hydpy.pub.timegrids.init)]
seriesshape.extend(self.shape)
return tuple(seriesshape) |
Shape of the array of temporary values required for the numerical solver actually being selected. | def numericshape(self):
"""Shape of the array of temporary values required for the numerical
solver actually being selected."""
try:
numericshape = [self.subseqs.seqs.model.numconsts.nmb_stages]
except AttributeError:
objecttools.augment_excmessage(
... |
Internal time series data within an |numpy. ndarray|. | def series(self) -> InfoArray:
"""Internal time series data within an |numpy.ndarray|."""
if self.diskflag:
array = self._load_int()
elif self.ramflag:
array = self.__get_array()
else:
raise AttributeError(
f'Sequence {objecttools.devic... |
Read the internal data from an external data file. | def load_ext(self):
"""Read the internal data from an external data file."""
try:
sequencemanager = hydpy.pub.sequencemanager
except AttributeError:
raise RuntimeError(
'The time series of sequence %s cannot be loaded. Firstly, '
'you have... |
Adjust a short time series to a longer timegrid. | def adjust_short_series(self, timegrid, values):
"""Adjust a short time series to a longer timegrid.
Normally, time series data to be read from a external data files
should span (at least) the whole initialization time period of a
HydPy project. However, for some variables which are on... |
Raise a |RuntimeError| if the |IOSequence. series| contains at least one |numpy. nan| value if option |Options. checkseries| is enabled. | def check_completeness(self):
"""Raise a |RuntimeError| if the |IOSequence.series| contains at
least one |numpy.nan| value, if option |Options.checkseries| is
enabled.
>>> from hydpy import pub
>>> pub.timegrids = '2000-01-01', '2000-01-11', '1d'
>>> from hydpy.core.sequ... |
Write the internal data into an external data file. | def save_ext(self):
"""Write the internal data into an external data file."""
try:
sequencemanager = hydpy.pub.sequencemanager
except AttributeError:
raise RuntimeError(
'The time series of sequence %s cannot be saved. Firstly,'
'you have ... |
Load internal data from file and return it. | def _load_int(self):
"""Load internal data from file and return it."""
values = numpy.fromfile(self.filepath_int)
if self.NDIM > 0:
values = values.reshape(self.seriesshape)
return values |
Average the actual time series of the |Variable| object for all time points. | def average_series(self, *args, **kwargs) -> InfoArray:
"""Average the actual time series of the |Variable| object for all
time points.
Method |IOSequence.average_series| works similarly as method
|Variable.average_values| of class |Variable|, from which we
borrow some examples.... |
Aggregates time series data based on the actual |FluxSequence. aggregation_ext| attribute of |IOSequence| subclasses. | def aggregate_series(self, *args, **kwargs) -> InfoArray:
"""Aggregates time series data based on the actual
|FluxSequence.aggregation_ext| attribute of |IOSequence|
subclasses.
We prepare some nodes and elements with the help of
method |prepare_io_example_1| and select a 1-dime... |
Assess to the state value ( s ) at beginning of the time step which has been processed most recently. When using * HydPy * in the normal manner. But it can be helpful for demonstration and debugging purposes. | def old(self):
"""Assess to the state value(s) at beginning of the time step, which
has been processed most recently. When using *HydPy* in the
normal manner. But it can be helpful for demonstration and debugging
purposes.
"""
value = getattr(self.fastaccess_old, self.n... |
Read time series data like method |IOSequence. load_ext| of class |IOSequence| but with special handling of missing data. | def load_ext(self):
"""Read time series data like method |IOSequence.load_ext| of class
|IOSequence|, but with special handling of missing data.
The method's "special handling" is to convert errors to warnings.
We explain the reasons in the documentation on method |Obs.load_ext|
... |
Read time series data like method |IOSequence. load_ext| of class |IOSequence| but with special handling of missing data. | def load_ext(self):
"""Read time series data like method |IOSequence.load_ext| of class
|IOSequence|, but with special handling of missing data.
When reading incomplete time series data, *HydPy* usually raises
a |RuntimeError| to prevent from performing erroneous calculations.
F... |
Open all files with an activated disk flag. | def open_files(self, idx):
"""Open all files with an activated disk flag."""
for name in self:
if getattr(self, '_%s_diskflag' % name):
path = getattr(self, '_%s_path' % name)
file_ = open(path, 'rb+')
ndim = getattr(self, '_%s_ndim' % name)
... |
Close all files with an activated disk flag. | def close_files(self):
"""Close all files with an activated disk flag."""
for name in self:
if getattr(self, '_%s_diskflag' % name):
file_ = getattr(self, '_%s_file' % name)
file_.close() |
Load the internal data of all sequences. Load from file if the corresponding disk flag is activated otherwise load from RAM. | def load_data(self, idx):
"""Load the internal data of all sequences. Load from file if the
corresponding disk flag is activated, otherwise load from RAM."""
for name in self:
ndim = getattr(self, '_%s_ndim' % name)
diskflag = getattr(self, '_%s_diskflag' % name)
... |
Save the internal data of all sequences with an activated flag. Write to file if the corresponding disk flag is activated ; store in working memory if the corresponding ram flag is activated. | def save_data(self, idx):
"""Save the internal data of all sequences with an activated flag.
Write to file if the corresponding disk flag is activated; store
in working memory if the corresponding ram flag is activated."""
for name in self:
actual = getattr(self, name)
... |
Load the next sim sequence value ( of the given index ). | def load_simdata(self, idx: int) -> None:
"""Load the next sim sequence value (of the given index)."""
if self._sim_ramflag:
self.sim[0] = self._sim_array[idx]
elif self._sim_diskflag:
raw = self._sim_file.read(8)
self.sim[0] = struct.unpack('d', raw) |
Save the last sim sequence value ( of the given index ). | def save_simdata(self, idx: int) -> None:
"""Save the last sim sequence value (of the given index)."""
if self._sim_ramflag:
self._sim_array[idx] = self.sim[0]
elif self._sim_diskflag:
raw = struct.pack('d', self.sim[0])
self._sim_file.write(raw) |
Load the next obs sequence value ( of the given index ). | def load_obsdata(self, idx: int) -> None:
"""Load the next obs sequence value (of the given index)."""
if self._obs_ramflag:
self.obs[0] = self._obs_array[idx]
elif self._obs_diskflag:
raw = self._obs_file.read(8)
self.obs[0] = struct.unpack('d', raw) |
Update |AbsFHRU| based on |FT| and |FHRU|. | def update(self):
"""Update |AbsFHRU| based on |FT| and |FHRU|.
>>> from hydpy.models.lland import *
>>> parameterstep('1d')
>>> nhru(2)
>>> lnk(ACKER)
>>> ft(100.0)
>>> fhru(0.2, 0.8)
>>> derived.absfhru.update()
>>> derived.absfhru
absfh... |
Update |KInz| based on |HInz| and |LAI|. | def update(self):
"""Update |KInz| based on |HInz| and |LAI|.
>>> from hydpy.models.lland import *
>>> parameterstep('1d')
>>> nhru(2)
>>> hinz(0.2)
>>> lai.acker_jun = 1.0
>>> lai.vers_dec = 2.0
>>> derived.kinz.update()
>>> from hydpy import rou... |
Update |WB| based on |RelWB| and |NFk|. | def update(self):
"""Update |WB| based on |RelWB| and |NFk|.
>>> from hydpy.models.lland import *
>>> parameterstep('1d')
>>> nhru(2)
>>> lnk(ACKER)
>>> relwb(0.2)
>>> nfk(100.0, 200.0)
>>> derived.wb.update()
>>> derived.wb
wb(20.0, 40.0)... |
Update |WZ| based on |RelWZ| and |NFk|. | def update(self):
"""Update |WZ| based on |RelWZ| and |NFk|.
>>> from hydpy.models.lland import *
>>> parameterstep('1d')
>>> nhru(2)
>>> lnk(ACKER)
>>> relwz(0.8)
>>> nfk(100.0, 200.0)
>>> derived.wz.update()
>>> derived.wz
wz(80.0, 160.0... |
Update |KB| based on |EQB| and |TInd|. | def update(self):
"""Update |KB| based on |EQB| and |TInd|.
>>> from hydpy.models.lland import *
>>> parameterstep('1d')
>>> eqb(10.0)
>>> tind.value = 10.0
>>> derived.kb.update()
>>> derived.kb
kb(100.0)
"""
con = self.subpars.pars.contr... |
Update |KI1| based on |EQI1| and |TInd|. | def update(self):
"""Update |KI1| based on |EQI1| and |TInd|.
>>> from hydpy.models.lland import *
>>> parameterstep('1d')
>>> eqi1(5.0)
>>> tind.value = 10.0
>>> derived.ki1.update()
>>> derived.ki1
ki1(50.0)
"""
con = self.subpars.pars.c... |
Update |KI2| based on |EQI2| and |TInd|. | def update(self):
"""Update |KI2| based on |EQI2| and |TInd|.
>>> from hydpy.models.lland import *
>>> parameterstep('1d')
>>> eqi2(1.0)
>>> tind.value = 10.0
>>> derived.ki2.update()
>>> derived.ki2
ki2(10.0)
"""
con = self.subpars.pars.c... |
Update |KD1| based on |EQD1| and |TInd|. | def update(self):
"""Update |KD1| based on |EQD1| and |TInd|.
>>> from hydpy.models.lland import *
>>> parameterstep('1d')
>>> eqd1(0.5)
>>> tind.value = 10.0
>>> derived.kd1.update()
>>> derived.kd1
kd1(5.0)
"""
con = self.subpars.pars.co... |
Update |KD2| based on |EQD2| and |TInd|. | def update(self):
"""Update |KD2| based on |EQD2| and |TInd|.
>>> from hydpy.models.lland import *
>>> parameterstep('1d')
>>> eqd2(0.1)
>>> tind.value = 10.0
>>> derived.kd2.update()
>>> derived.kd2
kd2(1.0)
"""
con = self.subpars.pars.co... |
Update |QFactor| based on |FT| and the current simulation step size. | def update(self):
"""Update |QFactor| based on |FT| and the current simulation step size.
>>> from hydpy.models.lland import *
>>> parameterstep('1d')
>>> simulationstep('1d')
>>> ft(10.0)
>>> derived.qfactor.update()
>>> derived.qfactor
qfactor(0.115741)... |
A tuple of the numbers of all routing basins. | def _router_numbers(self):
"""A tuple of the numbers of all "routing" basins."""
return tuple(up for up in self._up2down.keys()
if up in self._up2down.values()) |
A |Elements| collection of all supplying basins. | def supplier_elements(self):
"""A |Elements| collection of all "supplying" basins.
(All river basins are assumed to supply something to the downstream
basin.)
>>> from hydpy import RiverBasinNumbers2Selection
>>> rbns2s = RiverBasinNumbers2Selection(
... ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.