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 check_var(self, *args, **kwargs):
if not self.enable:
return
super().check_var()
if self.n_select is not None and self.n_select > 0:
asc = np.argsort(self.u.v - self.lower.v) # ascending order
desc = np.argsort(self.upper.v - self.u.v)
lowest_n = asc[:self.n_select]
highest_n = desc[:self.n_select]
reset_in = np.ones(self.u.v.shape)
reset_in[lowest_n] = 0
reset_in[highest_n] = 0
reset_out = 1 - reset_in
self.zi[:] = np.logical_or(reset_in, self.zi)
self.zl[:] = np.logical_and(reset_out, self.zl)
self.zu[:] = np.logical_and(reset_out, self.zu)