Software Manual

Applications

CLI

Simple command line application that can run prepared simulations. It takes simulation file and perform simulation with optional visualization.

Parameters:

Name	Parameters	Description	Notes
`simulation-file`	`filepath`	Path to simulation file.
`--plugins`		Prints a list of available plugins.
`--help`		Prints help.
`--visualize`		If simulation should be visualized.
`--novisualize`		Don’t visualize simulation.
`--fullscreen`		Start visualization window in fullscreen. You don’t have to specify window width and height. In that case monitor size is used.
`--width`	`int`	Visualization window width.
`--height`	`int`	Visualization window height.
`--capture`	`filepath`	Record video from simulation. Visualization is required.	May not be available in some builds. Check `--help` if is supported.

Specifying --visualize or --novisualize override settings from simulation (some simulation don’t explicitly want visualize).

Keys

When CLI application is running with visualization some keys can be used.

Key	Description
`Q`	Exits application.
`P`	Pause simulation.
`S`	Perform one simulation step when simulation is paused.

How to run

CLI application is supported on all three platforms.

Windows x64

On Windows the ZIP package contains executable in the main directory and some subdirectories with examples and plugins. Application must be executed from command line (cmd or PowerShell).

PS > .\cece-cli.exe examples\showcase.xml

Mac OS X

Application on Mac is shipped as bundle packed in TZG package. Package contains a few directories where the most important is bin where the application is stored. The directory bin/simulator-cli.app contains everything that CLI application needs to be executed. Run it from Finder is not viable (mostly for GUI apps that doesn’t require arguments) so it must be executed from terminal. The bundle have some predefined structure where the executable is stored but it’s not important because there is bin/cece-cli.sh that allows you to run CLI app without knowledge of bundle structure.

Just run the simulator by typing this in terminal in directory of unpacked TZG package.

$ ./bin/cece-cli.sh examples/showcase.xml

Linux x64

We offer only DEB package for Ubuntu-like distributions (Ubuntu 14.10 LTS, Mint 17.2). Just double click on DEB package and everything should be installed. Then just type following into terminal.

$ cece-cli /usr/share/cece/examples/showcase.xml

Data Types

In following text there are several data types that have different meaning. You can find their meaning in following table:

Name	Description	Example
`int`	Integer value.	`5`, `-3`
`uint`	Unsigned integer value.	`5`
`float`	Floating point value.	`5.3`
`string`	String value.	`hello world`
`expression`	Expression. Can contains parameters that are defined by parameter element.	`10 * 5 + 3 * sin(alpha)`
`plugin-name`	Name of existing plugin.	`cell`
`name`	Similar to `string`.	`print`
`unit[?]`	SI unit based on specified symbol in square braces. Accepts value without unit symbol but if symbol is specified it must match the unit type (prefix are supported). Value without symbol have unspecified size, but mostly corresponds to basic unit specified by simulator (`um`, `s`, `ng`).	`0`, `30um/s`, `1.3m/s2`, `0.01/s`, ~~`5um/us`~~
`vector[?]`	Value of two values separated by space. In case the second value is not supplied it is same as the first one.	`10um/s 1um/s`, `0 0`
`color`	Color value. Value can be name of predefined color or in CSS color definition format (#RRGGBB).	`red`, `#0000FF`
`it`	Simulation iteration number.	`10`, `55`
`range[?]`	Range of values. Values can be separated by dash ‘-’. If dash is not present the meaning is: `X-X`.	`10`, `10-15`
`array[?]`	List of values of same type.	`10 10 -5`, `a b c d e f g`

Data Tables

Data tables are way how the simulator stores data within simulation. Anything can store data in named data table and when simulation ends those data tables are stored into CSV files in current working directory.

All data is stored in memory during simulation and are stored into file when simulation ends. This cause a large memory requirements depending on stored data.

Loaders

Loaders are responsible for loading different type of source files. They understand the source file and create simulation from them.

Reactions

This loader loads simple files that contains reaction rules and some parameters. Syntax of reaction rules is same as stochastic-reaction plugins.

@iterations 500
@dt 1s
null > 0.3 > A;
A > 0.1 > B + C;

Lines that begins with @ symbol are considered as directives that setups simulation. Remaining lines are parsed by reactions parser and used as program for cell.

Coresponding XML file looks like:

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<simulation dt="1s" iterations="500">
    <program name="__local__" language="stochastic-reactions-intercellular">
<![CDATA[
        null > 0.3 > A;
        A > 0.1 > B + C;
]]>
    </program>
    <object class="cell.Yeast" programs="__local__" />
</simulation>

List of available directives:

Directive	Parameters	Description	Example
`iterations`	`int`	Number of simulation iterations.	`@iterations 100`
`dt`	`time`	Simulation iteration step.	`@dt 10s`
`molecule`	`string`, `int`	Initial amount of specified molecule.	`@molecule A 500`
`parameter`	`string`, `expression`	Set simulation parameter that can be used in reaction rules.	`@parameter kA 0.3`

XML

Basic and most supported loader. It loads simulation from valid XML file. Some basic knowledge of XML files is required. The simplest simulation file looks like:

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<simulation dt="1s">
</simulation>

<simulation dt="1s"> </simulation></source> This simulation does almost nothing just runs with iteration time step 1 second.

In the simulation element can be several other elements that specifies the simulation. Those elements can have sub-elements but that mostly depends on element type and used plugin.

Basic elements:

Simulator core defines following elements and their parameters.

Simulation

The XML file root element. It must be always present.

Name	Type	Default	Description
`world-size`	`vector[unit[m]]`	-	Simulation world size.
`dt`	`unit[s]`	-	Simulation time step.
`iterations`	`uint`	`0`	Number of simulation iterations. `0` means unlimited.
`background`	`color`	`white`	Background color.
`text-color`	`color`	`background` inverse	Color of UI text.
`text-size`	`uint`	`30`	UI text size.
`show-simulation-time`	`bool`	`false`	If simulation time should be rendered.

Init

This element defines program that is executed before the simulation is started. It’s good for simulation scene initialization in cases when manual specification is hard to write.

Name	Type	Default	Description
`language`	`plugin-name`	-	Language in element content.

Plugin

Explicitly loads required plugin. Plugin is implicitly loaded and when is needed but in some cases there is need for explicit load and configuration.

Name	Type	Default	Description
`name`	`plugin-name`	-	Plugin name.

Additional attributes are passed to plugin configuration.

Module

Adds module to simulation.

Name	Type	Default	Description
`name`	`plugin-name(.module-name)`	-	Name of required module. In most cases you can specify only plugin name but some plugins offsers more modules so you can specify which one you want by adding a suffix.

Additional attributes are passed to module configuration.

Program

Defines a program that is available for objects. Programs are not executed until are assigned to objects.

Name	Type	Default	Description
`name`	`string`	-	Unique program name.
`language`	`plugin-name`	-	Language in which is the program written.

Object

Adds an object into simulation. Objects are physical entities that can be affected during simulation.

Name	Type	Default	Description
`class`	`plugin-name.name`	-	Unique program name.
`visible`	`bool`	`true`	If object is rendered.
`position`	`vector[unit[m]]`	`0 0`	Initial object position. `0 0` is in middle of the world.
`velocity`	`vector[unit[m/s]]`	`0 0`	Initial object velocity.
`density`	`unit[g/m3]`	`1`	Initial object density.
`programs`	`array[string]`	-	A list of object programs.

Obstacle

Adds a physical obstacle into simulation. There are 3 different types of obstacles. Each of them require different attributes.

Name	Type	Default	Description
`visible`	`bool`	`true`	If object is rendered.
`position`	`vector[unit[m]]`	`0 0`	Initial object position. `0 0` is in middle of the world.
`type`	`string`	-	Type of obstacle. Possible values: `circle`, `rectangle`, `polygon`.
`radius`	`unit[m]`	-	Circle radius. Required for `circle` type.
`size`	`vector[unit[m]]`	-	Rectangle size. Required for `rectangle` type.
`vertices`	`array[vector[unit[m]]]`	-	A list of vertices. Required for `polygon` type.

Plugins

List of available plugins supplied within official distribution. Depending on how the simulator is built, some plugins can be builtin and rest of them can be extern as shared libraries (dll / dynlib / so).

Some of them may not be available on your platform, so check the list by calling application with --plugins flag.

Agglutination

This plugin enables simulation object sticking. When two simulation object collides they might be bound together and after some time the bound can be removed. This is based on bond definition where you can specify required molecules in both collided cells to create a bond. Specifying association and dissociation constant you indirectly defines probability of bond creation and destruction.

Example:

Example defines bonds between cells.

<module name="agglutination">
  <bond ligand="LM1" receptor="LM3" association-constant="50" disassociation-constant="1" />
  <bond ligand="LM2" receptor="LM4" association-constant="20" disassociation-constant="10" />
  <bond ligand="LM5" receptor="LM6" association-constant="1"  disassociation-constant="0" />
</module>

Bonds

Parameters:

Name	Type	Default	Description
`ligand`	`name`	-	Name of the first molecule.
`receptor`	`name`	-	Name of the second molecule.
`association-constant`	`float`	-	Bond association constant.
`disassociation-constant`	`float`	-	Bond dissociation constant.

Background

Plugin that renders defined image in each iteration.

Example:

<module name="background" image="background.png" />

Parameters:

Name	Type	Default	Description
`image`	`path`	-	Used background image.

Cell

Plugin offers things usefull to working with cells.

Objects

Objects offered by cell plugin:

Name	Description
`cell.Cell`	Common cell object.
`cell.Yeast`	Yeast cell.

All object share common (unavailable) ancestor that have following properties:

Property	Type	Default	Description	Example
`volume`	`unit[m3]`	`100um3`	Cell volume.	`300um3`
`volume-max`	`unit[m3]`	`100um3`	Maximum cell volume.	`300um3`
`growth-rate`	`unit[m3/s]`	`0`	Cell growth rate.	`3um3/s`
`saturation-gfp`	`unit[/m3]`	`20/um3`	Number of “GFP” molecules required to have full green color.	`100/um3`
`saturation-rfp`	`unit[/m3]`	`20/um3`	Number of “RFP” molecules required to have full red color.	`100/um3`
`saturation-yfp`	`unit[/m3]`	`20/um3`	Number of “YFP” molecules required to have full yellow color.	`100/um3`
`saturation-cfp`	`unit[/m3]`	`20/um3`	Number of “CFP” molecules required to have full cyan color.	`100/um3`
`saturation-bfp`	`unit[/m3]`	`20/um3`	Number of “BFP” molecules required to have full blue color.	`100/um3`

Cell can have set initial amount of molecule at the beginning.

<object class="cell.Yeast">
  <molecule name="GFP" amount="500" />
</object>

Yeast

Property	Type	Default	Description	Example
`volume-bud-create`	`unit[m3]`	`42um3`	Yeast volume when a bud is created.	`300um3`
`volume-bud-release`	`unit[m3]`	`35um3`	Bud volume when is release.	`300um3`

Programs

`store-molecules`

Program that stores amount of all molecules in current iteration to molecules data table. It stores object identifier to distinguish between multiple cells.

<object class="cell.Yeast" programs="cell.store-molecules" />

Stored data:

iteration - Iteration number.
totalTime - Simulation time in seconds.
id - Object identifier.
... - Column given by molecule name and value is amount of that molecule.

Cell Python

Adds access to cell plugin objects from Python.

Objects

Name	Parent	Description
`cell.BaseCell`	`simulator.Object`	Base cell object.
`cell.Yeast`	`cell.BaseCell`	Yeast cell.

Object `cell.BaseCell`

Base class for all cell objects.

Properties:

Name	Type	Description
`volume`	`float`	Cell volume
`growthRate`	`float`	Cell growth rate.

Methods:

Name	Return	Arguments	Description
`moleculeCount`	`float`	`string`	Return amount of required molecule stored in cell.
`kill`	-	-	Kills the cell.

Object `cell.Yeast`

Nothing special.

Diffusion

The main module adds support for global diffusion in simulation. Diffusion can handle any number of separate signals. They cannot affect each other.

Example:

Enables diffusion with two signals named GFP and RFP with diffusion and degradation rates. Those signals have specified colors how they are rendered.

<module name="diffusion" grid="100">
  <signal name="GFP" diffusion-rate="30um2/s" degradation-rate="0.1/s" color="green" />
  <signal name="RFP" diffusion-rate="5um2/s" color="red" saturation="1uM" />
</module>

Parameters:

Name	Type	Default	Description
`grid`	`vector[uint]`	-	Diffusion grid size.
`background`	`color`	`transparent`	Background color.

Signals

You can specify any number of different signals, there is no limitation. Each signal is specified separately.

Parameters:

Name	Type	Default	Description
`name`	`string`	-	Signal name.
`diffusion-rate`	`unit[m2/s]`	-	Diffusion rate.
`degradation-rate`	`unit[/s]`	`0/s`	Degradation rate.
`color`	`color`	Predefined	Signal color when the module is rendered.
`saturation`	`unit[mol/m3]`	`1umol/um3`	Defines concentration when signal color is 100%.

Additional modules

`store-state`

Module that stores values from signal grid of all signals into diffusion data table.

Example:

Store diffusion data for all iterations.

<module name="diffusion.store-state" />

Stored data:

iteration - Iteration number.
totalTime - Simulation time in seconds.
x - Grid X coordinate.
y - Grid Y coordinate.
... - Column given by molecule name and value is amount of that molecule in grid cell.

Diffusion Python

Python language binding for diffusion plugin.

Example:

This module generates in every iteration some diffusion signal inside defined circle.

<module name="python:generate"><![CDATA[
import math

def update(dt, simulation):
    diffusion = simulation.useModule("diffusion")
    size = diffusion.gridSize
    radius = size.x / 20
    signalAmount = 1
    signalId = diffusion.getSignalId("S1")

    for x in range(-radius, radius + 1):
        for y in range(-radius, radius + 1):
            if (math.sqrt(x * x + y * y) <= radius):
                diffusion.setSignal(signalId, size.x / 2 + x, size.y / 2 + y, signalAmount)
]]></module>

Class `diffusion.Module`

Diffusion module wrapping class.

Properties:

Name	Type	Description
`gridSize`	`vector[uint]`	Grid size.
`signalCount`	`uint`	Number of registered diffusion signals.

Methods:

Name	Return	Arguments	Description
`getSignalId`	`int`	`string`	Returns signal identifier from signal name.
`getSignal`	`float`	`string`, `int`, `int`	Return signal value of given signal at given coordinates.
`setSignal`	-	`string`, `int`, `int`, `float`	Change signal value of given signal at given coordinates.

Diffusion Streamlines

Without this plugin/module the streamlines does not affect diffusion. Just simply add:

<module name="diffusion-streamlines" />

It doesn’t require from diffusion and streamlines module to have same grid sizes.

Object generator

Module that generates specified object with some probability and parameters.

Example:

This example create module that generates different Yeast cells in each iteration with some probability.

<module name="object-generator">
  <object class="cell.Yeast" probability="0.004" programs="make-gfp" position-min="-80um -30um" position-max="-78um 30um" />
  <object class="cell.Yeast" probability="0.004" programs="make-rfp" position-min="-80um -30um" position-max="-78um 30um" />
  <object class="cell.Yeast" probability="0.004">
    <molecule name="GFP" amount="1000" />
  </object>
  <object class="cell.Yeast" probability="0.005" />
</module>

Objects

Object definition is same as for object in simulation just some additional parameters are required.

Parameters:

Name	Type	Default	Description
`probability`	`unit[]`	-	Probability of object spawning in iteration.
`position-min`	`vector[unit[m]]`	Left side of simulation scene.	Minimum position where object can be spawned.
`position-max`	`vector[unit[m]]`	Left side of simulation scene.	Maximum position where object can be spawned.
`active`	`array[range[it]]`	-	List of ranges when is generator active.

Changing simulation time step affects spawning probability.

Obstacles image

Plugin generate obstacles from graycolored image by finding contours.

Example:

<plugin name="obstacles-image" image="obstacles.png" />

Parameters:

Name	Type	Default	Description
`image`	`path`	-	Path to source file. Path is relative to same directory as simulation file.

Picture

Module that can store scene picture into file.

Example:

Stores scene picture each 100 iterations into file with name pic_$1.png in directory pictures.

<module name="picture" pattern="pictures/pic_$1.png" iteration="100" />

Parameters:

Name	Type	Default	Description
`pattern`	`string`	`image_$1.png`	Path to output file. Pattern can have special `$1` sequence that is replaced by iteration number.
`iteration`	`int`	`1`	Number of iteration to skip before store picture (~ store each Nth iteration).

If pattern contains directory that directory must exist. ## Python

Python support for dynamic programming.

Python plugin doesn’t support unit data type and float type is used instead.

Programs

Dynamic program generated from Python source code. Called (function call) once in each iteration per object that uses this program.

# Optional initialization code

# Required function prototype.
# object: Object that owns this program.
# simulation: Current simulation.
# dt: Current iteration time step.
def call(object, simulation, dt):
    pass

Modules

Dynamic modules generated from Python source code. Module’s update function is called once in each iteration.

# Optional initialization code

# Optional function prototype
# @param simulator.Simulation    simulation Current simulation.
# @param simulator.Configuration config     Configuration from XML file.
def configure(simulation, config):
    pass
    
# Recommended function prototype
# @param simulator.Simulation simulation Current simulation.
# @param float                dt         Current iteration  time step.
def update(simulation, dt):
    pass
    
# Optional function prototype.
# @param render.Context       context    Rendering context.
# @param simulator.Simulation simulation Current simulation.
def draw(context, simulation):
    pass

Classes

There are some wrappers around simulator core classes.

class `simulator.Configuration`

Configuration class.

Methods:

Name	Return	Arguments	Description
`get`	`string`	`string`	Returns configuration value under given name.

class `simulator.Simulation`

Main simulation class that contains everything about simulation.

Properties:

Name	Type	Description
`worldSize`	`vector[float]`	Simulation scene/world size.
`iteration`	`uint`	Current iteration number.
`iterations`	`uint`	Total number of required iterations. Can be `0`, if there is no limitation.
`timeStep`	`float`	Simulation time step.
`totalTime`	`float`	Total time spend in simulation in seconds.
`objectsCount`	`uint`	Number of objects in scene.

Methods:

Name	Return	Arguments	Description
`useModule`	`simulator.Module`	`string`	Returns required module. If module is not used, it is created by with default configuration.
`buildObject`	`simulator.Object`	`string`, `bool`	Create a new object. The first argument is class name and second one is if object should be static (non-movable).

class `simulator.Module`

Base class for all modules. It doesn’t offer anything.

class `simulator.Object`

Basic simulation object.

Properties:

Name	Type	Description
`id`	`uint`	Grid size.
`position`	`vector[float]`	Number of different signals.
`rotation`	`float`	Object rotation in radians.
`velocity`	`vector[float]`	Object velocity.

Methods:

Name	Return	Arguments	Description
`useProgram`	-	`string`	Add program with given name to object.

Stochastic reactions - Intracellular

Allows to specify reactions rules that are stochastically being executed inside the cell.

The syntax is similar to one in NFSim.

This reaction changes molecule A to molecule B with rate 1. In other words, when this reaction occurs, one molecule A gets substracted and one molecule B gets added.

A > 1 > B;

This reaction changes one molecule A into molecules B and C.

A > 1 > B + C;

If you need reaction to happen only when some other molecule is present, take a look at following reaction. This reaction subtracts A and B, and adds C + B. Therefore, this reaction changes A to C only when B is present. Please note you can’t use this concept with environmental reactions.

A + B > 3 > C + B;

This reaction creates complex C from 2 molecules of A. That means that at least two As are required for this reaction to occur.

A + A > 2 > C;

This reaction uses keyword null and represents expression of A. No molecule gets substracted and one molecule of A gets added.

null > 2 > A;

Similarly, this reaction represents degradation of A.

A > 5 > null;

The two reactions above can be easily rewritten like this using reversible reaction syntax. First rate is rate of reaction going back, and second rate is for reaction going forward.

A < 5, 2 > null;
null < 2, 5 > A;

Another keywords which help user to make his reaction rules more understandable are if, and and or.

if not C and D and E:  A + B > 1 > C;

This reaction merges A and B into C, but this reaction can occur only when there is no molecule of C present and simultaneously there must be D and E present. You can combine as many logic combinations as you can. Please note that and is prior to or, this means that following reaction only occur when there is either A or B and C together present in the cell.

if A or B and C: D > 1 > E;

We want to make your reactions easily tunable, so we included the principle of threshold. The following reaction get executed only when there is 500 molecules of B present in the cell.

If B > 500: A > 1 > C;

Example:

Defines reactions that create molecules GFP and A with some degradation.

<parameter name="K1" value="20" />
<program name="make" language="stochastic-reactions-intracellular"><![CDATA[
  if A > K1: null > 1.505149978 > GFP;
  GFP > 0.001 > null;
  null < 0.5, 0.8 > A;
]]></program>

Stochastic reactions - Intercellular

Allows to specify reactions program that happens in surrounding environment. Plugin is an extension of intracellular reactions.

Extension’s functionality lies in keyword env which is abbreviation for environment, which handles absorbing the molecules inside the cell or producing them outside. Please note that env must be alone on its side of reaction rule.

Plugin requires properly set diffusion module with signals that have same name as molecules released into environment.

This plugin extends basic Intracellular reactions functionality with two types of reactions, expression and absorption.

Expression of molecule A is either represented using:

A > 1 > env;

or using:

null > 1 > env_A;

Please note that those two representations are not exactly the same although they lead to the same result. In first example there must be molecule A present in the cell, after executing the reaction the molecule gets substracted and added to the environment. Therefore this reaction represents transportation of molecule outside the cell. In second reaction, the molecule is added and released directly to the environment in single step.

Representation of absorption:

env > 1 > A;

This reaction follows the same concept. Subtracts molecule from environment and adds inside the cell. However, you may not want the molecules to get absorbed, you may only want to detect if those molecules are outside.

if env_A: B > 1 > C;

Extended conditional reactions are the key. Usage is completely the same as you know from standard intracellular reactions, just add the env_ prefix before molecule name. The threshold functionality is of course kept too.

<parameter name="T1" value="20uM" />

if env_A > T1: B > 1 > C;

Example:

This example is production of A molecules and releasing them with some rate into diffusion.

<program name="expression-of-A" language="stochastic-reactions-intercellular"><![CDATA[
  null > 50 > env_A;
]]></program>

Streamlines

Module that simulate streamlines in whole scene. It using Lattice Boltzman method to calculate velocities in simulation grid. Simulation can handle static and even dynamic obstacles. Dynamic obstacles are moving objects in scene. Dynamic obstacles (i.e. objects) are affected by computed velocities.

There are some limitations that come from Lattice Boltzman method. Maximum velocity is limited by grid size, time step and scene/world size. If the velocity is higher than this limit, it’s changed to the maximum otherwise the streamlines simulation crashes.

Example:

<module name="streamlines" grid="200" inlet-velocity="300um/s" kinematic-viscosity="0.658mm2/s" />

Parameters:

Name	Type	Default	Description
`grid`	`vector[uint]`	-	Simulation grid size.
`layout`	4x `string`	`barrier outlet barrier inlet`	Defines scene layout. Four values define layout in order: top right bottom left. Possible values are: `none`, `barrier`, `inlet`, `outlet`.
`inlet-velocity`	`unit[m/s]`	`0`	Velocity for all inlets.
`inlet-velocities`	4x `unit[m/s]`	`0 0 0 0`	Specific inlet velocities for layout.
`kinematic-viscosity`	`unit[m2/s]`	`0.658mm/s`	Fluid kinematic viscosity.

Additional modules

`store-state`

Module that stores velicities from grid into streamlines data table.

Example:

<module name="streamlines.store-state" />

This module generates a huge amount of data so use with caution.

Stored data:

iteration - Iteration number.
totalTime - Simulation time in seconds.
x - Grid X coordinate.
y - Grid Y coordinate.
velX - Velocity in specified grid cell, X coordinate.
velY - Velocity in specified grid cell, Y coordinate.

Additional programs

`store-object-state`

Module that stores object position and velicities into object-state data table.

Example:

<object ... programs="streamlines.store-object-state" />

Stored data:

iteration - Iteration number.
totalTime - Simulation time in seconds.
id - Object identifier.
x - Object X world coordinate.
y - Object Y world coordinate.
velX - Object velocity, X coordinate.
velY - Object velocity, Y coordinate.

Streamlines Python

Python language binding for streamlines plugin.

Example:

This module generates in every iteration some diffusion signal inside defined circle.

<module name="python:generate"><![CDATA[
layouts = [
    ["barrier", "outlet", "barrier", "inlet"],
    ["barrier", "inlet", "barrier", "outlet"]
]

mode = 1

def update(dt, simulation):
    global mode
    module = simulation.useModule("streamlines")

    if (simulation.iteration % 200 == 0):
        module.setLayout(layouts[mode % 2])
        module.initBarriers(simulation)
        mode = mode + 1
]]></module>

Constants:

Name	Type	Description
`LEFT`	`uint`	Left side.
`RIGHT`	`uint`	Right side.
`TOP`	`uint`	Top side.
`BOTTOM`	`uint`	Bottom side.

Class `streamlines.Module`

Streamlines module wrapping class.

Methods:

Name	Return	Arguments	Description
`setLayout`	`int`	`string`, `string`, `string`, `string`	Set streamlines layout. Top, right, bottom, left. Possible values `barrier`, `inlet`, `outlet`, `none`.
`initBarriers`	`float`	-	Initialize barriers after setLayout call.
`setInletVelocity`	-	`int`, `float`	Change inlet velocity for specific scene side (see constants).

Team:Czech Republic/Software/Manual

Contents

Applications

CLI

Parameters:

Keys

How to run

Windows x64

Mac OS X

Linux x64

Data Types

Data Tables

Loaders

Reactions

XML

Basic elements:

Simulation

Init

Plugin

Module

Program

Object

Obstacle

Plugins

Agglutination

Example:

Bonds

Parameters:

Background

Example:

Parameters:

Cell

Objects

Yeast

Programs

store-molecules

Stored data:

Cell Python

Objects

Object cell.BaseCell

Properties:

Methods:

Object cell.Yeast

Diffusion

Example:

Parameters:

Signals

Parameters:

Additional modules

store-state

Example:

Stored data:

Diffusion Python

Example:

Class diffusion.Module

Properties:

Methods:

Diffusion Streamlines

Object generator

Example:

Objects

Parameters:

Obstacles image

Example:

Parameters:

Picture

Example:

Parameters:

Programs

Modules

Classes

class simulator.Configuration

Methods:

class simulator.Simulation

Properties:

Methods:

class simulator.Module

class simulator.Object

Properties:

Methods:

`store-molecules`

Object `cell.BaseCell`

Object `cell.Yeast`

`store-state`

Class `diffusion.Module`

class `simulator.Configuration`

class `simulator.Simulation`

class `simulator.Module`

class `simulator.Object`

`store-state`

`store-object-state`

Class `streamlines.Module`