New book on computational biology

Enzyme Kinetics for Systems Biology

by Herbert M Sauro
published at analogmachine.org

------------------------------------------------------------------------

Book summary:

318 pages, 94 illustrations and 75 exercises

This new monograph introduces students to basic reaction kinetics, including enzyme kinetics, cooperativity, allostery and gene regulatory kinetics. The text introduces a number of modern concepts such as generalized rate laws, elasticities and systems biology thermodynamic quantities. The text is suitable for junior undergraduate level in the US and 2nd year undergraduates in the UK. The text can also be used as a reference text for graduates and other researchers. Click here for the Google books preview.

Display Fire!

The simulation tools now display an animated "fire" on top of items after a simulation. The purpose of the fire is to highlight upregulated and downregulated molecules. The size of the fire is proportional to the final output in the simulation.

These fires can be created from Python or Octave scripts using the tc_burn( item, intensity ) command, where intensity is a number in the range (0,1). From C++, a tool can connect to signals in the LabelingTool (in TinkerCellCore library) in order to create these effects.

The fire feature can be completely inactivated from C++ by setting the LabelingTool::ENABLE_FIRE to false.

Events

Events can be inserted using the clock icon in the "Inputs" tab at the top. The events table is stored as part of the "global item", which can be accessed in the command-line using "_". The clock icon can be used to edit the Events. In this screenshot, an event is used with the toggle-switch model to try to switch the toggle-switch from one state to the other (didn't work in this model, because the states are quite robust).

Optimization and Global Sensitivity

TinkerCell now includes optimization functions for fitting time series data and maximizing or minimizing a given formula. The optimization routines are written in Python but use C++ simulators (copasi). The algorithm is Cross Entropy, which can be used to obtain an estimate of the distribution of parameters. PCA can be used to infer global sensitivities.


A user can write any Python function and optimize it using CrossEntropy. Here is template code:

#objective function for CrossEntropy
def MyObjective():
error = 0.0
#do something here, e.g. call tc_getSteadyState or tc_simulateDeterministic
return error

#optimization parameters
minimize = False
maxruns = 100
numPoints = 100
title = "My Optimization Function"

#optimize
result = CrossEntropy.OptimizeParameters(FitFormula_Objective, title, maxruns, numPoints, minimize)
mu = result[0]
sigma = result[1]
paramnames = result[2]
CrossEntropy.DoPCA(mu, sigma, paramnames)

#set the optimized parameters in the model if you want
n = len(mu)
params = tc_createMatrix(n, 1)
for i in range(0,n):
tc_setMatrixValue(params, i, 0, mu[i])
tc_setRowName(params, i, paramnames[i])
tc_setParameters(params,1)

CrossEntropy.DoPCA will generate a summary file such as the one below.

Trying different versions of a model

From Python or Octave, it is relatively simple to try different versions of the same network architecture. For example, the diagram below shows a protein regulating itself. The regulation type is "transcription regulation", i.e. it does not specify whether it is positive or negative regulation. The code below the figure simulates both positive and negative feedback using the tc_substituteModel command.

j = tc_find("tr1")

file1 = "/home/deepak/Documents/TinkerCell/Modules/transcription_activation/Equilibrium_Model.tic"

file2 = "/home/deepak/Documents/TinkerCell/Modules/transcription_repression/Equilibrium_Model.tic"

tc_multiplot(2,1)

tc_substituteModel(j, file1)

m1 = tc_simulateDeterministic(0,100,100)

tc_plot(m1, "using file 1")

tc_substituteModel(j, file2)

m2 = tc_simulateDeterministic(0,100,100)

tc_plot(m2, "using file 2")

It is also possible to practically remove a component from the model by substituting "empty" for the model, e.g. tc_substituteModel(j, "empty")