## Another Inhibition Pathway Diagram using TikZ

Here is another pathway diagram I needed to draw using TikZ. IN this case I needed an inhibited step. This was more tricky because I needed the inhibition line to point midway to a reaction but without touching the reaction itsef.

To solve this I had to ask stackoverflow and within 2 hours I had an answer. The linear portion of the pathway is straightforward:


\begin{tikzpicture}[>=latex',node distance = 2cm]

\node (S) {\scalebox{1.4}{$S$}};

\node [left of = S] (Xo) {};
\draw[->,line width = 1.2pt] (Xo) to node[above] {\scalebox{1.3}{$v_1$}} (S);

\node [right of = S] (P) {$P$};
\draw[->,line width = 1.2pt] (S) to node[below] {\scalebox{1.3}{$v_2$}} (P);

\node [right of = P] (X1) {};
\draw[->,line width = 1.2pt] (P) to node[above] {\scalebox{1.3}{$v_3$}} (X1);

\end{tikzpicture}


The question was how to draw the inhibition line from inhibitior I to reaction v2. The trick is to use the tikz calc extension package which can be used to do more more advanced coordinate calculations.

\usetikzlibrary{calc}

The line to add that that will draw the vertical inhibition line is:

\draw[|-,line width=1.2pt] ([yshift=4pt]$(S)!.5!(P)$) –++(0,1.5cm)node[above]{$I$};

Let’s decompose this. The first two arguments in the \draw command [[|-,line width=1.2pt] simply set the arrow style (blunt end) and the line width. The second part specifies the coordinates of the line itself and the remainder node[above]{$I$}; indicates what text to draw and where to draw it relative to the line. The real meat is in the drawing line section, that is:

([yshift=4pt]$(S)!.5!(P)$) –++(0,1.5cm)

The basic syntax for a line coordinate is (x1,y1) — (x2,y2). In the example there is a modification to this where the coordinate is specified as (x1,y1) — ++(x2,y2). The ++ means that the coordinate at x2,y2 is computed relative to x1,y1, that is the coordinate at x2,y2 is actually (x1,y1)+(x2,y2). The (0,1.5cm) then means that the coordinate for the end point has the same x coordinate but the y coordinate is displaced upwards by 1.5cm. Note that the tikz y coordinate is like a normal graph plotting axis.

The trickest bit is computing the starting point for the vertical line. Note that this has to be mid point between nodes S and P.  This requires some coordinate calculations. The x,y coordinate is specified by $(S)!.5!(P)$). The bit in front, ([yshift=4pt], just moves the computed y coordinates up 4pts.

The  text inside the  means that we are doing a coordinate calculation,ie $….$ represents a math calculation. (S) and (P) represent the coordinates of the nodes S and P respectively. The important bit is !.5!. The explanation point is a pathway modifier and can be put between two coordinates.

(S)!.5!(P) means compute the coordinate that is half way between (S) and (P).

The last thing to add is that I nocticed that the blunt end was a bit too sort. To widen the blunt end I used the arrow.meta extension package. This allows one to modify the size of the arrow heads, in this case I used the following to widen the blunt end to 5mm.

{|[width=5mm]}-

## Drawing a Pathway Fragment with Inhibition using Tikz

Here is another quick pathway fragment I needed today. This won’t scale well because I’ve used some fixed dimensions eg the width of the lines and the size of the text. But these are easily adjusted if you want to size the figure differently. The node distance = 2.5cm gives the sizes for the arrows except for v3. One might be able to calculate the some of the fixed sizes based on the node distance but I didn’t have time to investigate this.



\documentclass{article}

\usepackage{tikz}
\usetikzlibrary{arrows}
\begin{document}
\begin{tikzpicture}[>=latex',node distance = 2.5cm]
\node (S) {\scalebox{1.4}{$S$}};

\node [left of = S] (Xo) {};
\draw[->,line width = 1.2pt] (Xo) to node[above] {\scalebox{1.3}{$v_1$}} (S);

\node [right of = S] (X1) {};
\draw[->,line width = 1.2pt] (S) to node[above] {\scalebox{1.3}{$v_2$}} (X1);

\node[above of = S, node distance = 1.5cm] (V3) {};
\draw[-|,line width = 1.2pt] (S) to (V3) {};

\node[left of = V3, node distance = 1.25cm] (Xa) {};
\node[right of = V3, node distance = 1.25cm] (Xb) {};
\draw[->,line width = 1.2pt] (Xa) to node[above] {\scalebox{1.3}{$v_3$}} (Xb);
\end{tikzpicture}
\end{document}
 

## Drawing a ‘Futile’ Cycle using Tikz

I was in need of a diagram of a futile cycle. I tried illustator but I didn’t have the right LaTeX fonts so the figure did blend well with the rest of the document. I decided to make one using TiKz. And here it is.


\documentclass{article}

\usepackage{tikz}
\usetikzlibrary{arrows}
\begin{document}

\begin{tikzpicture}[>=latex',node distance = 2.5cm]
\node (S2) {$S_2$};
\node [left of = S2] (S1) {$S_1$};

\node [left of = S1, node distance = 1.5cm] (Xo) {};
\draw[->,thick] (Xo) to node[above] {$v_1$} (S1);

\node [right of = S2, node distance = 1.5cm] (X1) {};
\draw[->,thick] (S2) to node[above] {$v_4$} (X1);

\draw [->,thick] (S2) to [bend left=40] node[below] {$v_3$} (S1);
\draw [->,thick] (S1) to [bend left=40] node[above] {$v_3$} (S2);
\end{tikzpicture}

\end{document}


## Plotting 3D graphs using Python and Tellurium

As an example I wanted to show how one could plot a 3D phase plot. A great example to use for this is the Lorenz Attractor. This system is interesting because it displays chaotic behavior. The differential equations for the system are given by the following three:

Different values for the parameters, sigma, rho and beta, lead to different behaviors. The Python script below that uses Tellurium plots a 3D phase plot:

# The Lorenz Model

# The Lorenz system of equations is the classic set of
# equations which exhibit chaotic dynamics. The equations
# represent a highly simplified model of 2D thermal
# convection known as Rayleigh-Benard convection;

# The three variables, x, y and z represent the
# convective overturning, the horizontal temperature
# and vertical temperature variation respectively;

## The parameters a, b and c represent approximately
# the energy losses within the fluid due to viscosity,
# the temperature difference between the two plates
# which separate the fluid and the ratio of the vertical
# height of the fluid layer to the horizontal extent
# of the convective rolls respectively;
import tellurium as te
from mpl_toolkits.mplot3d import Axes3D
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np

// Define the model in terms of three differential equations;
$s -> x; -a*(x - y);$s -> y; -x*z + b*x - y;
$s -> z; x*y - c*z; a = 10; b = 28; c = 2.67; ''') # Uncomment/comment the following lines to obtain behaviour you wish to observe; # Non-chaotic oscillations; #r.x = 5.43027; r.y = 26.74167; r.z = 46.0098; #r.a = 4; r.b = 91.9; r.c = 2.67; # Single oscillation; #r.x = 32.82341; r.y = -44.84651; r.z = 258.02389; #r.a = 4; r.b = 191.9; r.x = 2.67; # Stable steady-state; #r.x = 0.1; r.y = 0.1; r.z = 0.1; #r.a = 10; r.b = 10; r.c = 2.67; # Chaos r.x = 0.96259; r.y = 2.07272; r.z = 18.65888; m = r.simulate (0, 40, 3000, ['x', 'y', 'z']); fig = plt.figure(figsize=(8,8)) ax = fig.gca(projection='3d') #theta = np.linspace(-4 * np.pi, 4 * np.pi, 100) ax.plot(m[:,0], m[:,1], m[:,2], label='Lorenz Attractor') ax.legend() plt.show()  | Leave a comment ## How do I change the simulation tolerances in Tellurium? For very complicated and large models it may be necessary to adjust the simulator tolerances in order to get the correct simulation results. Sometimes the simulator will terminate a simulation because it was unable to proceed due to numerical errors. In many cases this is due to a bad model and the user must investgate the model to determine what the issue might be. If the model is assumed to be correct then the other option is to change the simulator tolerances. The current option state of the simulator is obtained using the getInfo call, for example: r = roadrunner.RoadRunner ('mymodel.xml') r.getInfo() roadrunner.RoadRunner() { 'this' : 22F59350 'modelLoaded' : true 'modelName' : __main 'libSBMLVersion' : LibSBML Version: 5.13.0 'jacobianStepSize' : 1e-005 'conservedMoietyAnalysis' : false 'simulateOptions' : < roadrunner.SimulateOptions() { 'this' : 1B89AF28, 'reset' : 0, 'structuredResult' : 0, 'copyResult' : 1, 'steps' : 50, 'start' : 0, 'duration' : 20 }, 'integrator' : < roadrunner.Integrator() > name: cvode settings: relative_tolerance: 0.00001 absolute_tolerance: 0.0000000001 stiff: true maximum_bdf_order: 5 maximum_adams_order: 12 maximum_num_steps: 20000 maximum_time_step: 0 minimum_time_step: 0 initial_time_step: 0 multiple_steps: false variable_step_size: false }>  There are a variety of tuning parameters that can be changed in the simulator. Of interest are the relative and absolute tolerances, the maximium number of steps and the initial time step. The smaller the relative tolerance the more accuate the solution, however too small a value will result in either excessive runtimes or more likely rounadoff errors. A relative tolerance of 1E-4 means that errors are controlled to 0.01%. An optimal value is roughly 1E-6. The absoute tolerance is used when a variable gets so small that the relative tolerance don’t make much sense to apply. In these situations the absolute error tolerance is used to control the error. A small value for the absolute tolerance is often desirable, such as 1E-12, we do not recommend going below 1E-15 for either tolerances. To set the tolerances use the statements: r.integrator.absolute_tolerance = 5e-10 r.integrator.relative_tolerance = 1e-3  Another parameter worth changing if the simulations are not working well is to change the initial time step. This is often set by the integrator to be a relatively large value which means that the integrator will try to reduce this value if there are problems. Sometimes it is better to provide a small initial step size to help the integrator get started, for example, 1E-5. r.integrator.initial_time_step = 0.00001  The reader if refered to the CVODE documentation for more details. Posted in Modeling, Pathways, Programming, SBML, Software, Systems Theory | Leave a comment ## How do I plot phase plots using Tellurium? Phase plots are a common way to visualize the dynamics of models where time courses are generated and one variable is plotted against the other. For example consider the following model that can show oscillations:  v1:$Xo -> S1; k1*Xo;
v2:  S1 -> S2; k2*S1*S2^h/(10 + S2^h) + k3*S1;
v3:  S2 -> ;   k4*S2;


In this model S2 positively activates reaction v2 thus forming a positive feedback loop. The rate equation for v2 include a Hill like coefficient term, S2^h, this determines the strength of the positive feedback. The oscillations originate from an interaction between the positive feedback and a non-obvious negative feedback loop at S1 beteen v1 and v2.

Let us assign suitable parameter values to this model, run a simulation and plot S1 versus S2.

import tellurium as te
# Import pylab to access subplot plotting feature.
import pylab as plt

v1: $Xo -> S1; k1*Xo; v2: S1 -> S2; k2*S1*S2^h/(10 + S2^h) + k3*S1; v3: S2 ->$w; k4*S2;

# Initialize
h  = 2; # Hill coefficient
k1 = 1; k2 = 2; Xo = 1;
k3 = 0.02; k4 = 1;
S1 = 6; S2 = 2
''')

m = r.simulate (0, 80, 500, ['S1', 'S2'])
r.plot()


Running this script by clicking the green button in the toolbar yields the following plot:

What if we’d like to investigate how the oscillations are affected by the parmaeters of the model. For example how does the model bahave when we change k1? One way to do this is to plot simulations at different k1 values onto the same plot. In this case however this will create a difficult to read graph. Instead let us create a grid of subplots where each subplot represents a different simulation.

import tellurium as te
import pylab as plt

v1: $Xo -> S1; k1*Xo; v2: S1 -> S2; k2*S1*S2^h/(10 + S2^h) + k3*S1; v3: S2 ->$w; k4*S2;

# Initialize
h  = 2; # Hill coefficient
k1 = 1; k2 = 2; Xo = 1;
k3 = 0.02; k4 = 1;
S1 = 6; S2 = 2
''')

plt.subplots(3,3)
plt.figure(figsize=(12,6))
for i in range (9):
r.reset()
m = r.simulate (0, 80, 500, ['S1', 'S2'])
plt.subplot (3,3,i+1)
plt.plot (m[:,0], m[:,1], "k1=" + str (r.k1))
plt.legend()
r.k1 = r.k1 + 0.2


Here we create a 3 by 3 subplot grid, start a loop that changes k1 and each time round the loop it plots the simulation onto one of the subplots. Running this script results in the following output

## How to get the Stoichiometry Matrix using Tellurium

Here is a simple need, given a reaction model how do we get hold of the stoichiometry matrix?

Consider the following simple model:

import tellurium as te

$Xo -> S1; k1*Xo; S1 -> S2; k2*S1; S2 -> S3; k3*S2; S3 ->$X1; k4*S3;

k1 = 0.1; k2 = 0.4;
k3 = 0.5; k4 = 0.6;
Xo = 1;
""")

print r.getFullStoichiometryMatrix()


Running this script by clicking on the green arrow in the tool bar will yield:

      _J0, _J1, _J2, _J3
S1 [[   1,  -1,   0,   0],
S2  [   0,   1,  -1,   0],
S3  [   0,   0,   1,  -1]]


The nice thing about this output is that the columns and rows are labeled so you know exact what is what.

What about much larger models? For example the iAF1260.xml model from the Bigg database (http://bigg.ucsd.edu:8888/models/iAF1260). This is a model of E. Coli that includes 1668 metabolites and 2382 reactions. We can download the iAF1260.xml file and load it into libRoadRunner using:




This might take up to a minute to load depending on how fast your computer is. We are assuming here that the file is located in the current directory (os.getcwd()). If not, move the file, change the current directory (using os.chdir), or use the appropriate path in the call.

Rather than print out the stoichiometry matrix (don’t even try) to the screen we’ll save it to a file. Because the stoichiometry matrix is so large we will use numpy to write the matrix out as a text file:

import numpy as np
st = r.getFullStoichiometryMatrix()
print "Number of metabolites = ", r.getNumFloatingSpecies()
print "Number of reactions = ", r.getNumReactions()
np.savetxt ('stoich.txt', st)

Number of metabolites = 1668
Number of reactions = 2382


One can change the formating of the output using savetxt, for example the following will output the individual stoichiometry coefficeint using 3 decimal places, 5 characters minimium, and separated by a comma.

np.savetxt ('c:\\tmp\\st.txt', st, delimiter=',', fmt='%5.3f',)


You can get the labels for the rows and columns by calling r.getFloatingSpeciesIds() and r.getReactionIds() respectively.

## How to do a simple simulation using Tellurium

The most common requirement is the ability to carry out a simple time course simulation of a model. Consider the model:

Two reactions and three metabolites, S1, S2 and S3. We can describe this system using an Antimony string:

import tellurium as te

S1 -> S2; k1*S1;
S2 -> S3; k2*S2;

k1= 0.4; k2 = 0.45
S1 = 5; S2 = 0; S3 = 0
''')

m = r.simulate (0, 20, 100)
r.plot()


Run the script by clicking on the green arrow in the tool bar to yield:

## How do I run a stochastic simulation using Tellurium/libRoadRunner?

In this post I will show you how to run a stochastic simulation using our Tellurium application. Tellurium is a set of libraries that can be used via Python. One of those libraries is libRoadRunner which is our very fast simulator. It can simulate both stochastic and detemrinistic models. Let’s illustrate a stochastic simulation using the following simple model:

import tellurium as te
import numpy as np

J1: S1 -> S2;  k1*S1;
J2: S2 -> S3;  k2*S2
J3: S3 -> S4;  k3*S3;

k1 = 0.1; k2 = 0.5; k3 = 0.5;
S1 = 100;
''')


We’ve set up the number of initial molecules of S1 to be 100 molecules. The easiest way to run a stochastic simulation is to call the gillespie method on roadrunner. This is shown in the code below:

m = r.gillespie (0, 40, steps=100)
r.plot()


Running this by clicking on the green button in the tool bar will give you the plot:

What if you wanted to run a lot of gillespie simulations to get an idea of the distribution of trajectories? TO do that just just need ot repeat the simulation many times and plot all the results on the same graph:

import tellurium as te
import numpy as np

J1: S1 -> S2; k1*S1;
J2: S2 -> S3; k2*S2
J3: S3 -> S4; k3*S3;

k1 = 0.1; k2 = 0.5; k3 = 0.5;
S1 = 100;
''')

# run repeated simulation
numSimulations = 50
points = 101
for k in range(numSimulations ):
r.resetToOrigin()
s = r.gillespie(0, 50)
# No legend, do not show
r.plot(s, show=False, loc=None, alpha=0.4, linewidth=1.0)


This script will yield the plot:

We can do one other thing and compute the average trajectory and overlay the plot with the average line. The one thing we have to watch out for is that we must set the integrator property variable_step_size = False to false. This will ensure that time points are equally spaced and that all trajectories end at the same point in time.

import tellurium as te
import numpy as np

J1: S1 -> S2; k1*S1;
J2: S2 -> S3; k2*S2
J3: S3 -> S4; k3*S3;

k1 = 0.1; k2 = 0.5; k3 = 0.5;
S1 = 100;
''')

# run repeated simulation
numSimulations = 50
#points = 101
# Set the physical size of the plot (units are in inches)
plt.figure(figsize=(10,5))
r.setIntegrator ('gillespie')
# Make sure we do this so that all trajectories
# are the same length and spacings
r.getIntegrator().variable_step_size = False
s_sum = np.array(0.)
for k in range(numSimulations):
r.resetToOrigin()
s = r.simulate(0, 100, steps=50)
# no legend, do not show
r.plot(s, show=False, loc=None, alpha=0.4, linewidth=1.0)

# add mean curve, legend, show everything and set labels, titels, ...
s_mean = s_sum/numSimulations
r.plot(s_mean, loc='upper right', show=True, linewidth=3.0,
title="Stochastic simulation", xlabel="time",
ylabel="concentration", grid=True);


This will give us the following plot:

## Computing the steady state using Tellurium

If you’re building a model and you want to quickly find the model’s steady state, you can call the command steadyState. Let’s illustrate this with an example:

import tellurium as te

# Define a simple linear chain of reactions
$Xo -> S1; k1*Xo; S1 -> S2; k2*S1; S2 -> S3; k3*S2; S3 ->$X1; k4*S3;

# Initialize rate constants
k1 = 0.2; k2 = 0.7; k3 = 0.15; k4 = 1.3;
Xo = 10
''')



Running this script by clicking in the green arrow in the tool bar will output the following steady state levels:

[2.85714286  13.33333333   1.53846154]


But which steady state value refers to which species in my model? To find that out call getFloatingSpeciesIds:

print r.getFloatingSpeciesIds()
['S1', 'S2', 'S3']


The order of the speces Ids match the order of steady state values. In other words, S1 = 2.857, S2 = 13.333, and S3 = 1.538.

If you want to check that these values really are the steady state values you can compute the rates of change:

print r.getRatesOfChange()
array([  0.00000000e+00,  -4.44089210e-16,   4.44089210e-16])


If you look carefully all the rates of change are effectively zero, thus confirming we’re at steady state.

What about the stability of the steady state? That is, is it stable to small perturbations in S1, S2 or S3? To find this out we need to compute the eigenvalues of the system Jacobian matrix. If all the eigenvalues are negative this means small pertubrations are damped so that the system returns to the steady state. There are two ways to do this, we can use the getReducedEigenValues call, or we get compute the Jacobian first and then compute the eigenvalues of the Jacobian. Both these approaches are given below. Its probably simplest to call just getReducedEigenValues.

print r.getReducedEigenValues()
[-0.7  -0.15 -1.3 ]


Notice that all the eigenvalues are negative indicating that small perturbations are stable.

This is the alternative approach which computes the Jacobian first and then the eigenvalues of the Jacobian:

print te.getEigenvalues(r.getFullJacobian())
[-0.7  -0.15 -1.3 ]


Note that we’re using a utility method from the tellurium library, getEigenValues to compute the eigenvalues.