Electrostatic models for multicompartment neuron models
Project description
LFPykit
This Python module contain freestanding implementations of electrostatic forward models incorporated in LFPy (https://github.com/LFPy/LFPy, https://LFPy.readthedocs.io).
The aim of the LFPykit
module is to provide electrostatic models
in a manner that facilitates forwardmodel predictions of extracellular
potentials and related measures from multicompartment neuron models, but
without explicit dependencies on neural simulation software such as
NEURON (https://neuron.yale.edu, https://github.com/neuronsimulator/nrn),
Arbor (https://arbor.readthedocs.io, https://github.com/arborsim/arbor),
or even LFPy.
The LFPykit
module can then be more easily incorporated with
these simulators, or in various projects that utilize them such as
LFPy (https://LFPy.rtfd.io, https://github.com/LFPy/LFPy).
BMTK (https://alleninstitute.github.io/bmtk/, https://github.com/AllenInstitute/bmtk),
etc.
Its main functionality is providing class methods that return twodimensional linear transformation matrices M between transmembrane currents I of multicompartment neuron models and some measurement Y given by Y=MI.
The presently incorporated volume conductor models have been incorporated in LFPy (https://LFPy.rtfd.io, https://github.com/LFPy/LFPy), as described in various papers and books:

Linden H, Hagen E, Leski S, Norheim ES, Pettersen KH, Einevoll GT (2014) LFPy: a tool for biophysical simulation of extracellular potentials generated by detailed model neurons. Front. Neuroinform. 7:41. doi: 10.3389/fninf.2013.00041

Hagen E, Næss S, Ness TV and Einevoll GT (2018) Multimodal Modeling of Neural Network Activity: Computing LFP, ECoG, EEG, and MEG Signals With LFPy 2.0. Front. Neuroinform. 12:92. doi: 10.3389/fninf.2018.00092

Ness, T. V., Chintaluri, C., Potworowski, J., Leski, S., Glabska, H., Wójcik, D. K., et al. (2015). Modelling and analysis of electrical potentials recorded in microelectrode arrays (MEAs). Neuroinformatics 13:403–426. doi: 10.1007/s1202101592656

Nunez and Srinivasan, Oxford University Press, 2006

Næss S, Chintaluri C, Ness TV, Dale AM, Einevoll GT and Wójcik DK (2017). Corrected Foursphere Head Model for EEG Signals. Front. Hum. Neurosci. 11:490. doi: 10.3389/fnhum.2017.00490
Build Status
Features
LFPykit
presently incorporates different electrostatic forward models for extracellular potentials
and magnetic signals that has been derived using volume conductor theory.
In volumeconductor theory the extracellular potentials can be calculated from a distanceweighted sum of contributions from transmembrane currents of neurons.
Given the same transmembrane currents, the contributions to the magnetic field recorded both inside and outside the brain can also be computed.
The module presently incorporates different classes. To represent the geometry of a multicompartment neuron model we have:
CellGeometry
: Base class representing a multicompartment neuron geometry in terms of segment x, y, zcoordinates and diameter.
Different classes built to map transmembrane currents of CellGeometry
like instances
to different measurement modalities:
LinearModel
: Base class representing a generic forward model for subclassingCurrentDipoleMoment
: Class for predicting current dipole momentsPointSourcePotential
: Class for predicting extracellular potentials assuming point sources and point contactsLineSourcePotential
: Class for predicting extracellular potentials assuming line sourcers and point contactsRecExtElectrode
: Class for simulations of extracellular potentialsRecMEAElectrode
: Class for simulations of in vitro (slice) extracellular potentialsOneSphereVolumeConductor
: For computing extracellular potentials within sand outside a homogeneous sphereLaminarCurrentSourceDensity
: For computing the 'ground truth' current source density across cylindrical volumes aligned with the zaxisVolumetricCurrentSourceDensity
: For computing the 'ground truth' current source density on regularly spaced 3D grid
Different classes built to map current dipole moments (i.e., computed using CurrentDipoleMoment
)
to extracellular measurements:
eegmegcalc.FourSphereVolumeConductor
: For computing extracellular potentials in 4sphere head model (brain, CSF, skull, scalp) from current dipole momenteegmegcalc.InfiniteVolumeConductor
: To compute extracellular potentials in infinite volume conductor from current dipole momenteegmegcalc.MEG
: Class for computing magnetic field from current dipole momentseegmegcalc.NYHeadModel
: Class for computing extracellular potentials in detailed head volume conductor model (https://www.parralab.org/nyhead)
Each class (except CellGeometry
) should have a public method get_transformation_matrix()
that returns the linear map between the transmembrane currents or current dipole moment
and corresponding measurements (see Usage below)
Usage
A basic usage example using a mock 3segment sticklike neuron, treating each segment as a point source in a linear, isotropic and homogeneous volume conductor, computing the extracellular potential in ten different locations alongside the cell geometry:
>>> # imports
>>> import numpy as np
>>> from lfpykit import CellGeometry, PointSourcePotential
>>> n_seg = 3
>>> # instantiate class `CellGeometry`:
>>> cell = CellGeometry(x=np.array([[0.] * 2] * n_seg), # (µm)
y=np.array([[0.] * 2] * n_seg), # (µm)
z=np.array([[10. * x, 10. * (x + 1)]
for x in range(n_seg)]), # (µm)
d=np.array([1.] * n_seg)) # (µm)
>>> # instantiate class `PointSourcePotential`:
>>> psp = PointSourcePotential(cell,
x=np.ones(10) * 10,
y=np.zeros(10),
z=np.arange(10) * 10,
sigma=0.3)
>>> # get linear response matrix mapping currents to measurements
>>> M = psp.get_transformation_matrix()
>>> # transmembrane currents (nA):
>>> imem = np.array([[1., 1.],
[0., 0.],
[1., 1.]])
>>> # compute extracellular potentials (mV)
>>> V_ex = M @ imem
>>> V_ex
array([[0.01387397, 0.01387397],
[0.00901154, 0.00901154],
[ 0.00901154, 0.00901154],
[ 0.01387397, 0.01387397],
[ 0.00742668, 0.00742668],
[ 0.00409718, 0.00409718],
[ 0.00254212, 0.00254212],
[ 0.00172082, 0.00172082],
[ 0.00123933, 0.00123933],
[ 0.00093413, 0.00093413]])
A basic usage example using a mock 3segment sticklike neuron, treating each segment as a point source, computing the current dipole moment and computing the potential in ten different remote locations away from the cell geometry:
>>> # imports
>>> import numpy as np
>>> from lfpykit import CellGeometry, CurrentDipoleMoment, \
>>> eegmegcalc
>>> n_seg = 3
>>> # instantiate class `CellGeometry`:
>>> cell = CellGeometry(x=np.array([[0.] * 2] * n_seg), # (µm)
y=np.array([[0.] * 2] * n_seg), # (µm)
z=np.array([[10. * x, 10. * (x + 1)]
for x in range(n_seg)]), # (µm)
d=np.array([1.] * n_seg)) # (µm)
>>> # instantiate class `CurrentDipoleMoment`:
>>> cdp = CurrentDipoleMoment(cell)
>>> M_I_to_P = cdp.get_transformation_matrix()
>>> # instantiate class `eegmegcalc.InfiniteVolumeConductor` and map dipole moment to
>>> # extracellular potential at measurement sites
>>> ivc = eegmegcalc.InfiniteVolumeConductor(sigma=0.3)
>>> # compute linear response matrix between dipole moment and
>>> # extracellular potential
>>> M_P_to_V = ivc.get_transformation_matrix(np.c_[np.ones(10) * 1000,
np.zeros(10),
np.arange(10) * 100])
>>> # transmembrane currents (nA):
>>> imem = np.array([[1., 1.],
[0., 0.],
[1., 1.]])
>>> # compute extracellular potentials (mV)
>>> V_ex = M_P_to_V @ M_I_to_P @ imem
>>> V_ex
array([[ 0.00000000e+00, 0.00000000e+00],
[ 5.22657054e07, 5.22657054e07],
[ 1.00041193e06, 1.00041193e06],
[ 1.39855769e06, 1.39855769e06],
[ 1.69852477e06, 1.69852477e06],
[ 1.89803345e06, 1.89803345e06],
[ 2.00697409e06, 2.00697409e06],
[ 2.04182029e06, 2.04182029e06],
[ 2.02079888e06, 2.02079888e06],
[ 1.96075587e06, 1.96075587e06]])
Physical units
Notes on physical units used in LFPykit
:

There are no explicit checks for physical units

Transmembrane currents are assumed to be in units of (nA)

Spatial information is assumed to be in units of (µm)

Voltages are assumed to be in units of (mV)

Extracellular conductivities are assumed to be in units of (S/m)

current dipole moments are assumed to be in units of (nA µm)

Magnetic fields are assumed to be in units of (nA/µm)
Dimensionality

Transmembrane currents are represented by arrays with shape
(n_seg, n_timesteps)
wheren_seg
is the number of segments of the neuron model. 
Current dipole moments are represented by arrays with shape
(3, n_timesteps)

Response matrices M have shape
(n_points, input.shape[0])
wheren_points
is for instance the number of extracellular recording sites andinput.shape[0]
the first dimension of the input; that is, the number of segments in case of transmembrane currents or 3 in case of current dipole moments. 
predicted signals (except magnetic fields using
eegmegcalc.MEG
) have shape(n_points, n_timesteps)
Documentation
The online Documentation of LFPykit
can be found here:
https://lfpykit.readthedocs.io/en/latest
Dependencies
LFPykit
is implemented in Python and is written (and continuously tested) for Python >= 3.7
.
The main LFPykit
module depends on numpy
, scipy
and MEAutility
(https://github.com/alejoe91/MEAutility, https://meautility.readthedocs.io/en/latest/).
Running all unit tests and example files may in addition require py.test
, matplotlib
,
neuron
(https://www.neuron.yale.edu),
(arbor
coming) and
LFPy
(https://github.com/LFPy/LFPy, https://LFPy.readthedocs.io).
Installation
From development sources (https://github.com/LFPy/LFPykit)
Install the current development version on https://GitHub.com using git
(https://gitscm.com):
$ git clone https://github.com/LFPy/LFPykit.git
$ cd LFPykit
$ python setup.py install # user optional
or using pip
:
$ pip install . # user optional
For active development, link the repository location
$ python setup.py develop # user optional
Installation of stable releases on PyPI.org (https://www.pypi.org)
Installing from the Python Package Index (https://www.pypi.org/project/lfpykit):
$ pip install lfpykit # user optional
To upgrade the installation using pip:
$ pip install upgrade nodeps lfpykit
Installation of stable releases on condaforge (https://condaforge.org)
Installing lfpykit
from the condaforge
channel can be achieved by adding condaforge
to your channels with:
$ conda config add channels condaforge
Once the condaforge
channel has been enabled, lfpykit
can be installed with:
$ conda install lfpykit
It is possible to list all of the versions of lfpykit
available on your platform with:
$ conda search lfpykit channel condaforge
Project details
Release history Release notifications  RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Filename, size  File type  Python version  Upload date  Hashes 

Filename, size LFPykit0.3py3noneany.whl (67.1 kB)  File type Wheel  Python version py3  Upload date  Hashes View 
Filename, size LFPykit0.3.tar.gz (1.4 MB)  File type Source  Python version None  Upload date  Hashes View 