The fidelity of OpenWorm to its biological counterpart, C. elegans, depends on the realism of its constituent parts, such as computationally-modelled cells. The internal dynamics of these cells are largely controlled by ion channels, so a biophysically-informed ion channel model will, in-turn, support a realistic model of the entire organism.
Broadly speaking, the team for this project will develop a workflow and tools to simulate C. elegans cell dynamics using simulated ion channel (intracellular) dynamics.
The literature will be mined for scientific papers with ion channel data, which will be fed to the ChannelWorm pipeline. Inside the pipeline, data are extracted from the papers by various means, including digitization of figures. These data are then used to construct ion channel models.
Each ion channel model is simulated and, depending on its performance in a set of validation tests, takes one of two paths. If the model passes validation, it is stored in the project's database (PyOpenWorm) for later use. Otherwise the model fails validation, and is used as input for the optimization package. After tuning a model's parameters to the literature values, the model is updated, simulated, and passed to the validation phase again. This loop of modeling, validation and optimization may take several runs before a model passes.
Once the ion channel models are successfully validated and stored in the PyOpenWorm database, they can be incorporated into cellular models in both the Muscle Model and c302 (Neuron) subprojects. In each of these sections - PyOpenWorm database, Muscle Model and c302 - there are corresponding validation tests that ensure the integrity of their respective components. The validation tests will employ a similar approach in each subproject, and will be written using the same framework.
Issues for this set of projects are organized on our waffle board, and may give a clearer picture of what is going on in each of them.
Below is a similarly organized board keeping track of our higher-level milestones in each repository (in the Muscle / Neuron / Channel list), which will be updated as this meta-project develops.
Modeling / Validation / Optimization Loop
This figure describes, in a general way, how ion channel models are simulated and incrementally fit to their observed counterparts, as will be done in the ChannelWorm subproject.
Depending on the type of data being used (e.g. patch-clamp data or homology modelling), the implementation will differ, but our approach will still follow this pattern.
Let's take an example channel model being compared to patch-clamp data from the literature:
- We have a given channel model (ex: ca_boyle)
- Run it through simulating scripts (ex: Rayner's scripts)
- These scripts give us a simulate I/V curve, which can be compared to a digitized I/V curve from the literature (example digitized curve)
- Depending on the result of a test comparing these two I/V curves, the model is either kept or optimized further using NeuroTune.
Model Completion Dashboard
This is one possible interface that will display the results of the unifying modeling activity.
This interface allows a user to drill down into our model, and view the states of completion of modeled components at each level. At the highest level, matrices display, using a color indicator, the level of completion of each cell in the model.
By clicking one of these cells, the section below focuses on that cell. Ion channels that exist in that cell are displayed in a grid with completion coloring, and simulation/experimental data for the cell is compared in plots.
Individual ion channels can be clicked on and selected from the grid, with parameters and simulation/experimental comparison plots available.
Rolling over the data displayed at each level gives information about the references for that particular piece of data.
Clicking on the image below will let you view the raw drawing, and see more detailed annotations for each element.
The ChannelWorm subproject is, at a high level, a pipeline to convert ion channel data found in scientific papers into ion channel models. This pipeline involves:
- Identification of papers with ion channel data.
- Extraction of data from these papers, including figures, active parameters and tabular data.
- Digitization of figures, and more generally, converting this information into machine-readable form.
We are tracking milestones for this project over here.
The tasks ahead include:
- Run Rayner's scripts on an example cell, and get output.
- Establish common format between outputs of Rayner's script (above) and digitized plots from scientific articles.
- Write test to compare digitized plots and plots generated from ion channel model.
The Neurotune package provides neurotune a package for optimizing electrical models of excitable cells.
In other words, Neurotune provides a solution for optimizing the parameters of a model to match a specific output. In the case of ChannelWorm, the parameters are electrical ion channel parameters, and the desired output is patch-clamp data comparable to that observed in real life.
PyOpenWorm Unified Data Access Layer
PyOpenWorm will be used in the information storage aspect of various other subprojects. For instance, ChannelWorm will use its own fork of PyOpenWorm to store Ion Channel data and models that it retrieves from scientific papers. Next steps involve:
- Adapting PyOpenWorm's existing infrastructure to serve ChannelWorm
- Filling the database with information, being sure to tag each fact with sources along the way.
- Finalize remaining issues for PyOpenWorm version alpha0.5
- Document Neuron Ion Channels: Types
- Document Ion channels: Research Claims
Issues for PyOpenWorm are tracked on Github.
The muscle model subproject is concerned with modelling and simulation at the cellular level, specifically attempting to simulate the electrical dynamics of a C. elegans body wall muscle cell.
This depends on what happens in ChannelWorm, since ion channel dynamics are integral to our simulation of membrane dynamics.
Because the muscle cell is driven both by an electrical model and a mechanical model, it is a focus of integration between different algorithms. Previously we have created a separate repository for the muscle model that is an adaptation of the work by Boyle & Cohen, 2008. We have an approximately working version implemented in NEURON and are porting this to be fully NeuroML2 compliant.
The electrical side of the model is currently the focus of the OpenWorm Muscle / Neuron Team. You can connect with the team on real time chat.
To catch up with recent developments of this team, please see the following resources:
- Meeting #1 (YouTube Video) (Agenda)
- Meeting #2 (YouTube Video) (Agenda)
- Synapse journal club (YouTube Video) (Slides)
- Meeting #3 (YouTube Video) (Agenda)
Some additional background materials that will help explain neuroscience concepts relevant to to this in two minutes each are below:
- Implementation of Boyle & Cohen muscle model in python
- Conversion of model into NEURON
- Simulation of NeuroML2 ion channels in LEMS
Some of the next steps for the muscle model subproject include:
- Create unit test on the full muscle model that reproduces Figure 1A from Liu, Hollopeter, & Jorgensen 2009
- Create unit test that verifies correct I/V curve for ca_boyle NML2 channel
- Update optimization.py to run with neurotune instead of optimalneuron
Issues for the muscle model are tracked on Github.
The c302 subproject is an effort to simulate the connectome of C. elegans, which includes its 302 neurons. The neural dynamics will start out with biologically-unrealistic integrate and fire cells, and be replaced with incrementally more realistic dynamics, as tests pass. Like the musclemodel, dynamics of neurons depend on ion channel dynamics within the cells, and thus depend on the channelworm subproject.
- Generate NeuroML2 using libNeuroML combined with connectivity data
- Run simulations of the connectome in LEMS using jNeuroML or pyNeuroML
- Create validation tests using SciUnit or a similar framework.
- Run validation tests.
Issues for c302 are tracked in the CElegansNeuroML repo.