Team:Edinburgh/Cellulases (C model)
Cellulases (C model)
As explained in the abstract, the feasibility of our improved biorefineries depends on exploiting synergy between enzymes. Therefore, we attempted to use the C programming language to construct a model which could prove that synergy is, or might be, a real phenomenon affecting cellulase action.
It can seem almost magical that having enzymes closer together can increase their usefulness, but consider the following statements about cellulose degradation, all of which are true (Fontes and Gilbert, 2010):
- Exoglucanase chews away at the end of a cellulose chain, producing cellobiose sugars.
- Endoglucanase cuts cellulose chains in the middle, essentially turning one chain into two.
- Cellobiose inhibits the action of the above enzymes.
- β-glucosidase cuts cellobiose in half, producing two glucose molecules.
Facts 1 and 2 mean that exoglucanase works best with endoglucanase nearby, since every time endoglucanase acts, it produces new chain-ends for exoglucanase to attack. Meanwhile, facts 1, 3, and 4 mean that β-glucosidase helps nearby copies of the other enzymes by preventing the cellobiose from inhibiting them.
Syn: a simple demonstration of synergy
We can demonstrate that there is (potentially) a huge difference between the synergistic and non-synergistic systems with Edinburgh's Syn program, written in C. This is a 2D simulation that works in the following way:
- The world is a 2D grid.
- Each spot in the grid can contain a sugar, a bond between sugars, or nothing.
- The world begins with an array of cellulose.
- Cellulose is modelled as horizontal chains with alternating sugars and bonds: s-b-s-b-s-b-s-b-s-b-s, etc.
- There are three enzyme types: endoglucanase, exoglucanase, and β-glucosidase.
- The enzymes move about randomly in manner similar to Brownian motion.
- If an enzyme is in the same place as a bond, it can destroy it:
- Endoglucanase only cuts bonds away from the ends of a chain (some minimum distance is specified).
- Exoglucanase only cuts bonds if this results in a cellobiose molecule (s-b-s) forming.
- β-glucosidase only cuts cellobiose bonds.
- There is inhibition of exoglucanase by cellobiose; it does not cut bonds (or has a reduced chance to do so) if there is a nearby cellobiose molecule.
So, the actions of the enzymes are as follows:
Simulating non-synergy vs. synergy
We can run two different simulations with the same settings. However, in one simulation the enzymes float about freely, whereas in the other they travel in triplets, each triplet containing one of each type of enzyme, side by side (this animation seems to work rather poorly in Safari):
So, what happens if we run a large simulation? This:
You can view an animation of a similar run to the above, here.
Warning: 1.5 MB file, has been known to hang certain browsers...
This model is not intended as an accurate reflection of reality, but rather a simple demonstration that synergy works. The actual results seen depend heavily on the parameters passed to the program as command-line arguments. Among the relevant settings are the number of enzymes, the size of the cellulose array, and the strength of cellobiose inhibition.
Some standard settings are used for parameters the user does not otherwise specify. These standard settings are fairly arbitrary, but they provide baseline results; we can then provide other parameters and see what difference they make.
We carried out 100 runs of the program with standard settings (20 of each enzyme per side, width and height 155, full inhibition of exoglucanase by nearby cellobiose, endoglucanase requiring at least 5 sugars on each side of a bond to cut it).
On average, it took the synergistic system 7522 iterations to liberate half the sugar (i.e. turn it into glucose monosaccharides), as opposed to 13878 for the non-synergistic system.
We can graph the progress of a typical run by counting the number of sugars present:
- As free glucose molecules, not bonded to anything.
- As one half of a cellobiose molecule.
- As part of a longer chain (cellulose).
For graphing purposes let us define cellulose as any chain with three or more sugars bonded together (meaning s-b-s-b-s is the smallest chain that counts as "cellulose"). Figure 4 is a graph of the number of sugar molecules present in each form:
Effect of increased enzyme concentration
One obvious thing to try is increasing the enzyme concentration. Naturally, this will decrease the time taken to degrade the cellulose. But it also has a more subtle effect: since the enzymes are at higher density, they are automatically close to each other. Thus, even the model of free-floating enzymes has a sort of built-in synergy, and the result is rather similar to the explicitly synergistic model.
This is illustrated by Figure 5, which uses 500 enzymes of each type, instead of 20 (note carefully the different X axis):
Effect of (no) cellobiose inhibition
Under standard settings, exoglucanase is completely inhibited if there is a nearby cellobiose molecule. This reflects the real-world fact that enzymes are generally inhibited by their own products.
We can disregard this assumption and see what happens (Figure 6). Since exoglucanase now works at higher efficiency, the amount of cellobiose that builds up is greater, but the time taken to degrade the cellulose is less. And since exoglucanase is no longer assisted by β-glucosidase, the value of synergy is less:
Despite the simplicity of the model, it showed broadly similar results to the more complex Kappa model. Both have shown that synergy actually makes sense!
- Source code:
- Windows executable:
There are two ways to compile the code. The first is to just compile the C file as it stands, using a command like "gcc syn.c". When compiled in this way, there is no graphical display, except that the program saves .bmp graphics files every so often.
However, if you have the SDL graphics library development files (called libsdl1.2-dev in Ubuntu), you can optionally download the Makefile and compile with "make". This version does not (by default) spit out any files; instead, it gives a graphical display of the action as it occurs.
Note that, to work, the Makefile should be called "Makefile" and the C file should be called "syn.c".
The following command-line options should work. Default values are shown where applicable. (The default endpoint and bmptick depend on whether SDL support is compiled in.)
- --width 155 — width of each simulation
- --height 155 — height of each simulation
- --margin 4 — size of the margin (region of no cellulose)
- --enzymes 20 — number of enzymes of each type per simulation
- --endpoint x — how many iterations to run (0 for unlimited)
- --seed x — use specified random seed (results may still differ across platforms)
Cellobiose inhibition of exoglucanase
- --bioseinhib 1.0 — strength of cellobiose inhibition of exoglucanase, from 0 to 1
- --bioseinhibleft 1.0 — as above, but sets value for left simulation only
- --bioseinhibright 1.0 — as above, but sets value for right simulation only
- --endoreq 5 — how close to the end of a chain endoglucanase can cut
- --endoreqleft 5 — as above, but sets value for left simulation only
- --endoreqright 5 — as above, but sets value for right simulation only
- --nosyn — do not use synergy on either side
- --bothsyn — use synergy on both sides
Display and reporting
- --bmptick x — how often to spit out .bmp graphics files (0 for never)
- --bmpmag 1 — magnification of .bmp files
- --sdltick 1 — how often to draw to the SDL window (1 to draw every frame)
- --sdlmag 2 — magnification of SDL window
- --delay 20 — milliseconds to delay after drawing to SDL window; some machines require this
- --reporttick 250 — how often to print count of glucose and cellobiose to the console (0 for never)
- Fontes CMGA, Gilbert HJ (2010) Cellulosomes: highly efficient nanomachines designed to deconstruct plant cell wall complex carbohydrates. Annual Review of Biochemistry 79: 655-81 (doi: 10.1146/annurev-biochem-091208-085603).