Team:BCCS-Bristol/Modeling/Antos

From 2009.igem.org

(Difference between revisions)
(Antos)
Line 38: Line 38:
===temp===
===temp===
-
==== Antos ====
+
==== temp historical bits of work list====
*BSim GRNs
*BSim GRNs

Revision as of 13:36, 15 September 2009

BCCS-Bristol
iGEM 2009

Contents

Notes

ODE Solvers and Libraries already in existence

Looking around the web it seems that Java ODE solvers are not readily available. Maybe this is because everyone loves C, nonetheless there were a couple of Java examples available...

OdeToJava

Really nice, but seems too advanced for what we need, would also require a few changes. Many people seem to use this, in fact it seems pretty standard across the board and appears to have been implemented in many scientific projects (need to check this, they might just have the same name).

ODE section on Netlib and OdeToJava. The thesis (Murray D Patterson) which documents the creation of this library.

OK this group seem to use parts of it and are in fact modelling GRNs (handy). Why do I find these things when I'm writing rather than a week ago?

ImageJ, BIJ

Good descriptions, Javadoc etc but I think there was a problem that they use OdeToJava and don't actually include the source code, so its not really a new library as such.

Links:

ImageJ

BIJ

Similarly

I really like this but again it goes into some advanced methods which are not really necessary for our current purposes.

http://www.ee.ucl.ac.uk/~mflanaga/java/RungeKutta.html

In Conclusion...

I had already coded the Runge Kutta part of the BSim solvers by the time I found these, but it is interesting to see how other people have incorporated this standard algorithm. As it is essentially a simple piece of code I would say that our implementation is currently sufficient. As BSim gets more advanced, it may be necessary to incorporate some of these more complex libraries and routines, but with the custom features we require I think it is best to stick with coding our own methods.

  • Most of the available libraries start with 4th order runge kutta and get more complicated (stiffness, predictor-corrector, variable time steps), which is too advanced for our currnt needs.
  • BSim operates on a fixed time step basis, therefore all we really require is an algorithm for numerically solving an ODE or system of ODEs for a single time step. I suppose we could just re-use certain methods from other libraries rather than the parts which iterate over a longer period of time, however:
  • From what I have seen, GRNs and the sort of chemical reactions we are currently concerned with operate over a time scale of tens of minutes (less than this is quite rare) to a few hours. In contrast BSim uses a small time step of maximum 0.01s (even this is considered large). If we are integrating GRN equations with such a small time-step I believe a complicated ODE algorithm is not really necessary (apart from maybe to optimise speed, however this should be a later step).
  • We would like to make GRNs interact with the chemical field, so it would seem wise to adapt our own simple code to fit nicely with what is already there rather than figuring out new code.
  • We would like to simulate stochasticity in our GRNs, and none of the libraries I found could do this natively. This is another layer of complexity and is a fairly varied field so I think it is best to implement a solution for our specific situation. Also we already have some built in functions for random variables which we can reuse.
  • ODEs are not just for GRNs! We can use a very simple and adaptable ODE implementation to help us model other aspects of biological systems, in fact we have already thought about how this sort of approach affects the modelling of vesicles (though this would interact with the GRN approach).

temp

temp historical bits of work list

  • BSim GRNs
    • BSimChemicalField generalisation and better integration with scene, rendering etc.
    • Proof of concept to check functionality. Something like this
      • Update: it works! (r140) Need to run large scale simulation to check for long term synchronization...
      • Compare chemical field with degradation to vesicular transport.
    • Java implementation of Runge-Kutta 4th order solver. r70
      • Refactor ODEs from an interface to an abstract class if necessary. EDIT: interface seems sufficient so far, however need to generalise ODEs to just one interface.
    • Investigate other options in terms of external libraries (eg odeToJava - good but seems overcomplicated for current purposes; hundreds of lines of code for one solver routine)done
    • Implement the solvers into BSim. Done for single bacterium
    • Implement other solvers (more efficient). r70
      • The ability to choose between solvers. This will be in a parameter file or some equivalent settings when importing an ODE file.
    • Extend to Stochastic ODEs. However, how much stochasticity is inherent in our system? autoinducer chemical field is intrinsically random due to motion of bacteria.
    • Interface BSim with external parameters (maybe similar to current parameter files) used to define an ODE system.
      • Investigate the feasibility of SBML parameters or a similar XML based format. SBML may be overcomplicated for our current needs. Low priority for now.
      • Similarly investigate the format used by XPP (may be more succinct, also is specifically for ODEs).
      • If we use JYaml for parameters this may be possible through that.
    • Investigate and implement GRN (ODE) and chemical field interaction. r139
      • Study implementation of 3D diffusion in BSim. Seems to work fine
      • Implement diffusion in/out terms for membrane diffusion. r139 - diffusion in/out based on the two relative concentrations
    • GRN interaction with vesicle budding and chemical transport (on the surface of the vesicle and inside it).
    • Incorporate a method for seeing the effects of GRN activity.
      • Colour changes works but needs reimplementation in new renderer
      • Time series: could have pop-out, need to fix the data export to allow exporting a time series.
  • New and updated BSim documentation?
  • BSim graphics
    • New rendering framework r182
      • Add boundaries when they're implemented again.
      • Re-implement chemical field(s).
    • Rod shape rotation. r125
    • Basic BSimChemicalField drawing in 3D - will help with grns with a diffusing chemical. r124
      • but needs to be improved in terms of speed Done (removed lighting on chemical field :-s) this is pretty much the limit of optimisations possible without more in depth OpenGL work.
    • GRN/quorum field Done, but needs visual improvements due to high dynamic range of chemical levels.
    • Investigate (OpenGL?) volume rendering (Tom - Vidi?) maybe better for arbitrary (GRN diffusion) chemical fields A definite possibility in OpenGL, probably possible in P3D for (large?) speedups.
  • GRNs and vesicles
    • Read more about the mechanics of different GRNs (specifically switches).
    • Find out how they interact with the external environment.
    • Investigate the possiblity of using a different time-step to the fixed one in BSim. Can use a longer or shorter time-step if required, however need to finish other parts to see if this would be relevant/important.
    • Investigate the effect of different time steps (GRNs operate on a time scale relatively long compared to that of BSim).
    • Investigate the mechanics of our GRNs with respect to vesicle budding and communication.
    • Investigate methods for numerically solving stochastic ODEs.