def add(self, value=None): """ Add a new parameter value (from a new device of the owner model) to the ``v`` list. Parameters ---------- value : str or float, optional Parameter value of the new element. If None, the default will be used. Notes ----- If the value is ``math.nan``, it will set to ``None``. """ if isinstance(value, float) and math.isnan(value): value = None # check for mandatory if value is None: if self.get_property('mandatory'): raise ValueError( f'Mandatory parameter {self.name} for {self.owner.class_name} missing' ) else: value = self.default if isinstance(self.v, list): self.v.append(value) else: np.append(self.v, value)
def store_switch_times(self, models, eps=1e-4): """ Store event switching time in a sorted Numpy array in ``System.switch_times`` and an OrderedDict ``System.switch_dict``. ``System.switch_dict`` has keys as event times and values as the OrderedDict of model names and instances associated with the event. Parameters ---------- models : OrderedDict model name : model instance eps : float The small time step size to use immediately before and after the event Returns ------- array-like self.switch_times """ out = np.array([], dtype=np.float) if self.options.get('flat') is True: return out names = [] for instance in models.values(): times = np.array(instance.get_times()).ravel() out = np.append(out, times) out = np.append(out, times - eps) out = np.append(out, times + eps) names.extend([instance.class_name] * (3 * len(times))) # sort sort_idx = np.argsort(out).astype(int) out = out[sort_idx] names = [names[i] for i in sort_idx] # select t > current time ltzero_idx = np.where(out >= self.dae.t)[0] out = out[ltzero_idx] names = [names[i] for i in ltzero_idx] # make into an OrderedDict with unique keys and model names combined for i, j in zip(out, names): if i not in self.switch_dict: self.switch_dict[i] = {j: self.models[j]} else: self.switch_dict[i].update({j: self.models[j]}) self.switch_times = np.array(list(self.switch_dict.keys())) # self.switch_times = out self.n_switches = len(self.switch_times) return self.switch_times
def resize_array(self): """ Resize arrays to the new `m` and `n` Returns ------- """ self.x = np.append(self.x, np.zeros(self.n - len(self.x))) self.y = np.append(self.y, np.zeros(self.m - len(self.y))) self.z = np.append(self.z, np.zeros(self.o - len(self.z))) self.f = np.append(self.f, np.zeros(self.n - len(self.f))) self.g = np.append(self.g, np.zeros(self.m - len(self.g)))
def _extend_or_slice(self, array, new_size, fill_func=np.zeros): """ Helper function for ``self.resize_arrays`` to grow or shrink arrays. """ if new_size > len(array): array = np.append(array, fill_func(new_size - len(array))) else: array = array[0:new_size] return array
def _extend_or_slice(self, array, new_size, fill_func=np.zeros): """ Helper function for ``self.resize_arrays`` to grow or shrink arrays. TODO: BUG FIX The extended array will have new addresses so that in-place v and e will not gain memory access to the new one. """ if new_size > len(array): array = np.append(array, fill_func(new_size - len(array))) else: array = array[0:new_size] return array
def store_switch_times(self, models): """ Store event switching time in a sorted Numpy array at ``System.switch_times``. Returns ------- array-like self.switch_times """ out = [] for instance in models.values(): out.extend(instance.get_times()) out = np.ravel(np.array(out)) out = np.append(out, out - 1e-4) out = np.append(out, out + 1e-4) out = np.unique(out) out = out[np.where(out >= 0)] out = np.sort(out) self.switch_times = out self.n_switches = len(self.switch_times) return self.switch_times
def check_var(self, dae_t, *args, **kwargs): # Storage: # Output values is in the first col. # Latest values are stored in /appended to the last column self.rewind = False if dae_t == 0: self._v_mem[:] = self.u.v[:, None] elif dae_t < self.t[-1]: self.rewind = True self.t[-1] = dae_t self._v_mem[:, -1] = self.u.v elif dae_t == self.t[-1]: self._v_mem[:, -1] = self.u.v elif dae_t > self.t[-1]: if self.mode == 'step': self.t[:-1] = self.t[1:] self.t[-1] = dae_t self._v_mem[:, :-1] = self._v_mem[:, 1:] self._v_mem[:, -1] = self.u.v else: self.t = np.append(self.t, dae_t) self._v_mem = np.hstack((self._v_mem, self.u.v[:, None])) if dae_t - self.t[0] > self.delay: t_interp = dae_t - self.delay idx = np.argmax(self.t >= t_interp) - 1 v_interp = interp_n2(t_interp, self.t[idx:idx + 2], self._v_mem[:, idx:idx + 2]) self.t[idx] = t_interp self._v_mem[:, idx] = v_interp self.t = np.delete(self.t, np.arange(0, idx)) self._v_mem = np.delete(self._v_mem, np.arange(0, idx), axis=1) self.v[:] = self._v_mem[:, 0]
def add(self, value=None): """ Add a new parameter value (from a new device of the owner model) to the ``v`` list. Parameters ---------- value : str or float, optional Parameter value of the new element. If None, the default will be used. Notes ----- If the value is ``math.nan``, it will set to ``None``. """ value = self._sanitize(value) if isinstance(self.v, list): self.v.append(value) else: self.v = np.append(self.v, value)