More demo on modules

Modularity at work

New C/Python/Octave functions

tc_simulateODE

tc_simulateSSA

tc_scanSteadyState

tc_exportSBML

tc_screenshot

tc_screenWidth

tc_screenHeight

tc_savePlot

Name change in the C/Python/Octave API

Classes for embedding Python and Octave are now included inside the TinkerCellCore library.

Names of the base classes have changed to avoid confusion with the existing Octave classes. All data structures now have a tc_ prefix to avoid collisions. Here is the detailed documentation:

http://tinkercell.sourceforge.net/CAPI/index.html

All the function names available in the link above can be called from C, Python, or Octave.

Defining and creating new modules

The video shows how new modules can be defined and added. A "module" is an encapsulated biological process. So, in TinkerCell, this is treated like a "connection". The graphical representation will be modified to show something more than just a connection (not in this video).

How the autocompletion of reaction works

Each reaction is now defined by:

1. the family
2. the types, i.e. families, of nodes involved in the connection
3. the "role" of each node involved in the connection

ConnectionFamily::nodeFamilies and ConnectionFamily::nodeFunctions store this information (number 2 and 3 above)

For example, the family named "Enzyme Catalysis" would have:
participant families = Molecule, Molecule, Enzyme
participant roles = Reactant, Product, Catalyst

The roles MUST be unique. If there are multiple Reactants, the roles should define Reactant1, Reactant2, and so on.

The roles are used for:
1. Generating the stoichiometry (Stoichiometry and Rates plugin)
2. Identifying where to place the arrow-heads (Connection Insertion plugin)
3. Identifying how to merge components in a sub-model with the parent-model

The Connection Insertion inserts an arrow for any participant that has the role "Product" or "Target" (or contains those strings).
The Stoichiometry plugins assumes that any participant labeled "Reactant" will be consumed in the reaction and any participant labeled "Product" will be produced.

Abstract reactions with internal models

Big Plans Ahead...

1. TinkerCell will come with a folder full of modules, e.g. enzyme kinetics, gene regulation

2. Each reaction arc, such as a gene regulation arc, can be used to represent one of these modules. The interface will allow the user to double click on the gene regulation connector and load one of the modules to represent that process.

3. All modules will be encapsulated by default. Input/outputs will be represented using small input/output indicators on the items inside the module.

4. Users will be able to write Octave code for TinkerCell.

Big change to Core library

Qt has stopped supporting the drawItems(...) method that allowed multiple graphic v, each showing different items from the scene. As a result, I have adopted a different (possibly better) architecture:

A "NetworkHandle" class is used to represent a network.
Each NetworkHandle consists of one or more NetworkWindows, where each NetworkWindow can contain a scene or a text editor. So, a network is defined by using multiple scenes and/or text editors.

Helper functions for Python

Since the new API uses C data structures, the interface is a bit unfriendly for Python. So, I added the following functions for ease of programming:


toItems: converts Python list of Items to ArrayOfItems
fromItems: converts ArrayOfItems to Python list of Items

toStrings: converts Python list of strings to ArrayOfStrings
fromStrings: converts ArrayOfStrings to Python list of strings

toMatrix: converts Python list of list of reals to Matrix (two optional arguments for row and column names)
fromMatrix: converts Matrix to a list of row names, column names, and 2D list of reals