visualization Package

This package contains the definition of the visualization API, together with implementation of numerous plotting methods that take advantage of the mozaik data structures to automatize a lot of the visualization functionality.

The philoshophy of the visualization package is similar to the analysis package mozaik.analysis.analysis. The input of each plotting is a datastore, it is the role of the plotting to extract as much as possible data from the provided datastore and display as much as possible information (of course with respect to the role of the given plotting class). It is then up to the user to manipulate the datastore before passing it to the plotting function to restrict the information that is being plotted. Together with the querying system this provides a very flexible and unified framework for defining what users want to plot.

The implementation is based on matplotlib and its GridSpec objects. The plotting framwork is divided into two main concepts, represented by the two high-level classes Plotting mozaik.visualization.plotting.Plotting and mozaik.visualization.simple_plot.SimplePlot.

The SimplePlot represent low-level plotting. It is assumed that this plot has only a single axis that is drawn into the region defined by the GridSpec instance that is passed into it. The role of the set of classes derived from SimplePlot is to standardize the low level looks of all figures (mainly related to axis, lables, titles etc.), and should assume data given to them in a format that is easy to use by the given plot. In order to unify the look of figures it defines four functions pre_axis_plot, pre_plot, plot, and post_plot. The actual plotting that user defines is typically defined in the plot function while the pre_axis_plot, pre_plot and post_plot functions handle the pre and post plotting adjustments to the plot (i.e. typical post_plot function for example adjusts the ticks of the axis to a common format other such axis related properties). When defining a new SimplePlot function user is encoureged to push as much of it’s ‘decorating’ funcitonality into the post and pre plot function and define only the absolute minimum in the plot function. At the same time, there is already a set of classes implementing a general common look provided, and so users are encouraged to use these as much as possible. If their formatting features are not sufficient or incompatible with a given plot, users are encoureged to define new virtual class that defines the formatting in the pre and post plot functions (and thus sepparating it from the plot itself), and incorporating these as low as possible within the hierarchy of the SimplePlot classes to re-use as much of the previous work as possible.

The Plotting class (and its children) define the high level plotting mechanisms. They are mainly responsible for hierarchical organization of figures with multiple plots, any mechanisms that require consideration of several plots at the same time, and the translation of the data form the general format provided by Datastore, to specific format that the SimplePlot plots require. In general the Plotting instances should not do any plotting of axes themselves (but instead calling the SimplePlot instances to do the actual plotting), with the exception of multi-axis figures whith complicated inter-axis dependencies, for which it is not practical to break them down into single SimplePlot instances.

plotting Module

This module defines the mozaik.visualization.plotting.Plotting API and offers a library of plotting commands derived from it.

The plotting API

The high-level plotting API is defined by the mozaik.visualization.plotting.Plotting class. Each class derived from Plotting should implement two plotting functions: plot and subplot. The subplot function accepts a SubplotSpec object (see matplotlib doc) as input which will tell it where to plot. The subplot function returns a dictionary, where each key is a name of a subplot it generates (and will correspond to a creation of another Plotting or SimplePlot plot), and the associated value is a tuple that contains the:

• Plotting or SimplePlot object
• the SubplotSpec subregion into which the plot is supposed to be drawn
• dictionary of parameters that to be passed to the plot.

This way one can nest Plotting instances and eventualy simple_plot instances as the leafs of the tree.

The third element of the tuple discussed above is a dictionary of parameters that will be passed onto the eventual call to SimplePlot class. At each level of hierarchy the Plotting instances can add some parameters via the third element of the tuple. But note that the parameters at higher levels of hierarchy will overide the parameters given at lower level of hierarchy.

The names of the subplots that are returned by the subplot function as the keys of the dictionary should be documented as they will be used to identify the subplots by user should he wish to pass specific parameters to them. The user can do this by passing a dictionary to the plot function. The keys of the dictionary are comma sepparated strings containing the path to the plot in the plotting hierarchy to which the parameters will be passed, e.g: top_plot_name.first_level_subplot_name.second_level_subplot_name.parameter_name = value One can also use ‘*’ instead of a plot name to indicated that the parameter should be passed to all the subplots at that level. Also if the path ends before it reaches a simple_plot level it is automatically assumed the parameter will be passed into the rest of the subtree. Finaly the subplots function can return plots which are names which use the ‘.’ character. This will be processed in the same way as above and it allows for Plotting classes that create multiple groups of plots to let user sepparately target the different groups with parameters.

The plot function can either not be defined in which case it defaults to the Plotting.plot, which simply creates a figure and calls subplot with SuplotSpec spanning the whole figure. Alternatively, one can define the plot function if one wants to add some additional figure level decorations, in case the figure is plotted on its own (i.e. becomes the highest-level), and that would otherwise prevent flexible use in nesting via the subplot.

class mozaik.visualization.plotting.Plotting(datastore, parameters, plot_file_name=None, fig_param=None)

Bases: mozaik.core.ParametrizedObject

The high level Plotting API. See the module information on more detailed description.

Parameters :

datastore : Datastore

the DataStore from which to plot the data

parameters : ParameterSet

The mozaik parameters.

plot_file_name : str

Either None, in which case the plot is not saved onto HD, or path to a file into which to save the file (formats accepted by matplotlib).

fig_params : dict

The parameters that are passed to the matplotlib figure command (but note facecolor=’w’ is already supplied).

subplot(subplotspec)

This is the function that each Plotting instance has to implement. See the module documentation for more details.

plot(params=None)

The top level plot function. It is this function that the user will call on the plot instance to execute the plotting.

Parameters :

params : dict

The dictionary of parameters modifying the defaults across the plotting hierarchy. Keys are comma sepparated path in the plot hierarchy, values are values to be substituted. See the module level info for more details.

class mozaik.visualization.plotting.PlotTuningCurve(datastore, parameters, plot_file_name=None, fig_param=None)

Bases: mozaik.visualization.plotting.Plotting

Plots tuning curves, one plot in line per each neuron. This plotting function assumes a set of PerNeuronValue ADSs in the datastore associated with certain stimulus type. It will plot the values stored in these PerNeuronValue instances (corresponding to neurons in neurons) across the varying parameter parameter_name of thier associated stimuli. If other parameters of the stimuli are varying withing the datastore it will automatically plot one tuning curve per each combination of values of the other parameters and label the curve accordingly.

Other Parameters:  

neurons : list

List of neuron ids for which to plot the tuning curves.

sheet_name : str

From which layer to plot the tuning curves.

parameter_name : str

The parameter_name through which to plot the tuning curve.

Defines ‘TuningCurve_’ + value_name + ‘.Plot0’ ... ‘TuningCurve_’ + value_name + ‘.Plotn’ :

where n goes through number of neurons, and value_name creates one row for each value_name found in the different PerNeuron found :

class mozaik.visualization.plotting.RasterPlot(datastore, parameters, plot_file_name=None, fig_param=None)

Bases: mozaik.visualization.plotting.Plotting

It plots raster plots of spikes stored in the recordings. It assumes a datastore with a set of recordings. It will plot a line of raster plots, one per each recording, showing the raster plot corresponding to the given recording.

Defines ‘RasterPlot.Plot0’ ... ‘RasterPlot.PlotN’

Other Parameters:  

sheet_name : str

From which layer to plot the raster plots.

neurons : list

List of neuron ids for which to plot the tuning curves.

trial_averaged_histogram : bool

Should the plot show also the trial averaged histogram?

class mozaik.visualization.plotting.VmPlot(datastore, parameters, plot_file_name=None, fig_param=None)

Bases: mozaik.visualization.plotting.Plotting

It plots the membrane potentials stored in the recordings. It assumes a datastore with a set of recordings. It will plot a line of vm plots, one per each recording, showing the vm corresponding to the given recording.

It defines one plot named: ‘VmPlot.Plot0’ ... ‘VmPlot.PlotN’.

Other Parameters:  

sheet_name : str

From which layer to plot the vms.

neuron : int

Id of the neuron to plot.

class mozaik.visualization.plotting.GSynPlot(datastore, parameters, plot_file_name=None, fig_param=None)

Bases: mozaik.visualization.plotting.Plotting

It plots the conductances stored in the recordings. It assumes a datastore with a set of recordings. It will plot a line of conductance plots, one per each recording, showing the excitatory and inhibitory conductances corresponding to the given recording.

It defines one plot named: ‘ConductancesPlot.Plot0’ ... ‘ConductancesPlot.PlotN’.

Other Parameters:  

sheet_name : str

From which layer to plot the conductances.

neuron : int

Id of the neuron to plot.

class mozaik.visualization.plotting.OverviewPlot(datastore, parameters, plot_file_name=None, fig_param=None)

Bases: mozaik.visualization.plotting.Plotting

It defines 4 (or 3 depending on the sheet_activity option) plots named: ‘Activity_plot’, ‘Spike_plot’, ‘Vm_plot’, ‘Conductance_plot’ corresponding to the ActivityMovie RasterPlot, VmPlot, GSynPlot plots respectively. And than a line of the with the extensions .Plot1 ... .PlotN

Other Parameters:  

sheet_name : str

From which layer to plot.

neuron : int

Id of the neuron to plot.

sheet_activity: bool :

Whether to also show the sheet activity plot as the first row.

class mozaik.visualization.plotting.AnalogSignalListPlot(datastore, parameters, plot_file_name=None, fig_param=None)

Bases: mozaik.visualization.plotting.Plotting

This plot shows a line of plots each showing analog signals, one plot per each AnalogSignalList instance present in the datastore.

It defines line of plots named: ‘AnalogSignalPlot.Plot0’ ... ‘AnalogSignalPlot.PlotN’.

Other Parameters:  

sheet_name : str

From which layer to plot.

neurons : list

List of neuron ids for which to plot the analog signals.

class mozaik.visualization.plotting.ConductanceSignalListPlot(datastore, parameters, plot_file_name=None, fig_param=None)

Bases: mozaik.visualization.plotting.Plotting

This plot shows a line of plots each showing excitatory and inhibitory conductances, one plot per each ConductanceSignalList instance present in the datastore.

It defines line of plots named: ‘ConductancePlot.Plot0’ ... ‘ConductancePlot.PlotN’.

Other Parameters:  

sheet_name : str

From which layer to plot.

normalize_individually : bool

Whether to normalize each trace individually by dividing it with its maximum.

class mozaik.visualization.plotting.RetinalInputMovie(datastore, parameters, plot_file_name=None, fig_param=None)

Bases: mozaik.visualization.plotting.Plotting

This plots one plot showing the retinal input per each recording in the datastore.

It defines line of plots named: ‘PixelMovie.Plot0’ ... ‘PixelMovie.PlotN’.

Other Parameters:  

frame_rate : int

The desired frame rate (per sec), it might be less if the computer is too slow.

class mozaik.visualization.plotting.ActivityMovie(datastore, parameters, plot_file_name=None, fig_param=None)

Bases: mozaik.visualization.plotting.Plotting

This plots one plot per each recording, each showing the activity during that recording based on the spikes stored in the recording. The activity is showed localized in the sheet cooridantes.

It defines line of plots named: ‘ScatterPlot.Plot0’ ... ‘ScatterPlot.PlotN’ or ‘PixelMovie.Plot0’ ... ‘PixelMovie.PlotN’ depending on the parameter scatter.

Other Parameters:  

frame_rate : int

The desired frame rate (per sec), it might be less if the computer is too slow.

bin_width : float

In ms the width of the bins into which to sample spikes.

scatter : bool

Whether to plot neurons activity into a scatter plot (if True) or as an interpolated pixel image.

resolution : int

The number of pixels into which the activity will be interpolated in case scatter = False.

sheet_name: str :

The sheet for which to display the actvity movie.

class mozaik.visualization.plotting.PerNeuronValuePlot(datastore, parameters, plot_file_name=None, fig_param=None)

Bases: mozaik.visualization.plotting.Plotting

Plots the values for all PerNeuronValue ADSs in teh datastore, one for each sheet.

It defines line of plots named: ‘ScatterPlot.Plot0’ ... ‘ScatterPlot.PlotN

#JAHACK, so far doesn’t support the situation where several types of PerNeuronValue analysys data structures are present in the supplied datastore.

class mozaik.visualization.plotting.PerNeuronValueScatterPlot(datastore, parameters, plot_file_name=None, fig_param=None)

Bases: mozaik.visualization.plotting.Plotting

Takes each pair of PerNeuronValue ADSs in the datastore that have the same units and plots a scatter plot of each such pair.

It defines line of plots named: ‘ScatterPlot.Plot0’ ... ‘ScatterPlot.PlotN

class mozaik.visualization.plotting.ConnectivityPlot(datastore, parameters, pnv_dsv=None, plot_file_name=None, fig_param=None)

Bases: mozaik.visualization.plotting.Plotting

Plots Connectivity, one for each projection originating or targeting (depending on parameter reversed) sheet sheet_name for a single neuron in the sheet.

This plot can accept second DSV that contains the PerNeuronValues corresponding to the target sheets (or source sheet if reversed is True) to be displayed that will be plotted as well.

It defines line of plots named: ‘ConnectionsPlot.Plot0’ ... ‘DelaysPlot.PlotN` and ‘DelaysPlot.Plot0’ ... ‘DelaysPlot.PlotN where N is number of projections.

Parameters :

pnv_dsv : Datastore

The datastore holding PerNeuronValues - one per each sheet that will be displayed as colors for the connections.

Other Parameters:  

neuron : int

The target neuron whose connections are to be displayed.

reversed : bool

If false the outgoing connections from the given neuron are shown. if true the incomming connections are shown.

sheet_name : str

For neuron in which sheet to display connectivity.

Notes

One PerNeuronValue can be present per target sheet!

simple_plot Module

See mozaik.visualization for more general documentation.

class mozaik.visualization.simple_plot.SimplePlot

Bases: object

The low level plotting API based around matplotlib.

Each simple plot is assumed to create a single axis - this happens in this class. Each user defined low-level plotting function is supposed to derive from this class and implement the four abstract methods: pre_axis_plot, pre_plot, plot, post_plot, to direct the styling and decoration of the plot, and call the actual matplotlib plotting functions in the plot function.

The main policy that this API declares is that any overwriting of the standard style default values by the Plotting mechanisms should take precedence over those done by specific instances of SimplePlot. In order to enforce this precedence, the modifiable parameters of the classes should be stored in the common dictionary parameters. Each class derived from SimplePlot should add its modifiable parameters into the parameters dictionary in its constructor. We will document the modifiable parameters the given class declares in the ‘Other parameters’ section.

The kwargs passed to the instances of SimplePlot from the Plotting mechanisms will be stored. At the beginning of the __call__ the dictionary will be updated with these stored kwargs, and the updated parameters (note not all have to be present) will be marked. These marked parameters will not be then modifiable any further. In order to do so, the parameters dictionary is accessible via the __getattr__ and __setattr__ functions.

Note, for this reason all `SimplePlot` classes need to take care that none of the modifiable attributes is also defined as a class attribute.

pre_axis_plot()

The function that is executed before the axis is created.

pre_plot()

The function that is executed before the plotting but after the axis is created.

plot()

The function that has to perform the low level plotting. This is where the main matplotlib plot calls will happen.

post_plot()

The function that is executed after the plotting.

update_params(params)

Updates the modifiable parameters and sets them to be further un-modifiable

class mozaik.visualization.simple_plot.SpikeRasterPlot(spike_lists)

Bases: mozaik.visualization.simple_plot.StandardStyle

This function plots the raster plot of spikes in the spike_lists argument.

Parameters :

spike_lists : list

The spike_lists argument is a list of list of SpikeList objects. The top level list corresponds to different sets of spikes that should be plotted over each other. They have to contain the same number of neurons. Each set of spikes will be colored by the color on corresponding postion of the colors parameter (matplotlib readable color formats accapted). If None all colors will be set to ‘#848484’ (gray). The second level list contains different trials of the populations responses stored in the individual SpikeList objects.

Other Parameters:  

group_trials : bool

If is set to true - trials will be concatenated and plotted on the same line.

colors : list

The colors to assign to the different sets of spikes.

Notes

Each trial will be plotted as a sepparate line of spikes, and these will be grouped by the neurons. Only neurons in the neurons parameter will be plotted. If neurons are None, (up to) first 10 neurons will be plotted.

class mozaik.visualization.simple_plot.SpikeHistogramPlot(spike_lists)

Bases: mozaik.visualization.simple_plot.SpikeRasterPlot

This function plots the raster plot of spikes in the spike_list argument.

Parameters :

spike_list : list

List of list of SpikeList objects. The top level list corresponds to different sets of spikes that should be plotted over each other. They have to contain the same number of neurons. Each set of spikes will be colored by the color on corresponding postion of the colors parameter. If None all colors will be set to ‘#848484’ (gray). The second level list contains different trials of the populations responses stored in the individual SpikeList objects.

Other Parameters:  

bin_width : bool

The with of the bins into which to bin the spikes.

colors : list

The colors to assign to the different sets of spikes.

Notes

Each trial will be plotted as a sepparate line of spikes, and these will be grouped by the neurons. Only neurons in the neurons parameter will be plotted. If neurons are None, the first neuron will be plotted.

class mozaik.visualization.simple_plot.StandardStyleAnimatedPlot(frame_duration)

Bases: mozaik.visualization.simple_plot.StandardStyle

This is an abstract class helping construction of animated graphs.

Each class subclassing from this class should implement the SimplePlot plot() function in which it should draw the first frame of the animation with all the corresponding decorations.

Next it needs to implement the plot_next_frame function which should replot the data in the plot corresponding to the next frame. This function needs to keep track of the frame number itself if it needs it. Note that advanced usage of matplotlib is recomanded here so that not the whole graph is always replotted but only new data are set to the graph.

The StandardStyleAnimatedPlot will take care of the updating of the figure, so now draw() or show() or event commands should be issued.

Parameters :

frame_duration : double

Duration of single frame.

plot_next_frame()

The function that each instance of StandardStyleAnimatedPlot has to implement, in which it updated the data in the plot to the next frame.

class mozaik.visualization.simple_plot.PixelMovie(movie, frame_duration)

Bases: mozaik.visualization.simple_plot.StandardStyleAnimatedPlot

An instatiation of StandardStyleAnimatedPlot that works with regularly sampled data - i.e. 3D matricies where axis are interpreted as x,y,t.

Parameters :

movie : ndarray

3D array with axis (t,x,y) holding the data.

class mozaik.visualization.simple_plot.ScatterPlotMovie(x, y, z, frame_duration)

Bases: mozaik.visualization.simple_plot.StandardStyleAnimatedPlot

An instatiation of StandardStyleAnimatedPlot that works with irregularly sampled data. That data are assumed to have constant positions throught the time.

Parameters :

x : ndarray

1D array containing the x coordinate of the values to be displayed.

y : ndarray

1D array containing the y coordinate of the values to be displayed.

z : ndarray

2D array containing the values to be displayed (t,values)

class mozaik.visualization.simple_plot.ScatterPlot(x, y, z='b', periodic=False, period=None)

Bases: mozaik.visualization.simple_plot.StandardStyle

Simple scatter plot

Parameters :

z : ndarray

Array of the values to be plotted.

x : ndarray

Array with the y positions of the neurons.

y : ndarray

Array with the y positions of the neurons.

periodic : bool

If the z is a periodic value.

period : double

If periodic is True the z should come from (0,period).

Other Parameters:  

identity_line : bool

Should identity line be show?

colorbar : bool

Should there be a colorbar?

colormap : colormap

The colormap to use.

dot_size : double

The size of the markers in the scatter plot.

marker : str

The type of marker to use in the scatter plot.

equal_aspect_ratio : bool

If to enforce equal aspect ratio.

mark_means : bool

Whether to mark the means of each axis.

colorbar_label : label

The label that will be put on the colorbar.

class mozaik.visualization.simple_plot.StandardStyleLinePlot(x, y, labels=None)

Bases: mozaik.visualization.simple_plot.StandardStyle

This function plots vector data in simple line plots.

Parameters :

x, y : list

lists each containing corresponding vectors of x and y axis values to be plotted.

labels : list, optional

Can contain the labels to be given to the individual line plots.

Other Parameters:  

colors : int or list

The colors of the plots. If it is one colour all plots will have that same color. If it is a list its

length should correspond to length of x and y and the corresponding colors will be assigned to the individual graphs.

mean : bool

If the mean of the vectors should be plotted as well.

class mozaik.visualization.simple_plot.ConductancesPlot(exc, inh)

Bases: mozaik.visualization.simple_plot.StandardStyle

Plots conductances.

Parameters :

exc : list

List of excitatory conductances (AnalogSignal type).

inh : list

List of inhibitory conductances (AnalogSignal type).

Other Parameters:  

legend : bool

Whether legend should be displayed.

class mozaik.visualization.simple_plot.ConnectionPlot(pos_x, pos_y, source_x, source_y, weights, colors=None, period=None)

Bases: mozaik.visualization.simple_plot.StandardStyle

A plot that will display connections.

Parameters :

pos_x : ndarray

Array with x position of the target neurons.

pos_y : ndarray

Array with y position of the target neurons.

source_x : double

x position of the source neuron.

source_y : double

y position of the source neuron.

weights : list

Array of weights from source neuron to target neurons.

colors : list, optional

The extra information per neuron that will be displayed as colors. None if no info.

period : float, optional

If period is not None the colors should come from (0,period)

Other Parameters:  

line : bool

(TODO) True means the existing connections will be displayed as lines, with their thickness indicating the strength. False means the strength of connection will be indicated by the size of the circle representing the corresponding target neuron.

colorbar : bool

Should there be a colorbar ?

colormap : colormap

The colormap to use.

colorbar_label : label

The label that will be put on the colorbar.

plot_constructors Module

This module contains classes that assist with construction of complicated arrangements of plots. A typical example is a class that helps with creating a line of plots with a common y axis.

class mozaik.visualization.plot_constructors.LinePlot(**params)

Bases: param.parameterized.Parameterized

Plot multiple plots with common x or y axis in a row or column. The user has to specify the function. This one has to return a list of tuples, each containing:

• a name of a plot
• a Plotting or SimplePlot instance
• the simple_plot parameters that should be passed on

Assuming each function returns a list of plots with names PlotA,...PlotX The LinePlot will create a list of plots named:

PlotA.plot0 ... PlotA.plotN PlotX.plot0 ... PlotX.plotN

where N is defined by the length parameter. User can this way target the plots with parameters as desribed in the Plotting class.

Mozaik parameters:  

function : Callable(constant=False, default=None, readonly=False)

The function that should be called to plot individual plots. It should accept three parameters: self, index in the line, gridspec object into which to plot the plot, the simple_plot parameters

shared_lim : Boolean(bounds=(0, 1), constant=False, default=False, readonly=False)

should the limits of the x axis or y axis (depending on the horizontal flag) be considered shared

length : Integer(bounds=None, constant=False, default=0, inclusive_bounds=(True, True), readonly=False)

how many plots will there be

extra_space_top : Number(bounds=None, constant=False, default=0.0, inclusive_bounds=(True, True), readonly=False)

Space to be reserved on top of the subplot, defined as fraction of the subplot.

shared_axis : Boolean(bounds=(0, 1), constant=False, default=True, readonly=False)

should the x axis or y axis (depending on the horizontal flag) considered shared

max_length : Integer(bounds=None, constant=False, default=8, inclusive_bounds=(True, True), readonly=False)

The maximum # plots actually displayed

horizontal : Boolean(bounds=(0, 1), constant=False, default=True, readonly=False)

Should the line of plots be horizontal or vertical

extra_space_right : Number(bounds=None, constant=False, default=0.0, inclusive_bounds=(True, True), readonly=False)

Space to be reserved on the right side of the subplot, defined as fraction of the subplot.

make_line_plot(subplotspec)

Call to execute the line plot.

Parameters :

funtion : func

Is the function that plots the individual plots. Function has to accept idx

subplotspec : subplotspec

Is the subplotspec into which the whole lineplot is to be plotted.

class mozaik.visualization.plot_constructors.PerDSVPlot(datastore, **params)

Bases: mozaik.visualization.plot_constructors.LinePlot

This is a LinePlot that automatically partitions the datastore view based on some rules, and than executes the individual plots on the line over the individual DSVs.

Unlike LinePlot the function parameter should accept as the first arguemnt DSV not the index of the plot on the line.

The partition dsvs function should perform the partitioning.

Mozaik parameters:  

function : Callable(constant=False, default=None, readonly=False)

The function that should be called to plot individual plots. It should accept three parameters: self, the DSV from which to generate the plot, gridspec object into which to plot the plot, the simple_plot parameters

class mozaik.visualization.plot_constructors.PerStimulusPlot(datastore, **params)

Bases: mozaik.visualization.plot_constructors.PerDSVPlot

Line plot where each plot corresponds to stimulus with the same parameter except trials.

The self.dsvs will contain the datastores you want to plot in each of the subplots - i.e. all recordings in the given datastore come from the same stimulus of the same parameters except for the trial parameter.

PerStimulusPlot provides several automatic titling of plots based on the stimulus name and parameters. The currently supported styles are:

“None” - No title

“Standard” - Simple style where the Stimulus name is plotted on one line

and the parameter values on the second line

“Clever” - This style is valid only for cases where only stimuli of the

same type are present in the supplied DSV. If the style is set to Clever but the conditions doesn’t hold it falls back to Standard and emits a warning. In this case the name of the stimulus and all parameters which are the same for all stimuli in DSV are not displayed. The remaining parameters are shown line after line in the format ‘stimulus: value’. Of course trial parameter is ignored.

Mozaik parameters:  

title_style : String(constant=False, default=Clever, readonly=False)

The style of the title

class mozaik.visualization.plot_constructors.PerStimulusADSPlot(datastore, **params)

Bases: mozaik.visualization.plot_constructors.PerStimulusPlot

As PerStimulusPlot, but partitions the ADS not recordings.

class mozaik.visualization.plot_constructors.GridPlot(**params)

Bases: param.parameterized.Parameterized

Set of plots that are placed on a grid, that vary in two parameters and can have shared x or y axis (only at the level of labels for now).

Mozaik parameters:  

y_axis_parameter : String(constant=False, default=None, readonly=False)

The parameter whose values should be iterated along y-axis

x_axis_parameter : String(constant=False, default=None, readonly=False)

The parameter whose values should be iterated along x-axis

visualization Module