def __init__(self,
connectivity,
default_model=None,
default_integrator=None,
compute_phase_plane_params=True):
self.logger = get_logger(self.__class__.__module__)
self.default_model = default_model
self.default_integrator = default_integrator
self.connectivity = connectivity
self.connectivity_models = dict()
if self.default_model is None:
self.default_model = models_module.Generic2dOscillator()
if self.default_integrator is None:
self.default_integrator = integrators_module.RungeKutta4thOrderDeterministic(
)
self.model_parameter_names = deepcopy(
self.default_model.ui_configurable_parameters)
if not len(self.model_parameter_names):
self.logger.warning(
"The 'ui_configurable_parameters' list of the current model is empty!"
)
self.prepared_model_parameter_names = self._prepare_parameter_names(
self.model_parameter_names)
model = self._get_model_for_region(0)
if compute_phase_plane_params:
self._phase_plane = PhasePlaneInteractive(
deepcopy(model), deepcopy(self.default_integrator))
self.phase_plane_params = self._phase_plane.draw_phase_plane()
def __init__(self, connectivity, default_model = None, default_integrator = None):
self.logger = get_logger(self.__class__.__module__)
self.default_model = default_model
self.default_integrator = default_integrator
self.connectivity = connectivity
self.connectivity_models = dict()
if self.default_model is None:
self.default_model = models_module.Generic2dOscillator()
if self.default_integrator is None:
self.default_integrator = integrators_module.RungeKutta4thOrderDeterministic()
self.model_parameter_names = deepcopy(self.default_model.ui_configurable_parameters)
if not len(self.model_parameter_names):
self.logger.warning("The 'ui_configurable_parameters' list of the current model is empty!")
def pplane(self, **kwargs):
"""
Generate and plot a phase-plane diagram. Initial state of all the state
variables, other than the two specified for the phase-plane, are
randomly set once for the entire phase-plane based on the initial()
method of the chosen model. In other words, running multiple times will
give slightly different results, but they will all lie within the range
of default initial conditions...
**kwargs**:
``xlo``
``xhi``
``ylo``
``yhi``
``npts``
``phase-plane``
"""
for key in kwargs:
setattr(self, key, kwargs[key])
#import pdb; pdb.set_trace()
if self.xlo is None:
self.xlo = numpy.array([self.model.state_variable_range[self.model.state_variables[indx]][0] for indx in self.phase_plane[0]]) #self.model.state_variable_range[0][self.phase_plane[0]]
if self.xhi is None:
self.xhi = numpy.array([self.model.state_variable_range[self.model.state_variables[indx]][1] for indx in self.phase_plane[0]]) #self.model.state_variable_range[1][self.phase_plane[0]]
if self.ylo is None:
self.ylo = numpy.array([self.model.state_variable_range[self.model.state_variables[indx]][0] for indx in self.phase_plane[1]]) #self.model.state_variable_range[0][self.phase_plane[1]]
if self.yhi is None:
self.yhi = numpy.array([self.model.state_variable_range[self.model.state_variables[indx]][1] for indx in self.phase_plane[1]]) #self.model.state_variable_range[1][self.phase_plane[1]]
init_cond = self.initial(history_shape=(1, self.model.nvar, 1, self.model.number_of_modes))
init_cond = init_cond.reshape((self.model.nvar, 1, self.model.number_of_modes))
no_coupling = numpy.zeros(init_cond.shape)
#import pdb; pdb.set_trace()
#Calculate an example trajectory
state = init_cond.copy()
rk4 = integrators.RungeKutta4thOrderDeterministic(dt=2**-5)
traj = numpy.zeros((self.int_steps, self.model.nvar, 1, self.model.number_of_modes))
for step in range(self.int_steps):
state = rk4.scheme(state, self.dfun)
traj[step, :] = state
npp = len(self.phase_plane[0])
for hh in range(npp):
#Calculate the vector field discretely sampled at a grid of points
grid_point = init_cond.copy()
X = numpy.mgrid[self.xlo[hh]:self.xhi[hh]:(self.npts*1j)]
Y = numpy.mgrid[self.ylo[hh]:self.yhi[hh]:(self.npts*1j)]
U = numpy.zeros((self.npts, self.npts, self.model.number_of_modes, npp))
V = numpy.zeros((self.npts, self.npts, self.model.number_of_modes, npp))
for ii in xrange(self.npts):
grid_point[self.phase_plane[1, hh]] = Y[ii]
for jj in xrange(self.npts):
#import pdb; pdb.set_trace()
grid_point[self.phase_plane[0, hh]] = X[jj]
d = self.dfun(grid_point, no_coupling)
for kk in range(self.model.number_of_modes):
U[ii, jj, kk, hh] = d[self.phase_plane[0, hh], 0, kk]
V[ii, jj, kk, hh] = d[self.phase_plane[1, hh], 0, kk]
# Plot it, and save the figures to files...
for kk in range(self.model.number_of_modes):
#Create a plot window with a title
pyplot.figure(10 * hh + kk)
model_class_name = self.model.__class__.__name__
pyplot.title(model_class_name + " mode " + str(kk+1))
pyplot.xlabel("State Variable " + str(self.model.state_variables[self.phase_plane[0, hh]]))
pyplot.ylabel("State Variable " + str(self.model.state_variables[self.phase_plane[1, hh]]))
#Plot a discrete representation of the vector field
pyplot.quiver(X, Y, U[:, :, kk, hh], V[:, :, kk, hh],
width=0.0005, headwidth=8)
#Plot the nullclines
pyplot.contour(X, Y, U[:, :, kk, hh], [0], colors="r")
pyplot.contour(X, Y, V[:, :, kk, hh], [0], colors="g")
#Add an example trajectory to the on screen version of the phase-plane
pyplot.plot(traj[:, self.phase_plane[0, hh], 0, kk],
traj[:, self.phase_plane[1, hh], 0, kk])
#Save this phase-plane plot to as an .png file (change to .svg when it's working...)
pyplot.savefig("img/" + model_class_name + "_" +
str(self.phase_plane[0, hh]) + str(self.phase_plane[1, hh]) +
"_mode_" + str(kk) + "_pplane" + IMG_SUFFIX)
pyplot.close("all")
def test_rk4(self):
rk4 = integrators.RungeKutta4thOrderDeterministic()
assert rk4.dt == dt
self._test_scheme(rk4)
class PhasePlaneInteractive(HasTraits):
"""
The GUI for the interactive phase-plane viewer provides sliders for setting:
- The value of all parameters of the Model.
- The extent of the axes.
- A fixed value for the state-variables which aren't currently selected.
- The noise strength, if a stocahstic integrator is specified.
and radio buttons for selecting:
- Which state-variables to show on each axis.
- Which mode to show, if the Model has them.
Clicking on the phase-plane will generate a sample trajectory, originating
from where you clicked.
"""
model = Attr(
field_type=models_module.Model,
label="Model",
default=models_module.Generic2dOscillator(),
doc="""An instance of the local dynamic model to be investigated with
PhasePlaneInteractive.""")
integrator = Attr(
field_type=integrators_module.Integrator,
label="Integrator",
default=integrators_module.RungeKutta4thOrderDeterministic(),
doc="""The integration scheme used to for generating sample
trajectories on the phase-plane. NOTE: This is not used for generating
the phase-plane itself, ie the vector field and nulclines.""")
exclude_sliders = List(of=str)
def __init__(self, **kwargs):
"""
Initialise based on provided keywords or their traited defaults. Also,
initialise the place-holder attributes that aren't filled until the
show() method is called.
"""
super(PhasePlaneInteractive, self).__init__(**kwargs)
LOG.debug(str(kwargs))
#figure
self.ipp_fig = None
#phase-plane
self.pp_ax = None
self.X = None
self.Y = None
self.U = None
self.V = None
self.UVmag = None
self.nullcline_x = None
self.nullcline_y = None
self.pp_quivers = None
#Current state
self.svx = None
self.svy = None
self.default_sv = None
self.no_coupling = None
self.mode = None
#Selectors
self.state_variable_x = None
self.state_variable_y = None
self.mode_selector = None
#Sliders
self.param_sliders = None
self.axes_range_sliders = None
self.sv_sliders = None
self.noise_slider = None
#Reset buttons
self.reset_param_button = None
self.reset_sv_button = None
self.reset_axes_button = None
self.reset_noise_button = None
self.reset_seed_button = None
def show(self):
""" Generate the interactive phase-plane figure. """
model_name = self.model.__class__.__name__
msg = "Generating an interactive phase-plane plot for %s"
LOG.info(msg % model_name)
#Make sure the model is fully configured...
self.model.configure()
#Setup the inital(current) state
try:
self.svx = self.model.state_variables[
0] #x-axis: 1st state variable
self.svy = self.model.state_variables[
1] #y-axis: 2nd state variable
except:
import pdb
pdb.set_trace()
self.svx = self.model.state_variables[
'S1'] #x-axis: 1st state variable
self.svy = self.model.state_variables[
'S2'] #y-axis: 2nd state variable
self.mode = 0
self.set_state_vector()
#Make the figure:
self.create_figure()
#Selectors
self.add_state_variable_selector()
self.add_mode_selector()
#Sliders
self.add_axes_range_sliders()
self.add_state_variable_sliders()
self.add_param_sliders()
if isinstance(self.integrator,
integrators_module.IntegratorStochastic):
if self.integrator.noise.ntau > 0.0:
self.integrator.noise.configure_coloured(
self.integrator.dt,
(1, self.model.nvar, 1, self.model.number_of_modes))
else:
self.integrator.noise.configure_white(
self.integrator.dt,
(1, self.model.nvar, 1, self.model.number_of_modes))
self.add_noise_slider()
self.add_reset_noise_button()
self.add_reset_seed_button()
#Reset buttons
self.add_reset_param_button()
self.add_reset_sv_button()
self.add_reset_axes_button()
#Calculate the phase plane
self.set_mesh_grid()
self.calc_phase_plane()
#Plot phase plane
self.plot_phase_plane()
# add mouse handler for trajectory clicking
self.ipp_fig.canvas.mpl_connect('button_press_event',
self.click_trajectory)
#import pdb; pdb.set_trace()
pylab.show()
##------------------------------------------------------------------------##
##----------------- Functions for building the figure --------------------##
##------------------------------------------------------------------------##
def create_figure(self):
""" Create the figure and phase-plane axes. """
#Figure and main phase-plane axes
model_name = self.model.__class__.__name__
integrator_name = self.integrator.__class__.__name__
figsize = 10, 5
try:
figure_window_title = "Interactive phase-plane: " + model_name
figure_window_title += " -- %s" % integrator_name
self.ipp_fig = pylab.figure(num=figure_window_title,
figsize=figsize,
facecolor=BACKGROUNDCOLOUR,
edgecolor=EDGECOLOUR)
except ValueError:
LOG.info("My life would be easier if you'd update your PyLab...")
self.ipp_fig = pylab.figure(num=42,
figsize=figsize,
facecolor=BACKGROUNDCOLOUR,
edgecolor=EDGECOLOUR)
self.pp_ax = self.ipp_fig.add_axes([0.265, 0.2, 0.5, 0.75])
self.pp_splt = self.ipp_fig.add_subplot(212)
self.ipp_fig.subplots_adjust(left=0.265,
bottom=0.02,
right=0.765,
top=0.3,
wspace=0.1,
hspace=None)
self.pp_splt.set_prop_cycle(color=get_color(self.model.nvar))
self.pp_splt.plot(
numpy.arange(TRAJ_STEPS + 1) * self.integrator.dt,
numpy.zeros((TRAJ_STEPS + 1, self.model.nvar)))
if hasattr(self.pp_splt, 'autoscale'):
self.pp_splt.autoscale(enable=True, axis='y', tight=True)
self.pp_splt.legend(self.model.state_variables)
def add_state_variable_selector(self):
"""
Generate radio selector buttons to set which state variable is displayed
on the x and y axis of the phase-plane plot.
"""
svx_ind = self.model.state_variables.index(self.svx)
svy_ind = self.model.state_variables.index(self.svy)
#State variable for the x axis
pos_shp = [0.07, 0.05, 0.065, 0.12 + 0.006 * self.model.nvar]
rax = self.ipp_fig.add_axes(pos_shp,
facecolor=AXCOLOUR,
title="x-axis")
self.state_variable_x = widgets.RadioButtons(
rax, tuple(self.model.state_variables), active=svx_ind)
self.state_variable_x.on_clicked(self.update_svx)
#State variable for the y axis
pos_shp = [0.14, 0.05, 0.065, 0.12 + 0.006 * self.model.nvar]
rax = self.ipp_fig.add_axes(pos_shp,
facecolor=AXCOLOUR,
title="y-axis")
self.state_variable_y = widgets.RadioButtons(
rax, tuple(self.model.state_variables), active=svy_ind)
self.state_variable_y.on_clicked(self.update_svy)
def add_mode_selector(self):
"""
Add a radio button to the figure for selecting which mode of the model
should be displayed.
"""
pos_shp = [0.02, 0.07, 0.04, 0.1 + 0.002 * self.model.number_of_modes]
rax = self.ipp_fig.add_axes(pos_shp, facecolor=AXCOLOUR, title="Mode")
mode_tuple = tuple(range(self.model.number_of_modes))
self.mode_selector = widgets.RadioButtons(rax, mode_tuple, active=0)
self.mode_selector.on_clicked(self.update_mode)
def add_axes_range_sliders(self):
"""
Add sliders to the figure to allow the phase-planes axes to be set.
"""
self.axes_range_sliders = dict()
default_range_x = (self.model.state_variable_range[self.svx][1] -
self.model.state_variable_range[self.svx][0])
default_range_y = (self.model.state_variable_range[self.svy][1] -
self.model.state_variable_range[self.svy][0])
min_val_x = self.model.state_variable_range[
self.svx][0] - 4.0 * default_range_x
max_val_x = self.model.state_variable_range[
self.svx][1] + 4.0 * default_range_x
min_val_y = self.model.state_variable_range[
self.svy][0] - 4.0 * default_range_y
max_val_y = self.model.state_variable_range[
self.svy][1] + 4.0 * default_range_y
sax = self.ipp_fig.add_axes([0.04, 0.835, 0.125, 0.025],
facecolor=AXCOLOUR)
sl_x_min = widgets.Slider(
sax,
"xlo",
min_val_x,
max_val_x,
valinit=self.model.state_variable_range[self.svx][0])
sl_x_min.on_changed(self.update_range)
sax = self.ipp_fig.add_axes([0.04, 0.8, 0.125, 0.025],
facecolor=AXCOLOUR)
sl_x_max = widgets.Slider(
sax,
"xhi",
min_val_x,
max_val_x,
valinit=self.model.state_variable_range[self.svx][1])
sl_x_max.on_changed(self.update_range)
sax = self.ipp_fig.add_axes([0.04, 0.765, 0.125, 0.025],
facecolor=AXCOLOUR)
sl_y_min = widgets.Slider(
sax,
"ylo",
min_val_y,
max_val_y,
valinit=self.model.state_variable_range[self.svy][0])
sl_y_min.on_changed(self.update_range)
sax = self.ipp_fig.add_axes([0.04, 0.73, 0.125, 0.025],
facecolor=AXCOLOUR)
sl_y_max = widgets.Slider(
sax,
"yhi",
min_val_y,
max_val_y,
valinit=self.model.state_variable_range[self.svy][1])
sl_y_max.on_changed(self.update_range)
self.axes_range_sliders["sl_x_min"] = sl_x_min
self.axes_range_sliders["sl_x_max"] = sl_x_max
self.axes_range_sliders["sl_y_min"] = sl_y_min
self.axes_range_sliders["sl_y_max"] = sl_y_max
def add_state_variable_sliders(self):
"""
Add sliders to the figure to allow default values for the models state
variable to be set.
"""
msv_range = self.model.state_variable_range
offset = 0.0
self.sv_sliders = dict()
for sv in range(self.model.nvar):
offset += 0.035
pos_shp = [0.04, 0.6 - offset, 0.125, 0.025]
sax = self.ipp_fig.add_axes(pos_shp, facecolor=AXCOLOUR)
sv_str = self.model.state_variables[sv]
self.sv_sliders[sv_str] = widgets.Slider(
sax,
sv_str,
msv_range[sv_str][0],
msv_range[sv_str][1],
valinit=self.default_sv[sv, 0, 0])
self.sv_sliders[sv_str].on_changed(self.update_state_variables)
# Traited paramaters as sliders
def add_param_sliders(self):
"""
Add sliders to the figure to allow the models parameters to be set.
"""
offset = 0.0
self.param_sliders = dict()
# import pdb; pdb.set_trace()
for param_name in type(self.model).declarative_attrs:
if self.exclude_sliders is not None and param_name in self.exclude_sliders:
continue
param_def = getattr(type(self.model), param_name)
if not isinstance(param_def,
NArray) or not param_def.dtype == numpy.float:
continue
param_range = param_def.domain
if param_range is None:
continue
offset += 0.035
sax = self.ipp_fig.add_axes([0.825, 0.865 - offset, 0.125, 0.025],
facecolor=AXCOLOUR)
param_value = getattr(self.model, param_name)[0]
self.param_sliders[param_name] = widgets.Slider(
sax,
param_name,
param_range.lo,
param_range.hi,
valinit=param_value)
self.param_sliders[param_name].on_changed(self.update_parameters)
def add_noise_slider(self):
"""
Add a slider to the figure to allow the integrators noise strength to
be set.
"""
pos_shp = [0.825, 0.1, 0.125, 0.025]
sax = self.ipp_fig.add_axes(pos_shp, facecolor=AXCOLOUR)
self.noise_slider = widgets.Slider(sax,
"Log Noise",
-9.0,
1.0,
valinit=self.integrator.noise.nsig)
self.noise_slider.on_changed(self.update_noise)
def add_reset_param_button(self):
"""
Add a button to the figure for reseting the model parameter values to
their original values.
"""
bax = self.ipp_fig.add_axes([0.825, 0.865, 0.125, 0.04])
self.reset_param_button = widgets.Button(bax,
'Reset parameters',
color=BUTTONCOLOUR,
hovercolor=HOVERCOLOUR)
def reset_parameters(event):
for param_slider in self.param_sliders:
self.param_sliders[param_slider].reset()
self.reset_param_button.on_clicked(reset_parameters)
def add_reset_sv_button(self):
"""
Add a button to the figure for reseting the model state variables to
their default values.
"""
bax = self.ipp_fig.add_axes([0.04, 0.60, 0.125, 0.04])
self.reset_sv_button = widgets.Button(bax,
'Reset state-variables',
color=BUTTONCOLOUR,
hovercolor=HOVERCOLOUR)
def reset_state_variables(event):
for svsl in self.sv_sliders.values():
svsl.reset()
self.reset_sv_button.on_clicked(reset_state_variables)
def add_reset_noise_button(self):
"""
Add a button to the figure for reseting the noise to its default value.
"""
bax = self.ipp_fig.add_axes([0.825, 0.135, 0.125, 0.04])
self.reset_noise_button = widgets.Button(bax,
'Reset noise strength',
color=BUTTONCOLOUR,
hovercolor=HOVERCOLOUR)
def reset_noise(event):
self.noise_slider.reset()
self.reset_noise_button.on_clicked(reset_noise)
def add_reset_seed_button(self):
"""
Add a button to the figure for reseting the random number generator to
its intial state. For reproducible noise...
"""
bax = self.ipp_fig.add_axes([0.825, 0.05, 0.125, 0.04])
self.reset_seed_button = widgets.Button(bax,
'Reset random stream',
color=BUTTONCOLOUR,
hovercolor=HOVERCOLOUR)
def reset_seed(event):
self.integrator.noise.trait["random_stream"].reset()
self.reset_seed_button.on_clicked(reset_seed)
def add_reset_axes_button(self):
"""
Add a button to the figure for reseting the phase-plane axes to their
default ranges.
"""
bax = self.ipp_fig.add_axes([0.04, 0.87, 0.125, 0.04])
self.reset_axes_button = widgets.Button(bax,
'Reset axes',
color=BUTTONCOLOUR,
hovercolor=HOVERCOLOUR)
def reset_ranges(event):
self.axes_range_sliders["sl_x_min"].reset()
self.axes_range_sliders["sl_x_max"].reset()
self.axes_range_sliders["sl_y_min"].reset()
self.axes_range_sliders["sl_y_max"].reset()
self.reset_axes_button.on_clicked(reset_ranges)
##------------------------------------------------------------------------##
##------------------- Functions for updating the figure ------------------##
##------------------------------------------------------------------------##
#NOTE: All the ax.set_xlim, poly.xy, etc, garbage below is fragile. It works
# at the moment, but there are currently bugs in Slider and the hackery
# below takes these into account... If the bugs are fixed/changed then
# this could break. As an example, the Slider doc says poly is a
# Rectangle, but it's actually a Polygon. The Slider set_val method
# assumes a Rectangle even though this is not the case, so the array
# Slider.poly.xy is corrupted by that method. The corruption isn't
# visible in the plot, which is probably why it hasn't been fixed...
def update_xrange_sliders(self):
"""
A hacky update of the x-axis range sliders that is called when the
state-variable selected for the x-axis is changed.
"""
default_range_x = (self.model.state_variable_range[self.svx][1] -
self.model.state_variable_range[self.svx][0])
min_val_x = self.model.state_variable_range[
self.svx][0] - 4.0 * default_range_x
max_val_x = self.model.state_variable_range[
self.svx][1] + 4.0 * default_range_x
self.axes_range_sliders[
"sl_x_min"].valinit = self.model.state_variable_range[self.svx][0]
self.axes_range_sliders["sl_x_min"].valmin = min_val_x
self.axes_range_sliders["sl_x_min"].valmax = max_val_x
self.axes_range_sliders["sl_x_min"].ax.set_xlim(min_val_x, max_val_x)
self.axes_range_sliders["sl_x_min"].poly.axes.set_xlim(
min_val_x, max_val_x)
self.axes_range_sliders["sl_x_min"].poly.xy[[0, 1], 0] = min_val_x
self.axes_range_sliders["sl_x_min"].vline.set_data(([
self.axes_range_sliders["sl_x_min"].valinit,
self.axes_range_sliders["sl_x_min"].valinit
], [0, 1]))
self.axes_range_sliders[
"sl_x_max"].valinit = self.model.state_variable_range[self.svx][1]
self.axes_range_sliders["sl_x_max"].valmin = min_val_x
self.axes_range_sliders["sl_x_max"].valmax = max_val_x
self.axes_range_sliders["sl_x_max"].ax.set_xlim(min_val_x, max_val_x)
self.axes_range_sliders["sl_x_max"].poly.axes.set_xlim(
min_val_x, max_val_x)
self.axes_range_sliders["sl_x_max"].poly.xy[[0, 1], 0] = min_val_x
self.axes_range_sliders["sl_x_max"].vline.set_data(([
self.axes_range_sliders["sl_x_max"].valinit,
self.axes_range_sliders["sl_x_max"].valinit
], [0, 1]))
self.axes_range_sliders["sl_x_min"].reset()
self.axes_range_sliders["sl_x_max"].reset()
def update_yrange_sliders(self):
"""
A hacky update of the y-axis range sliders that is called when the
state-variable selected for the y-axis is changed.
"""
#svy_ind = self.model.state_variables.index(self.svy)
default_range_y = (self.model.state_variable_range[self.svy][1] -
self.model.state_variable_range[self.svy][0])
min_val_y = self.model.state_variable_range[
self.svy][0] - 4.0 * default_range_y
max_val_y = self.model.state_variable_range[
self.svy][1] + 4.0 * default_range_y
self.axes_range_sliders[
"sl_y_min"].valinit = self.model.state_variable_range[self.svy][0]
self.axes_range_sliders["sl_y_min"].valmin = min_val_y
self.axes_range_sliders["sl_y_min"].valmax = max_val_y
self.axes_range_sliders["sl_y_min"].ax.set_xlim(min_val_y, max_val_y)
self.axes_range_sliders["sl_y_min"].poly.axes.set_xlim(
min_val_y, max_val_y)
self.axes_range_sliders["sl_y_min"].poly.xy[[0, 1], 0] = min_val_y
self.axes_range_sliders["sl_y_min"].vline.set_data(([
self.axes_range_sliders["sl_y_min"].valinit,
self.axes_range_sliders["sl_y_min"].valinit
], [0, 1]))
self.axes_range_sliders[
"sl_y_max"].valinit = self.model.state_variable_range[self.svy][1]
self.axes_range_sliders["sl_y_max"].valmin = min_val_y
self.axes_range_sliders["sl_y_max"].valmax = max_val_y
self.axes_range_sliders["sl_y_max"].ax.set_xlim(min_val_y, max_val_y)
self.axes_range_sliders["sl_y_max"].poly.axes.set_xlim(
min_val_y, max_val_y)
self.axes_range_sliders["sl_y_max"].poly.xy[[0, 1], 0] = min_val_y
self.axes_range_sliders["sl_y_max"].vline.set_data(([
self.axes_range_sliders["sl_y_max"].valinit,
self.axes_range_sliders["sl_y_max"].valinit
], [0, 1]))
self.axes_range_sliders["sl_y_min"].reset()
self.axes_range_sliders["sl_y_max"].reset()
def update_svx(self, label):
"""
Update state variable used for x-axis based on radio buttton selection.
"""
self.svx = label
self.update_xrange_sliders()
self.set_mesh_grid()
self.calc_phase_plane()
self.update_phase_plane()
def update_svy(self, label):
"""
Update state variable used for y-axis based on radio buttton selection.
"""
self.svy = label
self.update_yrange_sliders()
self.set_mesh_grid()
self.calc_phase_plane()
self.update_phase_plane()
def update_mode(self, label):
""" Update the visualised mode based on radio button selection. """
self.mode = label
self.update_phase_plane()
def update_parameters(self, val):
"""
Update model parameters based on the current parameter slider values.
NOTE: Haven't figured out how to update independantly, so just update
everything.
"""
#TODO: Grab caller and use val directly, ie independent parameter update.
#import pdb; pdb.set_trace()
for param in self.param_sliders:
setattr(self.model, param,
numpy.array([self.param_sliders[param].val]))
self.model.update_derived_parameters()
self.calc_phase_plane()
self.update_phase_plane()
def update_noise(self, nsig):
""" Update integrator noise based on the noise slider value. """
self.integrator.noise.nsig = numpy.array([
10**nsig,
])
def update_range(self, val):
"""
Update the axes ranges based on the current axes slider values.
NOTE: Haven't figured out how to update independantly, so just update
everything.
"""
#TODO: Grab caller and use val directly, ie independent range update.
self.axes_range_sliders["sl_x_min"].ax.set_facecolor(AXCOLOUR)
self.axes_range_sliders["sl_x_max"].ax.set_facecolor(AXCOLOUR)
self.axes_range_sliders["sl_y_min"].ax.set_facecolor(AXCOLOUR)
self.axes_range_sliders["sl_y_max"].ax.set_facecolor(AXCOLOUR)
if (self.axes_range_sliders["sl_x_min"].val >=
self.axes_range_sliders["sl_x_max"].val):
LOG.error("X-axis min must be less than max...")
self.axes_range_sliders["sl_x_min"].ax.set_facecolor("Red")
self.axes_range_sliders["sl_x_max"].ax.set_facecolor("Red")
return
if (self.axes_range_sliders["sl_y_min"].val >=
self.axes_range_sliders["sl_y_max"].val):
LOG.error("Y-axis min must be less than max...")
self.axes_range_sliders["sl_y_min"].ax.set_facecolor("Red")
self.axes_range_sliders["sl_y_max"].ax.set_facecolor("Red")
return
msv_range = self.model.state_variable_range
msv_range[self.svx][0] = self.axes_range_sliders["sl_x_min"].val
msv_range[self.svx][1] = self.axes_range_sliders["sl_x_max"].val
msv_range[self.svy][0] = self.axes_range_sliders["sl_y_min"].val
msv_range[self.svy][1] = self.axes_range_sliders["sl_y_max"].val
self.set_mesh_grid()
self.calc_phase_plane()
self.update_phase_plane()
def update_phase_plane(self):
""" Clear the axes and redraw the phase-plane. """
self.pp_ax.clear()
self.pp_splt.clear()
self.pp_splt.set_prop_cycle('color', get_color(self.model.nvar))
self.pp_splt.plot(
numpy.arange(TRAJ_STEPS + 1) * self.integrator.dt,
numpy.zeros((TRAJ_STEPS + 1, self.model.nvar)))
if hasattr(self.pp_splt, 'autoscale'):
self.pp_splt.autoscale(enable=True, axis='y', tight=True)
self.pp_splt.legend(self.model.state_variables)
self.plot_phase_plane()
def update_state_variables(self, val):
"""
Update the default state-variable values, used for non-visualised state
variables, based of the current slider values.
"""
for sv in self.sv_sliders:
k = self.model.state_variables.index(sv)
self.default_sv[k] = self.sv_sliders[sv].val
self.calc_phase_plane()
self.update_phase_plane()
def set_mesh_grid(self):
"""
Generate the phase-plane gridding based on currently selected
state-variables and their range values.
"""
xlo = self.model.state_variable_range[self.svx][0]
xhi = self.model.state_variable_range[self.svx][1]
ylo = self.model.state_variable_range[self.svy][0]
yhi = self.model.state_variable_range[self.svy][1]
self.X = numpy.mgrid[xlo:xhi:(NUMBEROFGRIDPOINTS * 1j)]
self.Y = numpy.mgrid[ylo:yhi:(NUMBEROFGRIDPOINTS * 1j)]
def set_state_vector(self):
"""
Set up a vector containing the default state-variable values and create
a filler(all zeros) for the coupling arg of the Model's dfun method.
This method is called once at initialisation (show()).
"""
#import pdb; pdb.set_trace()
sv_mean = numpy.array([
self.model.state_variable_range[key].mean()
for key in self.model.state_variables
])
sv_mean = sv_mean.reshape((self.model.nvar, 1, 1))
self.default_sv = sv_mean.repeat(self.model.number_of_modes, axis=2)
self.no_coupling = numpy.zeros(
(self.model.nvar, 1, self.model.number_of_modes))
def calc_phase_plane(self):
""" Calculate the vector field. """
svx_ind = self.model.state_variables.index(self.svx)
svy_ind = self.model.state_variables.index(self.svy)
#Calculate the vector field discretely sampled at a grid of points
grid_point = self.default_sv.copy()
self.U = numpy.zeros((NUMBEROFGRIDPOINTS, NUMBEROFGRIDPOINTS,
self.model.number_of_modes))
self.V = numpy.zeros((NUMBEROFGRIDPOINTS, NUMBEROFGRIDPOINTS,
self.model.number_of_modes))
for ii in range(NUMBEROFGRIDPOINTS):
grid_point[svy_ind] = self.Y[ii]
for jj in range(NUMBEROFGRIDPOINTS):
#import pdb; pdb.set_trace()
grid_point[svx_ind] = self.X[jj]
d = self.model.dfun(grid_point, self.no_coupling)
for kk in range(self.model.number_of_modes):
self.U[ii, jj, kk] = d[svx_ind, 0, kk]
self.V[ii, jj, kk] = d[svy_ind, 0, kk]
#Colours for the vector field quivers
#self.UVmag = numpy.sqrt(self.U**2 + self.V**2)
#import pdb; pdb.set_trace()
if numpy.isnan(self.U).any() or numpy.isnan(self.V).any():
LOG.error("NaN")
def plot_phase_plane(self):
""" Plot the vector field and its nullclines. """
# Set title and axis labels
model_name = self.model.__class__.__name__
self.pp_ax.set(title=model_name + " mode " + str(self.mode))
self.pp_ax.set(xlabel="State Variable " + self.svx)
self.pp_ax.set(ylabel="State Variable " + self.svy)
#import pdb; pdb.set_trace()
#Plot a discrete representation of the vector field
if numpy.all(self.U[:, :, self.mode] + self.V[:, :, self.mode] == 0):
self.pp_ax.set(title=model_name + " mode " + str(self.mode) +
": NO MOTION IN THIS PLANE")
X, Y = numpy.meshgrid(self.X, self.Y)
self.pp_quivers = self.pp_ax.scatter(X, Y, s=8, marker=".", c="k")
else:
self.pp_quivers = self.pp_ax.quiver(
self.X,
self.Y,
self.U[:, :, self.mode],
self.V[:, :, self.mode],
#self.UVmag[:, :, self.mode],
width=0.001,
headwidth=8)
#Plot the nullclines
self.nullcline_x = self.pp_ax.contour(self.X,
self.Y,
self.U[:, :, self.mode], [0],
colors="r")
self.nullcline_y = self.pp_ax.contour(self.X,
self.Y,
self.V[:, :, self.mode], [0],
colors="g")
pylab.draw()
def plot_trajectory(self, x, y):
"""
Plot a sample trajectory, starting at the position x,y in the
phase-plane. This method is called as a result of a mouse click on the
phase-plane.
"""
svx_ind = self.model.state_variables.index(self.svx)
svy_ind = self.model.state_variables.index(self.svy)
print(svx_ind)
#Calculate an example trajectory
state = self.default_sv.copy()
self.integrator.clamped_state_variable_indices = numpy.setdiff1d(
numpy.r_[:len(self.model.state_variables)], numpy.r_[svx_ind,
svy_ind])
self.integrator.clamped_state_variable_values = self.default_sv[
self.integrator.clamped_state_variable_indices]
state[svx_ind] = x
state[svy_ind] = y
scheme = self.integrator.scheme
traj = numpy.zeros(
(TRAJ_STEPS + 1, self.model.nvar, 1, self.model.number_of_modes))
traj[0, :] = state
for step in range(TRAJ_STEPS):
#import pdb; pdb.set_trace()
state = scheme(state, self.model.dfun, self.no_coupling, 0.0, 0.0)
traj[step + 1, :] = state
self.pp_ax.scatter(x, y, s=42, c='g', marker='o', edgecolor=None)
self.pp_ax.plot(traj[:, svx_ind, 0, self.mode], traj[:, svy_ind, 0,
self.mode])
#Plot the selected state variable trajectories as a function of time
self.pp_splt.plot(
numpy.arange(TRAJ_STEPS + 1) * self.integrator.dt, traj[:, :, 0,
self.mode])
pylab.draw()
def click_trajectory(self, event):
"""
This method captures mouse clicks on the phase-plane and then uses the
plot_trajectory() method to generate a sample trajectory.
"""
if event.inaxes is self.pp_ax:
x, y = event.xdata, event.ydata
LOG.info('trajectory starting at (%f, %f)', x, y)
self.plot_trajectory(x, y)
def test_rk4(self):
rk4 = integrators.RungeKutta4thOrderDeterministic()
self.assertEqual(rk4.dt, dt)
self._test_scheme(rk4)
