text stringlengths 81 112k |
|---|
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.
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) |
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.
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.') |
Sum of the absolute deviations between the central moments of the
instantaneous unit hydrograph and the ARMA approximation.
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)) |
Multiply all coefficients by the same factor, so that their sum
becomes one.
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 |
The sum of all AR and MA coefficients
def sum_coefs(self):
"""The sum of all AR and MA coefficients"""
return numpy.sum(self.ar_coefs) + numpy.sum(self.ma_coefs) |
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.
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. |
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|.
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) |
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.
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))) |
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.
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])) |
Return the response to a standard dt impulse.
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) |
The first two time delay weighted statistical moments of the
ARMA response.
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]) |
Barplot of the ARMA response.
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) |
Returns the Cython method header for methods without arguments except
`self`.
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 |
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 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) |
Appends the given text line with prefixed spaces in accordance with
the given number of indentation levels.
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) |
Name of the compiled module.
def pyname(self):
"""Name of the compiled module."""
if self.pymodule.endswith('__init__'):
return self.pymodule.split('.')[-2]
else:
return self.pymodule.split('.')[-1] |
Update the pyx file.
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) |
All source files of the actual models Python classes and their
respective base classes.
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) |
True if at least one of the |Cythonizer.pysourcefiles| is
newer than the compiled file under |Cythonizer.pyxfilepath|,
otherwise False.
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 |
Translate cython code to C code and compile it.
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 |
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.
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) |
Constants declaration lines.
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 |
Parameter declaration lines.
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 |
Sequence declaration lines.
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 |
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)
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 |
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(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 |
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_file)' % seq.name)
return lines |
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.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 |
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:
lines.extend(self.alloc(subseqs))
lines.extend(self.dealloc(subseqs))
lines.extend(self.set_pointer1d(subseqs))
break
return lines |
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:
lines.add(2, 'if name == "%s":' % seq.name)
lines.add(3, 'self.%s = value.p_value' % seq.name)
return lines |
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.add(3, 'self._%s_length_0 = length' % seq.name)
lines.add(3, 'self.%s = <double**> '
'PyMem_Malloc(length * sizeof(double*))' % seq.name)
return lines |
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 subseqs:
lines.add(2, 'if name == "%s":' % seq.name)
lines.add(3, 'self.%s[idx] = value.p_value' % seq.name)
return lines |
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(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 |
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.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 |
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.update_outlets)
lines.extend(self.update_receivers)
lines.extend(self.update_senders)
return lines |
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_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 |
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 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 |
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)):
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 |
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 ='
'self.numvars.nmb_calls+1'))
return lines |
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.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 |
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
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) |
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)'
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) |
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)']
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 |
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_`
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) |
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
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,)) |
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.
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])) |
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.
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) |
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.
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}`') |
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'
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}' |
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 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) |
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
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 |
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'
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 |
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 not self.seconds % 1:
return 's'
else:
raise ValueError(
'The stepsize is not a multiple of one '
'second, which is not allowed.') |
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]),
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 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()
values[6:12] = self.lastdate.to_array()
values[12] = self.stepsize.seconds
return values |
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')
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) |
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])
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 |
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`.
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 |
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 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}.') |
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')
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)}')") |
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 '
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.') |
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.append(f'{self.sim.assignrepr(blanks)},')
lines[-1] = lines[-1][:-1] + ')'
return '\n'.join(lines) |
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
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()) |
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
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()) |
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')
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) |
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()))
[' ']
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 |
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
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] |
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'
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'] |
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...
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) |
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')
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 |
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'
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 |
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
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) |
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)
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] |
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()
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) |
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 += 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) |
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.
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) |
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 examples show that function |extract|
basically implements a type specific flattening mechanism:
>>> from hydpy.core.objecttools import extract
>>> tuple(extract('str1', (str, int)))
('str1',)
>>> tuple(extract(['str1', 'str2'], (str, int)))
('str1', 'str2')
>>> tuple(extract((['str1', 'str2'], [1,]), (str, int)))
('str1', 'str2', 1)
If an object is neither iterable nor of the required type, the
following exception is raised:
>>> tuple(extract((['str1', 'str2'], [None, 1]), (str, int)))
Traceback (most recent call last):
...
TypeError: The given value `None` is neither iterable nor \
an instance of the following classes: str and int.
Optionally, |None| values can be skipped:
>>> tuple(extract(None, (str, int), True))
()
>>> tuple(extract((['str1', 'str2'], [None, 1]), (str, int), True))
('str1', 'str2', 1)
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 examples show that function |extract|
basically implements a type specific flattening mechanism:
>>> from hydpy.core.objecttools import extract
>>> tuple(extract('str1', (str, int)))
('str1',)
>>> tuple(extract(['str1', 'str2'], (str, int)))
('str1', 'str2')
>>> tuple(extract((['str1', 'str2'], [1,]), (str, int)))
('str1', 'str2', 1)
If an object is neither iterable nor of the required type, the
following exception is raised:
>>> tuple(extract((['str1', 'str2'], [None, 1]), (str, int)))
Traceback (most recent call last):
...
TypeError: The given value `None` is neither iterable nor \
an instance of the following classes: str and int.
Optionally, |None| values can be skipped:
>>> tuple(extract(None, (str, int), True))
()
>>> tuple(extract((['str1', 'str2'], [None, 1]), (str, int), True))
('str1', 'str2', 1)
"""
if isinstance(values, types):
yield values
elif skip and (values is None):
return
else:
try:
for value in values:
for subvalue in extract(value, types, skip):
yield subvalue
except TypeError as exc:
if exc.args[0].startswith('The given value'):
raise exc
else:
raise TypeError(
f'The given value `{repr(values)}` is neither iterable '
f'nor an instance of the following classes: '
f'{enumeration(types, converter=instancename)}.') |
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 []'
>>> enumeration(('text', 3))
'text and 3'
>>> enumeration(('text',))
'text'
>>> enumeration(())
''
All given objects are converted to strings by function |str|, as shown
by the first two examples. This behaviour can be changed by another
function expecting a single argument and returning a string:
>>> from hydpy.core.objecttools import classname
>>> enumeration(('text', 3, []), converter=classname)
'str, int, and list'
Furthermore, you can define a default string that is returned
in case an empty iterable is given:
>>> enumeration((), default='nothing')
'nothing'
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 []'
>>> enumeration(('text', 3))
'text and 3'
>>> enumeration(('text',))
'text'
>>> enumeration(())
''
All given objects are converted to strings by function |str|, as shown
by the first two examples. This behaviour can be changed by another
function expecting a single argument and returning a string:
>>> from hydpy.core.objecttools import classname
>>> enumeration(('text', 3, []), converter=classname)
'str, int, and list'
Furthermore, you can define a default string that is returned
in case an empty iterable is given:
>>> enumeration((), default='nothing')
'nothing'
"""
values = tuple(converter(value) for value in values)
if not values:
return default
if len(values) == 1:
return values[0]
if len(values) == 2:
return ' and '.join(values)
return ', and '.join((', '.join(values[:-1]), values[-1])) |
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.0, 0.0, 1.0, 2.0, 2.0)
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.0, 0.0, 1.0, 2.0, 2.0)
"""
if upper is None:
control = self.subseqs.seqs.model.parameters.control
upper = control.icmax
hland_sequences.State1DSequence.trim(self, lower, upper) |
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
>>> states.sp(-1., 0., 0., 5., 5., 5., 5.)
>>> states.sp
sp(0.0, 0.0, 10.0, 5.0, 5.0, 5.0, 10.0)
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
>>> states.sp(-1., 0., 0., 5., 5., 5., 5.)
>>> states.sp
sp(0.0, 0.0, 10.0, 5.0, 5.0, 5.0, 10.0)
"""
whc = self.subseqs.seqs.model.parameters.control.whc
wc = self.subseqs.wc
if lower is None:
if wc.values is not None:
with numpy.errstate(divide='ignore', invalid='ignore'):
lower = numpy.clip(wc.values / whc.values, 0., numpy.inf)
else:
lower = 0.
hland_sequences.State1DSequence.trim(self, lower, upper) |
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.0, 0.0, 1.0, -1.0, 0.0, 0.5, 1.0)
>>> states.wc
wc(0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5)
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.0, 0.0, 1.0, -1.0, 0.0, 0.5, 1.0)
>>> states.wc
wc(0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5)
"""
whc = self.subseqs.seqs.model.parameters.control.whc
sp = self.subseqs.sp
if (upper is None) and (sp.values is not None):
upper = whc*sp
hland_sequences.State1DSequence.trim(self, lower, upper) |
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)
>>> states.lz
lz(-1.0)
>>> zonetype(FIELD, FOREST)
>>> states.lz(-1.0)
>>> states.lz
lz(0.0)
>>> states.lz(1.0)
>>> states.lz
lz(1.0)
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)
>>> states.lz
lz(-1.0)
>>> zonetype(FIELD, FOREST)
>>> states.lz(-1.0)
>>> states.lz
lz(0.0)
>>> states.lz(1.0)
>>> states.lz
lz(1.0)
"""
if upper is None:
control = self.subseqs.seqs.model.parameters.control
if not any(control.zonetype.values == ILAKE):
lower = 0.
sequencetools.StateSequence.trim(self, lower, upper) |
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.
See the documentation on property |HydPy.conditions| for further
information.
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 NAMES_CONDITIONSEQUENCES:
subseqs = getattr(self, subname, ())
subconditions = {seq.name: copy.deepcopy(seq.values)
for seq in subseqs}
if subconditions:
conditions[subname] = subconditions
return conditions |
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
|ConditionManager| stored in module |pub| are used.
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
|ConditionManager| stored in module |pub| are used.
"""
if self.hasconditions:
if not filename:
filename = self._conditiondefaultfilename
namespace = locals()
for seq in self.conditionsequences:
namespace[seq.name] = seq
namespace['model'] = self
code = hydpy.pub.conditionmanager.load_file(filename)
try:
# ToDo: raises an escape sequence deprecation sometimes
# ToDo: use runpy instead?
# ToDo: Move functionality to filetools.py?
exec(code)
except BaseException:
objecttools.augment_excmessage(
'While trying to gather initial conditions of element %s'
% objecttools.devicename(self)) |
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
|ConditionManager| stored in module |pub| are used.
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
|ConditionManager| stored in module |pub| are used.
"""
if self.hasconditions:
if filename is None:
filename = self._conditiondefaultfilename
con = hydpy.pub.controlmanager
lines = ['# -*- coding: utf-8 -*-\n\n',
'from hydpy.models.%s import *\n\n' % self.model,
'controlcheck(projectdir="%s", controldir="%s")\n\n'
% (con.projectdir, con.currentdir)]
for seq in self.conditionsequences:
lines.append(repr(seq) + '\n')
hydpy.pub.conditionmanager.save_file(filename, ''.join(lines)) |
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.filetools import SequenceManager
>>> pub.sequencemanager = SequenceManager()
We overwrite |FileManager.basepath| and prepare a folder in teh
`iotesting` directory to simplify the following examples:
>>> basepath = SequenceManager.basepath
>>> SequenceManager.basepath = 'test'
>>> TestIO.clear()
>>> import os
>>> with TestIO():
... os.makedirs('test/temp')
Generally, |SequenceManager.tempdirpath| is queried:
>>> from hydpy.core import sequencetools as st
>>> seq = st.InputSequence(None)
>>> with TestIO():
... repr_(seq.dirpath_int)
'test/temp'
Alternatively, you can specify |IOSequence.dirpath_int| for each
sequence object individually:
>>> seq.dirpath_int = 'path'
>>> os.path.split(seq.dirpath_int)
('', 'path')
>>> del seq.dirpath_int
>>> with TestIO():
... os.path.split(seq.dirpath_int)
('test', 'temp')
If neither an individual definition nor |SequenceManager| is
available, the following error is raised:
>>> del pub.sequencemanager
>>> seq.dirpath_int
Traceback (most recent call last):
...
RuntimeError: For sequence `inputsequence` the directory of \
the internal data file cannot be determined. Either set it manually \
or prepare `pub.sequencemanager` correctly.
Remove the `basepath` mock:
>>> SequenceManager.basepath = basepath
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.filetools import SequenceManager
>>> pub.sequencemanager = SequenceManager()
We overwrite |FileManager.basepath| and prepare a folder in teh
`iotesting` directory to simplify the following examples:
>>> basepath = SequenceManager.basepath
>>> SequenceManager.basepath = 'test'
>>> TestIO.clear()
>>> import os
>>> with TestIO():
... os.makedirs('test/temp')
Generally, |SequenceManager.tempdirpath| is queried:
>>> from hydpy.core import sequencetools as st
>>> seq = st.InputSequence(None)
>>> with TestIO():
... repr_(seq.dirpath_int)
'test/temp'
Alternatively, you can specify |IOSequence.dirpath_int| for each
sequence object individually:
>>> seq.dirpath_int = 'path'
>>> os.path.split(seq.dirpath_int)
('', 'path')
>>> del seq.dirpath_int
>>> with TestIO():
... os.path.split(seq.dirpath_int)
('test', 'temp')
If neither an individual definition nor |SequenceManager| is
available, the following error is raised:
>>> del pub.sequencemanager
>>> seq.dirpath_int
Traceback (most recent call last):
...
RuntimeError: For sequence `inputsequence` the directory of \
the internal data file cannot be determined. Either set it manually \
or prepare `pub.sequencemanager` correctly.
Remove the `basepath` mock:
>>> SequenceManager.basepath = basepath
"""
try:
return hydpy.pub.sequencemanager.tempdirpath
except RuntimeError:
raise RuntimeError(
f'For sequence {objecttools.devicephrase(self)} '
f'the directory of the internal data file cannot '
f'be determined. Either set it manually or prepare '
f'`pub.sequencemanager` correctly.') |
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(
'The `numericshape` of a sequence like `%s` depends on the '
'configuration of the actual integration algorithm. '
'While trying to query the required configuration data '
'`nmb_stages` of the model associated with element `%s`'
% (self.name, objecttools.devicename(self)))
# noinspection PyUnboundLocalVariable
numericshape.extend(self.shape)
return tuple(numericshape) |
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.devicephrase(self)} is not requested '
f'to make any internal data available to the user.')
return InfoArray(array, info={'type': 'unmodified'}) |
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 to prepare `pub.sequencemanager` correctly.'
% objecttools.devicephrase(self))
sequencemanager.load_file(self) |
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 only used
for comparison (e.g. observed runoff used for calibration),
incomplete time series might also be helpful. This method it
thought for adjusting such incomplete series to the public
initialization time grid stored in module |pub|. It is
automatically called in method |IOSequence.adjust_series| when
necessary provided that the option |Options.checkseries| is
disabled.
Assume the initialization time period of a HydPy project spans
five day:
>>> from hydpy import pub
>>> pub.timegrids = '2000.01.10', '2000.01.15', '1d'
Prepare a node series object for observational data:
>>> from hydpy.core.sequencetools import Obs
>>> obs = Obs(None)
Prepare a test function that expects the timegrid of the
data and the data itself, which returns the ajdusted array by
means of calling method |IOSequence.adjust_short_series|:
>>> import numpy
>>> def test(timegrid):
... values = numpy.ones(len(timegrid))
... return obs.adjust_short_series(timegrid, values)
The following calls to the test function shows the arrays
returned for different kinds of misalignments:
>>> from hydpy import Timegrid
>>> test(Timegrid('2000.01.05', '2000.01.20', '1d'))
array([ 1., 1., 1., 1., 1.])
>>> test(Timegrid('2000.01.12', '2000.01.15', '1d'))
array([ nan, nan, 1., 1., 1.])
>>> test(Timegrid('2000.01.12', '2000.01.17', '1d'))
array([ nan, nan, 1., 1., 1.])
>>> test(Timegrid('2000.01.10', '2000.01.13', '1d'))
array([ 1., 1., 1., nan, nan])
>>> test(Timegrid('2000.01.08', '2000.01.13', '1d'))
array([ 1., 1., 1., nan, nan])
>>> test(Timegrid('2000.01.12', '2000.01.13', '1d'))
array([ nan, nan, 1., nan, nan])
>>> test(Timegrid('2000.01.05', '2000.01.10', '1d'))
array([ nan, nan, nan, nan, nan])
>>> test(Timegrid('2000.01.05', '2000.01.08', '1d'))
array([ nan, nan, nan, nan, nan])
>>> test(Timegrid('2000.01.15', '2000.01.18', '1d'))
array([ nan, nan, nan, nan, nan])
>>> test(Timegrid('2000.01.16', '2000.01.18', '1d'))
array([ nan, nan, nan, nan, nan])
Through enabling option |Options.usedefaultvalues| the missing
values are initialised with zero instead of nan:
>>> with pub.options.usedefaultvalues(True):
... test(Timegrid('2000.01.12', '2000.01.17', '1d'))
array([ 0., 0., 1., 1., 1.])
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 only used
for comparison (e.g. observed runoff used for calibration),
incomplete time series might also be helpful. This method it
thought for adjusting such incomplete series to the public
initialization time grid stored in module |pub|. It is
automatically called in method |IOSequence.adjust_series| when
necessary provided that the option |Options.checkseries| is
disabled.
Assume the initialization time period of a HydPy project spans
five day:
>>> from hydpy import pub
>>> pub.timegrids = '2000.01.10', '2000.01.15', '1d'
Prepare a node series object for observational data:
>>> from hydpy.core.sequencetools import Obs
>>> obs = Obs(None)
Prepare a test function that expects the timegrid of the
data and the data itself, which returns the ajdusted array by
means of calling method |IOSequence.adjust_short_series|:
>>> import numpy
>>> def test(timegrid):
... values = numpy.ones(len(timegrid))
... return obs.adjust_short_series(timegrid, values)
The following calls to the test function shows the arrays
returned for different kinds of misalignments:
>>> from hydpy import Timegrid
>>> test(Timegrid('2000.01.05', '2000.01.20', '1d'))
array([ 1., 1., 1., 1., 1.])
>>> test(Timegrid('2000.01.12', '2000.01.15', '1d'))
array([ nan, nan, 1., 1., 1.])
>>> test(Timegrid('2000.01.12', '2000.01.17', '1d'))
array([ nan, nan, 1., 1., 1.])
>>> test(Timegrid('2000.01.10', '2000.01.13', '1d'))
array([ 1., 1., 1., nan, nan])
>>> test(Timegrid('2000.01.08', '2000.01.13', '1d'))
array([ 1., 1., 1., nan, nan])
>>> test(Timegrid('2000.01.12', '2000.01.13', '1d'))
array([ nan, nan, 1., nan, nan])
>>> test(Timegrid('2000.01.05', '2000.01.10', '1d'))
array([ nan, nan, nan, nan, nan])
>>> test(Timegrid('2000.01.05', '2000.01.08', '1d'))
array([ nan, nan, nan, nan, nan])
>>> test(Timegrid('2000.01.15', '2000.01.18', '1d'))
array([ nan, nan, nan, nan, nan])
>>> test(Timegrid('2000.01.16', '2000.01.18', '1d'))
array([ nan, nan, nan, nan, nan])
Through enabling option |Options.usedefaultvalues| the missing
values are initialised with zero instead of nan:
>>> with pub.options.usedefaultvalues(True):
... test(Timegrid('2000.01.12', '2000.01.17', '1d'))
array([ 0., 0., 1., 1., 1.])
"""
idxs = [timegrid[hydpy.pub.timegrids.init.firstdate],
timegrid[hydpy.pub.timegrids.init.lastdate]]
valcopy = values
values = numpy.full(self.seriesshape, self.initinfo[0])
len_ = len(valcopy)
jdxs = []
for idx in idxs:
if idx < 0:
jdxs.append(0)
elif idx <= len_:
jdxs.append(idx)
else:
jdxs.append(len_)
valcopy = valcopy[jdxs[0]:jdxs[1]]
zdx1 = max(-idxs[0], 0)
zdx2 = zdx1+jdxs[1]-jdxs[0]
values[zdx1:zdx2] = valcopy
return values |
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.sequencetools import IOSequence
>>> class Seq(IOSequence):
... NDIM = 0
>>> seq = Seq(None)
>>> seq.activate_ram()
>>> seq.check_completeness()
Traceback (most recent call last):
...
RuntimeError: The series array of sequence `seq` contains 10 nan values.
>>> seq.series = 1.0
>>> seq.check_completeness()
>>> seq.series[3] = numpy.nan
>>> seq.check_completeness()
Traceback (most recent call last):
...
RuntimeError: The series array of sequence `seq` contains 1 nan value.
>>> with pub.options.checkseries(False):
... seq.check_completeness()
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.sequencetools import IOSequence
>>> class Seq(IOSequence):
... NDIM = 0
>>> seq = Seq(None)
>>> seq.activate_ram()
>>> seq.check_completeness()
Traceback (most recent call last):
...
RuntimeError: The series array of sequence `seq` contains 10 nan values.
>>> seq.series = 1.0
>>> seq.check_completeness()
>>> seq.series[3] = numpy.nan
>>> seq.check_completeness()
Traceback (most recent call last):
...
RuntimeError: The series array of sequence `seq` contains 1 nan value.
>>> with pub.options.checkseries(False):
... seq.check_completeness()
"""
if hydpy.pub.options.checkseries:
isnan = numpy.isnan(self.series)
if numpy.any(isnan):
nmb = numpy.sum(isnan)
valuestring = 'value' if nmb == 1 else 'values'
raise RuntimeError(
f'The series array of sequence '
f'{objecttools.devicephrase(self)} contains '
f'{nmb} nan {valuestring}.') |
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 to prepare `pub.sequencemanager` correctly.'
% objecttools.devicephrase(self))
sequencemanager.save_file(self) |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.