User Guide

Tim Rudge edited this page Jun 8, 2018 · 59 revisions

Running the GUI

The installer (OSX, Linux) creates script to run the CellModeller user interface in Terminal via the command:

$ cmgui

This should open a window like this: GUI There are 5 buttons here:
Load Model - this will load a file dialog where you can select models to run.
Load Pickle - Pickles are how a simulation saves data (more details below). This will load a simulation from a saved state.
Reset Simulation - This will reset the simulation to the starting point. Note that if the model file was changed, these changes will be picked up by CellModeller, making it easier to tweak models on the fly.
Run - Click this to get the simulation started.
Save Pickle - This toggles whether the simulation is saving data or not.

You can now load and run models from the GUI, for a guide please see tutorials (also in ~/cellmodeller/Examples).

You can also run a specific model from the command line like this:

$ cmgui Examples/Tutorial_1/

Once in a model, pressing Shift and clicking on a cell will select it and display its properties.

OpenCL settings

When you load a model, CellModeller will ask you which OpenCL platform and device you want to use. Most users will have one platform (e.g. "Apple"), but you might have multiple devices (e.g. CPU and GPU). More details can be found in OpenCL configuration.

Using the CellModeller python package

The installer creates a shortcut to the Python interpreter inside the bundled Miniconda. This is where the CellModeller python package is installed. So to run python code that imports CellModeller modules you should use:

$ cmpython

If you installed the python package manually (Custom installation) then you should obviously use the python that you installed into.

You can then write scripts that create and step simulations, check and analyse the state of simulations, load simulations from saved data files, or incorporate them into other python software.

Running simulations in batch mode

The batch script (cellmodeller/Scripts/ is a simple example of creating and stepping a simulation in python, e.g.:

$ cmpython Scripts/ Examples/

Although your model file might create display renderers, when run without the GUI these are not called - so you won't see any graphical output, and the computational cost of rendering is removed. There are variants on this script for running sequences of simulations, e.g. scanning parameters. Have a look in ~/cellmodeller/Scripts.

Saving and loading data

Saving data

By default CellModeller will save simulation data in ~/cellmodeller/data. Each time you run a simulation (either in the GUI or directly via python) a new directory is created with the model name and data/time of the run. The directory will also contain a file with the model in it, for reference. Periodically the state of the simulation is saved here in a pickle file. The pickle will save the all of the details of the cells and signals, as well as the simulation parameters.

In the model specification you can choose how often (if at all) to save data, e.g.

def setup(sim):
    # Set up your model here
    # ...

    # Specify how often to save data
    sim.pickleSteps = 10

specifies to save every 10th simulation step. Beware that data can take up a lot of disk space - we are looking into more efficient ways to store this.

Loading data

User interface

In the GUI you can load any saved pickle file by clicking the "Load pickle file" button. Each pickle also contains the model that generated it, so you can now continue to simulate by pressing the "Run" button. Note that this means that you cannot change the model parameters when it is loaded from a pickle.


Outside of the GUI you can also load saved pickle files and analyse or visualise the state of the simulation. Scripts/ loads a pickle in this way and uses the data to generate a PDF figure. We hope to create a utility module to contain many of these common script functions, and many more useful scripts will be added soon.

Creating figures and videos


To generate PDFs you will need to install the reportlab package:

$ conda install -n cellmodeller reportlab

The saved pickle files mentioned above can be used to create high quality PDF figures (see here for an example) using Scripts/ as follows:

$ cmpython Scripts/ <data file>.pickle

where .pickle is the path to your saved data. You can also create figures from a set of pickles, in particular all the files saved from a given simulation (~/cellmodeller/data) like this:

$ cmpython Scripts/ ~/cellmodeller/data/<dir name>/*.pickle

where <dir name> is the directory name of your simulation run.

To frame your simulations properly you might need to change the world size in - this specifies the page size in simulation units (usually microns). By default it is setup to frame your cells to fill the page. You can change this by editing:

(w,h) = pdf.computeBox()

to specify you desired framing, e.g.:

(w,h) = (200,200)

specifies a fixed size of 200x200 units.


We generate video using ffmpeg to process image sequences based on the PDFs generated by You will need to install ffmpeg:

$ conda install -n cellmodeller ffmpeg

Here is an example 1080p video generated from each step of a simulation:

[![alt text][2]][1] Click image to view video. [1]: [2]:]

You will probably want to set the frame size to some fixed values as mentioned above. You can then run Scripts/ like this:

$ cd <image dir>
$ ~/cellmodeller/Scripts/ <output>.mp4

This script uses ImageMagick to convert PDFs to high resolution images via Ghostscript and then ffmpeg to generate a video file. You'll need to install these tools, the easiest way on Mac OSX is via Homebrew, on Linux use your package manager (e.g. synaptic).

You can’t perform that action at this time.
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.
Press h to open a hovercard with more details.