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)
