def update_ma_coefs(self): """Determine the MA coefficients. The number of MA coefficients is subsequently increased until the required precision :attr:`~ARMA.max_dev_coefs` is reached. Otherwise, a :class:`~exceptions.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: raise RuntimeError( 'Method `update_ma_coefs` is not able to determine the MA ' 'coefficients of the ARMA model with the desired accuracy. ' 'You can set the tolerance value ´max_dev_coefs` to a ' 'higher value. An accuracy of `%s` has been reached using ' '`%d` MA coefficients.' % (objecttools.repr_(self.dev_coefs, 12), ma_order)) if numpy.min(self.response) < 0.: warnings.warn( 'Note that the smallest response to a standard impulse of the ' 'determined ARMA model is negative (`%s`).' % objecttools.repr_(numpy.min(self.response)))
def raw_body_strings(self): """All raw strings for the tables body.""" strings = [] for (idx, first_string) in enumerate(self.raw_first_col_strings): strings.append([first_string]) for parseq in self.parseqs: array = self.get_output_array(parseq) if parseq.NDIM == 0: strings[-1].append(objecttools.repr_(array[idx])) elif parseq.NDIM == 1: if parseq.shape[0] > 0: strings[-1].extend( objecttools.repr_(value) for value in array[idx]) else: strings[-1].append('empty') else: thing = ('sequence' if isinstance( parseq, abctools.SequenceABC) else 'parameter') raise RuntimeError( 'An instance of class `Test` of module `testtools` ' 'is requested to print the results of %s `%s`. ' 'Unfortunately, for %d-dimensional sequences this ' 'feature is not supported yet.' % (thing, parseq.name, parseq.NDIM)) return strings
def _print_results(self): strings = [['date'] + [ seq.subseqs.node.name if seq.name == 'sim' else seq.name for seq in self.seqs ]] lengths = numpy.zeros((len(pub.timegrids.sim) + 1, len(self.seqs) + 1), dtype=int) lengths[0, :] = [len(string) for string in strings[0]] for (idx, date) in enumerate(pub.timegrids.sim): strings.append([date.datetime.strftime(self.dateformat)]) for seq in self.seqs: if seq.NDIM == 0: strings[-1].append(objecttools.repr_(seq.series[idx])) elif seq.NDIM == 1 and seq.shape == (1, ): strings[-1].append(objecttools.repr_(seq.series[idx, 0])) else: raise RuntimeError( 'An instance of class `Test` of module `testtools` ' 'is requested to print the results of sequence `%s`. ' 'Unfortunately, for %d-dimensional sequences with ' 'shape `%s` this feature is not supported yet.' % (seq.name, seq.NDIM, seq.shape)) lengths[idx + 1, :] = [len(string) for string in strings[-1]] maxlengths = numpy.max(lengths, axis=0) for (idx, linestrings) in enumerate(strings): print( '|', ' | '.join( string.rjust(maxlengths[jdx]) for (jdx, string) in enumerate(linestrings)), '|') if idx == 0: print('-' * (numpy.sum(maxlengths) + 3 * (len(self.seqs)) + 4))
def raw_body_strings(self): """All raw strings for the tables body.""" strings = [] for (idx, first_string) in enumerate(self.raw_first_col_strings): strings.append([first_string]) for parseq in self.parseqs: array = self.get_output_array(parseq) if parseq.NDIM == 0: strings[-1].append(objecttools.repr_(array[idx])) else: strings[-1].extend( objecttools.repr_(value) for value in array[idx]) return strings
def __call__(self, *args, **kwargs): """The prefered way to pass values to |TInd| instances within parameter control files. """ try: super().__call__(*args, **kwargs) except NotImplementedError: try: tal = float(kwargs['tal']) hot = float(kwargs['hot']) hut = float(kwargs['hut']) except KeyError: raise ValueError( 'For the alternative calculation of parameter `tind`, ' 'values for all three keyword keyword arguments `tal`, ' '`hot`, and `hut` must be given.') if (tal <= 0.) or (hot <= hut): raise ValueError( 'For the alternative calculation of parameter ' '`tind`, the value assigned to keyword argument ' '`tal` must be greater then zero and the one of ' '`hot` must be greater than the one of `hut`. ' 'However, for element %s, the values `%s`, `%s` ' 'and `%s` were given respectively.' % (objecttools.devicename(self), tal, hot, hut)) self.value = (.868 * tal**3 / (hot - hut))**.385 if (self > 1000.) or (self < .001): warnings.warn( 'Due to the given values for the keyword arguments ' '`tal` (%s), `hot` (%s) and `hut` (%s), parameter ' '`tind` of element `%s` has been set to an ' 'unrealistic value of `%s hours`.' % (tal, hot, hut, objecttools.devicename(self), objecttools.repr_(self.value))) self.value *= timetools.Period('1h') / self.simulationstep
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.0: warnings.warn( "Note that the smallest response to a standard impulse of the " "determined ARMA model is negative (`%s`)." % objecttools.repr_(numpy.min(self.response)))
def yield_name2value(self, idx1=None, idx2=None) -> Iterator[Tuple[str, str]]: """Sequentially return name-value-pairs describing the current state of the target variables. The names are automatically generated and contain both the name of the |Device| of the respective |Variable| object and the target description: >>> from hydpy.examples import prepare_full_example_2 >>> hp, pub, TestIO = prepare_full_example_2() >>> from hydpy.core.itemtools import SetItem >>> item = GetItem("hland_v1", "states.lz") >>> item.collect_variables(pub.selections) >>> hp.elements.land_dill.model.sequences.states.lz = 100.0 >>> for name, value in item.yield_name2value(): ... print(name, value) land_dill_states_lz 100.0 land_lahn_1_states_lz 8.18711 land_lahn_2_states_lz 10.14007 land_lahn_3_states_lz 7.52648 >>> item = GetItem("hland_v1", "states.sm") >>> item.collect_variables(pub.selections) >>> hp.elements.land_dill.model.sequences.states.sm = 2.0 >>> for name, value in item.yield_name2value(): ... print(name, value) # doctest: +ELLIPSIS land_dill_states_sm [2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, \ 2.0, 2.0, 2.0, 2.0] land_lahn_1_states_sm [99.27505, ..., 142.84148] ... When querying time series, one can restrict the span of interest by passing index values: >>> item = GetItem("nodes", "sim.series") >>> item.collect_variables(pub.selections) >>> hp.nodes.dill.sequences.sim.series = 1.0, 2.0, 3.0, 4.0 >>> for name, value in item.yield_name2value(): ... print(name, value) # doctest: +ELLIPSIS dill_sim_series [1.0, 2.0, 3.0, 4.0] lahn_1_sim_series [nan, ... ... >>> for name, value in item.yield_name2value(2, 3): ... print(name, value) # doctest: +ELLIPSIS dill_sim_series [3.0] lahn_1_sim_series [nan] ... """ for device, name in self._device2name.items(): target = self.device2target[device] if self.targetspecs.series: values = target.series[idx1:idx2] else: values = target.values if self.ndim == 0: values = objecttools.repr_(float(values)) else: values = objecttools.repr_list(values.tolist()) yield name, values
def __repr__(self) -> str: parts = [type(self).__name__, "("] for (name, primpar) in sorted(self._PRIMARY_PARAMETERS.items()): value = primpar.__get__(self) if value is not None: parts.extend([name, "=", objecttools.repr_(value), ", "]) if parts[-1] == ", ": parts[-1] = ")" else: parts.append(")") return "".join(parts)
def __repr__(self): parts = [objecttools.classname(self), '('] for (name, primpar) in sorted(self._primary_parameters.items()): value = primpar.__get__(self) if value is not None: parts.extend([name, '=', objecttools.repr_(value), ', ']) if parts[-1] == ', ': parts[-1] = ')' else: parts.append(')') return ''.join(parts)
def repr_(self, values, islong): prefix = '%s(' % self.name if self.NDIM == 0: string = '%s(%s)' % (self.name, objecttools.repr_(values)) elif self.NDIM == 1: if islong: string = objecttools.assignrepr_list(values, prefix, 75) + ')' else: string = objecttools.assignrepr_values( values, prefix, 75) + ')' elif self.NDIM == 2: string = objecttools.assignrepr_list2(values, prefix, 75) + ')' else: raise NotImplementedError( '`repr` does not yet support parameters or sequences like `%s`' 'of element `%s` which handle %d-dimensional matrices.' % self.NDIM) return '\n'.join(self.commentrepr() + [string])
def update_ar_coefs(self): """Determine the AR coefficients. The number of AR coefficients is subsequently increased until the required precision :attr:`~ARMA.max_rel_rmse` is reached. Otherwise, a :class:`~exceptions.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: raise RuntimeError( 'Method `update_ar_coefs` is not able to determine the AR ' 'coefficients of the ARMA model with the desired accuracy. ' 'You can either set the tolerance value `max_rel_rmse` to ' 'a higher value or increase the allowed `max_ar_order`. ' 'An accuracy of `%s` has been reached using `%d` coefficients.' % (objecttools.repr_(self.rel_rmse, 12), ar_order))
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 pub.options.reprdigits(12): raise RuntimeError( 'Method `update_ar_coefs` is not able to determine ' 'the AR coefficients of the ARMA model with the desired ' 'accuracy. You can either set the tolerance value ' '`max_rel_rmse` to a higher value or increase the ' 'allowed `max_ar_order`. An accuracy of `%s` has been ' 'reached using `%d` coefficients.' % (objecttools.repr_(self._rel_rmse), ar_order))