|
|
| (4 intermediate revisions by 2 users not shown) |
| Line 1: |
Line 1: |
| − | == Basics ==
| + | Welcome to the <code>transsys</code> tutorials page. |
| | | | |
| − | transsys provides a concise and powerful language for describing gene regulatory networks (GRNs). Networks are described in units that correspond to the key biological objects: genes and gene products, called "factors" in transsys parlance. A transsys program enables simulating the dynamics of gene expression, and thus to study the dynamical properties of GRNs. transsys uses object oriented concepts, and this enables the use of transsys models as components for integrated, "multi-scale" models. The object oriented structure also provides a basis for developing tools for validating transsys against molecular data, as well as its use as a source of realistic simulated gene expression data. | + | * [[transsys Installation]] (in progress): This tutorial walks you through the steps of installing <code>transsys</code> on a Linux system. |
| − | | + | * [[transsys Language Basics Tutorial]]: This tutorial gets you started with modelling your gene regulatory networks by coding them up in the <code>transsys</code> language. |
| − | | + | * [[SimGenex]]: An introduction to the <code>SimGenex</code> language that you can use to describe your gene expression experiments, and to simulate them on your computer. This allows you to assess your <code>transsys</code> models by comparing simulated gene expression profiles to empirically measured ones. |
| − | === transsys Programs ===
| + | * [[L-transsys Tutorial]] (not yet available): This tutorial will show you how to to model plant morphogenesis using Lindenmayer systems parameterised with <code>transsys</code> programs. |
| − | | + | * [[Python API Tutorial]] (not yet available): This tutorial will get you started with combining <code>transsys</code> network models and computational phenotype models written in Python. Read this if you plan to build multiscale models that integrate gene expression dynamics with phenotypic processes and features. |
| − | Gene regulatory networks (GRNs) are specified by '''transsys programs'''. A transsys program consists of the keyword <code>transsys</code>, followed by a name and a '''block''' containing the actual GRN specification. The block contains '''factor declarations''' and '''gene declarations''', as described below. The block may be empty.
| |
| − | | |
| − | === Minimal and Useless Example ===
| |
| − | A minimal, empty transsys program is
| |
| − | | |
| − | transsys emptyexample
| |
| − | {
| |
| − | }
| |
| − | | |
| − | Here, the program's name is "<code>emptyexample</code>". As you may correctly expect, this program is entirely incapable of doing anything interesting, as it is devoid of any content. It's just technically a complete transsys program, somewhat like an empty wallet is still techically a complete wallet. So let's look at what we can use to fill our transsys program.
| |
| − | | |
| − | === Factor Declarations ===
| |
| − | | |
| − | Factors are transsys's representations of gene products. During a transsys simulation, each factor is characterised by its '''expression level''', i.e. its amount or concentration. Factors are characterised by a '''decay rate'''. They also have a '''diffusibility''', which is provided as a facility for constructing models with (possibly complex) spatial structures but not used by the core simulator. The declaration of a factor <code>myfirstfactor</code> with a decay rate of 0.1 and a diffusibility of 0.04711 would for example look like this:
| |
| − | factor myfirstfactor
| |
| − | {
| |
| − | decay: 0.1;
| |
| − | diffusibility: 0.04711;
| |
| − | }
| |
| − | You could stick this factor declaration into the empty transsys program shell shown above and obtain another valid transsys program. This program would enable you to simulate the temporal dynamics of <code>myfirstfactor</code>. But because there is no gene that encodes <code>myfirstfactor</code>, it's expression level will always be 0, and the "dynamics" will thus be a flat line. Obviously, that's not particularly interesting but you can have a look at that [http://www.transsys.net//cgi-bin/demo.cgi?transsys_program=transsys+myfirstexample%0A{%0A++factor+myfirstfactor%0A++{%0A++++decay%3a+0.1%3b%0A++++diffusibility%3a+0.04711%3b%0A++}%0A}%0A&num_timesteps=200 here]. For more interesting dynamics, we have to add a gene.
| |
| − | | |
| − | === Gene Declarations ===
| |
| − | | |
| − | As a geneticist you expect that a gene encodes a product, and also that it has some regulatory information that determines which transcription factors regulate the gene's expression. That's exactly how transsys models a gene. Gene declarations are divided into a <code>promoter</code> block which contains the regulatory information and a <code>product</code> block which specifies the factor that is the gene's product. The <code>promoter</code> block may contain many '''promoter elements'''. The simplest promoter element is <code>constitutive</code>, which determines a rate at which the gene is expressed constitutively, i.e. independently of any transcription factors. So, a simple gene that is constitutively expressed and encodes the factor <code>myfirstfactor</code> would look like this:
| |
| − | gene myfirstgene
| |
| − | {
| |
| − | promoter
| |
| − | {
| |
| − | constitutive: 0.2;
| |
| − | }
| |
| − | product
| |
| − | {
| |
| − | default: myfirstfactor;
| |
| − | }
| |
| − | }
| |
| − | By adding that to our transsys program we arrive at the introductory example that concludes the basics.
| |
| − | | |
| − | === Introductory Example ===
| |
| − | | |
| − | The following is a transsys program comprised of one factor, <code>myfirstfactor</code> and one gene, called <code>myfirstgene</code>, which encodes that factor:
| |
| − | | |
| − | transsys myfirstexample
| |
| − | {
| |
| − | factor myfirstfactor
| |
| − | {
| |
| − | decay: 0.1;
| |
| − | diffusibility: 0.04711;
| |
| − | }
| |
| − |
| |
| − | gene myfirstgene
| |
| − | {
| |
| − | promoter
| |
| − | {
| |
| − | constitutive: 0.2;
| |
| − | }
| |
| − | product
| |
| − | {
| |
| − | default: myfirstfactor;
| |
| − | }
| |
| − | }
| |
| − | }
| |
| − | You can see a demo of this [http://www.transsys.net//cgi-bin/demo.cgi?transsys_program=transsys+myfirstexample%0A{%0A++factor+myfirstfactor%0A++{%0A++++decay%3a+0.1%3b%0A++++diffusibility%3a+0.04711%3b%0A++}%0A%0A++gene+myfirstgene%0A++{%0A++++promoter%0A++++{%0A++++++constitutive%3a+0.2%3b%0A++++}%0A++++product%0A++++{%0A++++++default%3a+myfirstfactor%3b%0A++++}%0A++}%0A}%0A&num_timesteps=200 here].
| |
| − | | |
| − | ==== Analysis: Equilibrium Expression Level ====
| |
| − | | |
| − | As you'll see, the expression level of <code>myfirstfactor</code> starts out at 0 and converges towards 2. The initial expression level of 0 is just an arbitrary starting point provided by the simulator. However, the convergence towards an expression level of 2 is a property of your transsys program: At an expression level of 2, the amount of <code>myfirstfactor</code> that decays in each time step is the decay rate times the expression, i.e. 0.1 * 2 = 0.2. By virtue of the <code>constitutive</code> element in <code>myfirstgene</code> the amount of <code>myfirstfactor</code> synthesised per time step is 0.2. So, at the expression level of 2, decay and synthesis cancel each other out exactly. That's why the expression level of 2 is an '''equilibrium expression level'''. In dynamical systems parlance, this is a '''fixed point attractor'''. For this simple program it's relatively straightforward to convince yourself that 2 is indeed the only equilibrium level (or the only fixed point) -- so we'll leave that as an exercise for you.
| |
