def cellsim(stimamp0=0.055, stimamp1=0.0, **kwargs):
cell = InterneuronTemplate(**kwargs)
PPparams0 = {
'idx': 0,
'pptype': 'IClamp',
'delay': 100,
'dur': 900,
'amp': stimamp0
}
PPparams1 = {
'idx': 0,
'pptype': 'IClamp',
'delay': 0,
'dur': 20000,
'amp': stimamp1,
}
if stimamp0 != 0:
stim0 = LFPy.StimIntElectrode(cell, **PPparams0)
if stimamp1 != 0:
stim1 = LFPy.StimIntElectrode(cell, **PPparams1)
cell.simulate(rec_vmem=True)
return cell
def exercise2(soma_clamp_params, apic_clamp_params, electrode_parameters, noise_level):
### MAKING THE CELL
cell_parameters = {
'morphology': 'A140612.hoc',
'v_init': -62,
'passive': False,
'nsegs_method': None,
'dt': 2**-3, # [ms] Should be a power of 2
'tstart': -50, # [ms] Simulation start time
'tstop': 50, # [ms] Simulation end time
'custom_code': ['cell_model.hoc'] # Loads model specific code
}
cell = LFPy.Cell(**cell_parameters)
### MAKING THE INPUT
apic_clamp_params['idx'] = cell.get_closest_idx(x=-150., y=750., z=0.)
cl_soma = LFPy.StimIntElectrode(cell, **soma_clamp_params)
cl_apic = LFPy.StimIntElectrode(cell, **apic_clamp_params)
cell.simulate(rec_imem=True, rec_vmem=True)
### MAKING THE ELECTRODE
electrode = LFPy.RecExtElectrode(cell, **electrode_parameters)
electrode.calc_lfp()
### PLOTTING THE RESULTS
cell_plot_idxs = [soma_clamp_params['idx'], apic_clamp_params['idx']]
cell_idx_colors = {cell_plot_idxs[idx]: plt.cm.Greens_r(1./(len(cell_plot_idxs) + 1) * idx + 0.1) for idx in range(len(cell_plot_idxs))}
elec_idx_colors = {idx: plt.cm.Reds_r(1./(len(electrode_parameters['x']) + 1) * idx) for idx in range(len(electrode_parameters['x']))}
plt.figure(figsize=(16,9))
# Plotting the morphology
plt.subplots_adjust(hspace=0.5, wspace=0.5)
plt.subplot(141, aspect='equal', xlabel='x [$\mu m$]', ylabel='y [$\mu m$]', xlim=[-400, 400], xticks=[-400, 0, 400],
title='Green dots: Inputs\nRed diamonds: Extracellular electrodes')
[plt.plot([cell.xstart[idx], cell.xend[idx]], [cell.ystart[idx], cell.yend[idx]], c='k') for idx in range(cell.totnsegs)]
[plt.plot(cell.xmid[idx], cell.ymid[idx], 'o', c=cell_idx_colors[idx], ms=12) for idx in cell_plot_idxs]
[plt.plot(electrode_parameters['x'][idx], electrode_parameters['y'][idx], 'D', c=elec_idx_colors[idx], ms=12) for idx in range(len(electrode_parameters['x']))]
# Plotting the membrane potentials
plt.subplot(242, title='Membrane\npotential', xlabel='Time [ms]', ylabel='mV', ylim=[-80, 20])
[plt.plot(cell.tvec, cell.vmem[idx, :], c=cell_idx_colors[idx], lw=2) for idx in cell_plot_idxs]
# Plotting the input currents
stim_lim = [2*np.min([cl_soma.i, cl_apic.i]), 2*np.max([cl_soma.i, cl_apic.i])]
plt.subplot(246, title='Input currents', xlabel='Time [ms]', ylabel='nA', ylim=stim_lim)
plt.plot(cell.tvec, cl_soma.i, c=cell_idx_colors[soma_clamp_params['idx']], lw=2)
plt.plot(cell.tvec, cl_apic.i, '--', c=cell_idx_colors[apic_clamp_params['idx']], lw=2)
# Plotting the extracellular potentials
LFP = 1000 * electrode.LFP + noise_level * (np.random.random(electrode.LFP.shape) - 0.5)
plt.subplot(243, title='Extracellular\npotentials', xlabel='Time [ms]', ylabel='$\mu$V', xlim=[9, 18])
[plt.plot(cell.tvec, LFP[idx], c=elec_idx_colors[idx], lw=2) for idx in range(len(electrode_parameters['x']))]
norm_LFP = [LFP[idx] - LFP[idx, 0] for idx in range(len(electrode_parameters['x']))]
plt.subplot(247, title='Extracellular\npotentials', xlabel='Time [ms]', ylabel='Normalized', xlim=[9, 18])
[plt.plot(cell.tvec, norm_LFP[idx] / np.max(np.abs(norm_LFP[idx])), c=elec_idx_colors[idx], lw=2) for idx in range(len(electrode_parameters['x']))]
def test_StimIntElectrode_03(self):
cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',
'ball_and_sticks.hoc'))
stim0 = LFPy.StimIntElectrode(cell=cell,
idx=0,
pptype='IClamp',
amp=1.,
dur=20.,
delay=10.,
record_potential=True,
record_current=True)
stim1 = LFPy.StimIntElectrode(cell=cell,
idx=1,
pptype='IClamp',
amp=1.,
dur=20.,
delay=30.,
record_potential=True,
record_current=False)
stim2 = LFPy.StimIntElectrode(cell=cell,
idx=2,
pptype='IClamp',
amp=1.,
dur=20.,
delay=50.,
record_potential=False,
record_current=True)
stim3 = LFPy.StimIntElectrode(cell=cell,
idx=3,
pptype='IClamp',
amp=1.,
dur=20.,
delay=70.,
record_potential=False,
record_current=False)
cell.simulate()
gt = np.zeros(cell.tvec.size)
gt[(cell.tvec > 10.) & (cell.tvec <= 30.)] = 1.
np.testing.assert_equal(gt, stim0.i)
np.testing.assert_equal(cell.somav, stim0.v)
self.assertTrue(hasattr(stim1, 'v'))
self.assertTrue(cell.tvec.shape == stim1.v.shape)
self.assertFalse(hasattr(stim2, 'v'))
self.assertFalse(hasattr(stim3, 'v'))
self.assertFalse(hasattr(stim1, 'i'))
self.assertTrue(hasattr(stim2, 'i'))
self.assertTrue(cell.tvec.shape == stim2.i.shape)
self.assertFalse(hasattr(stim3, 'i'))
def test_cell_tstart_00(self):
stickParams = {
'morphology': os.path.join(LFPy.__path__[0], 'test', 'stick.hoc'),
'cm': 1,
'Ra': 150,
'v_init': -65,
'passive': True,
'passive_parameters': {
'g_pas': 1. / 30000,
'e_pas': -65
},
'dt': 2**-4,
'nsegs_method': 'lambda_f',
'lambda_f': 100,
}
stimParams = {
'pptype': 'SinSyn',
'dur': 1000.,
'pkamp': 1.,
'freq': 100.,
'bias': 0.,
'record_current': False
}
stick0 = LFPy.Cell(tstart=0, tstop=200, **stickParams)
synapse0 = LFPy.StimIntElectrode(stick0,
stick0.get_closest_idx(0, 0, 1000),
delay=0,
phase=0.,
**stimParams)
stick0.simulate(rec_imem=True,
rec_vmem=True,
rec_current_dipole_moment=True)
stick1 = LFPy.Cell(tstart=-100, tstop=100, **stickParams)
synapse1 = LFPy.StimIntElectrode(stick1,
stick1.get_closest_idx(0, 0, 1000),
delay=-100,
phase=0.,
**stimParams)
stick1.simulate(rec_imem=True,
rec_vmem=True,
rec_current_dipole_moment=True)
inds = stick0.tvec >= 100
np.testing.assert_allclose(stick0.vmem[:, inds], stick1.vmem)
np.testing.assert_allclose(stick0.imem[:, inds], stick1.imem)
np.testing.assert_allclose(stick0.current_dipole_moment[inds, :],
stick1.current_dipole_moment)
def test_StimIntElectrode_02(self):
cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',
'ball_and_sticks.hoc'),
dt=1.,
v_init=-65.,
Ra=150.,
cm=1.,
passive=True,
passive_parameters=dict(g_pas=1. / 30000, e_pas=-65))
stim = LFPy.StimIntElectrode(cell=cell,
record_potential=True,
**{
'idx': 0,
'pptype': 'SEClamp',
'amp1': -65,
'dur1': 10,
'amp2': -55.,
'dur2': 20,
'amp3': -65,
'dur3': 10,
})
cell.simulate()
gt = np.zeros(cell.tvec.size) - 65.
gt[(cell.tvec > 10.) & (cell.tvec <= 30.)] = -55.
np.testing.assert_allclose(gt, cell.somav, rtol=1E-2)
np.testing.assert_equal(cell.somav, stim.v)
def instantiate(self, sim=None, icell=None, LFPyCell=None):
"""Run stimulus"""
from .locations import NrnSomaDistanceCompLocation
if hasattr(self.location, "sec_index"):
sec_index = self.location.sec_index
elif isinstance(self.location, NrnSomaDistanceCompLocation):
# compute sec_index closest to soma_distance
cell_seg_locs = np.array([LFPyCell.x, LFPyCell.y, LFPyCell.z]).T
soma_loc = LFPyCell.somapos
dist_from_soma = np.array(
[np.linalg.norm(loc - soma_loc) for loc in cell_seg_locs])
sec_index = np.argmin(
np.abs(dist_from_soma - self.location.soma_distance))
else:
raise NotImplementedError(
f"{type(self.location)} is currently not implemented "
"with the LFPy backend")
self.iclamp = LFPy.StimIntElectrode(cell=LFPyCell,
idx=sec_index,
pptype="IClamp",
amp=self.step_amplitude,
delay=self.step_delay,
dur=self.step_duration,
record_current=True)
logger.debug(
"Adding square step stimulus to %s with delay %f, "
"duration %f, and amplitude %f",
str(self.location),
self.step_delay,
self.step_duration,
self.step_amplitude,
)
def distal_cosine_current_injection(self, tstop=850):
pre_syn_sptimes = self.stationary_poisson(nsyn=self.n_pre_syn,
lambd=2,
tstart=0,
tstop=400)
l = np.arange(self.n_pre_syn)
pre_syn_pick = np.random.permutation(l)[0:self.n_synapses]
pars = {}
for i_syn in range(self.n_synapses):
syn_idx = int(self.cell.get_rand_idx_area_norm())
spike_times = pre_syn_sptimes[pre_syn_pick[i_syn]]
if syn_idx in pars:
pars[syn_idx].extend(list(spike_times))
else:
pars[syn_idx] = list(spike_times)
for syn_idx in pars:
self.synapse_parameters.update({'idx': syn_idx})
synapse = LFPy.Synapse(self.cell, **self.synapse_parameters)
synapse.set_spike_times(np.array(pars[syn_idx]))
TimesStim = np.arange(850)
stim = np.array(3.6*np.sin(2.*3.141*6.5*TimesStim/1000.))
all_idxs = self.cell.get_idx()
for istim in range(tstop):
pointprocess = {
'idx' : max(all_idxs),
'pptype': 'IClamp',
'record_current' : True,
'amp': stim[istim],
'dur' : 1.,
'delay': istim,
}
stimulus = LFPy.StimIntElectrode(self.cell, **pointprocess)
def cell_thread_PSC(task_queue, done_queue):
'''thread function for simulation of single neuron process'''
for n in iter(task_queue.get, 'STOP'):
print 'Cell number %s out of %d.' % (n, pop_params['n'] - 1)
cell = LFPy.Cell(**cellparams)
e_synparams = e_synparams_init.copy()
for idx in allidx_e[n]:
e_synparams = e_synparams_init.copy()
e_synparams.update({'idx': int(idx), 'color': (0.8, 0.8, 0.8)})
e_spiketimes = [pl.array([spiketime])]
s_e = LFPy.Synapse(cell, **e_synparams)
s_e.set_spike_times(e_spiketimes[0])
e_synparams = e_synparams_init.copy()
LFPy.StimIntElectrode(cell, **pointprocparams)
cell.simulate(**simparams2)
cell.tvec = pl.arange(
-1, cellparams['timeres_python'] * len(cell.tvec) - 1,
cellparams['timeres_python'])
cell.strip_hoc_objects()
done_queue.put(cell)
def generate_LFP_for_single_neuron(electrode, cell_name, params):
cwd = os.getcwd()
neuron.h.load_file('stdrun.hoc')
neuron.h.load_file('import3d.hoc')
#Loading the neuron models of interest
neuron_model = '/home/baran/Desktop/neuron_models/' + cell_name
load_mechanisms_from_neuron_model(cell_name)
templatename = load_cell_properties(cell_name)
os.chdir(neuron_model)
morphologyfile = glob(os.path.join('morphology', '*'))[0]
add_synapses = False
cell = LFPy.TemplateCell(morphology=morphologyfile,
templatefile=(os.path.join(
neuron_model, 'template.hoc')),
templatename=templatename,
templateargs=1 if add_synapses else 0,
tstop=params['tstop'],
dt=params['dt'],
nsegs_method=None,
pt3d=True,
verbose=True)
#Add stimulation electrode
pointProcess = LFPy.StimIntElectrode(cell, **params['PointProcParams'])
cell.simulate(electrode=electrode)
os.chdir(cwd)
return electrode, cell
def test_isotropic_version_of_anisotropic_methods(self):
stickParams = {
'morphology': os.path.join(LFPy.__path__[0], 'test', 'stick.hoc'),
'passive_parameters': {
'g_pas': 1. / 30000,
'e_pas': -65
},
'passive': True,
'tstart': 0,
'tstop': 20,
'dt': 2**-4,
'nsegs_method': 'lambda_f',
'lambda_f': 1000,
}
stimParams = {
'pptype': 'SinSyn',
'delay': -100.,
'dur': 1000.,
'pkamp': 1.,
'freq': 100.,
'phase': -np.pi / 2,
'bias': 0.,
'record_current': True
}
isotropic_electrodeParams = {
'sigma': 0.3,
'x': np.ones(11) * 100.,
'y': np.zeros(11),
'z': np.linspace(1000, 0, 11),
}
anisotropic_electrodeParams = isotropic_electrodeParams.copy()
anisotropic_electrodeParams["sigma"] = [
isotropic_electrodeParams["sigma"]
] * 3
methods = ["pointsource", "linesource", "soma_as_point"]
for method in methods:
isotropic_electrodeParams["method"] = method
anisotropic_electrodeParams["method"] = method
isotropic_electrode = LFPy.RecExtElectrode(
**isotropic_electrodeParams)
anisotropic_electrode = LFPy.RecExtElectrode(
**anisotropic_electrodeParams)
stick = LFPy.Cell(**stickParams)
stick.set_pos(z=-stick.zstart[0])
synapse = LFPy.StimIntElectrode(stick,
stick.get_closest_idx(0, 0, 1000),
**stimParams)
stick.simulate([isotropic_electrode, anisotropic_electrode],
rec_imem=True,
rec_vmem=True)
np.testing.assert_allclose(isotropic_electrode.LFP,
anisotropic_electrode.LFP)
def cosine_current_injection(self, tstop=850):
pre_syn_sptimes = self.stationary_poisson(nsyn=self.n_pre_syn,
lambd=2,
tstart=0,
tstop=400)
l = np.arange(self.n_pre_syn)
pre_syn_pick = np.random.permutation(l)[0:self.n_synapses]
self.synapse_parameters['weight'] = 0.05
pars = {}
for i_syn in range(self.n_synapses):
syn_idx = int(self.cell.get_rand_idx_area_norm())
spike_times = pre_syn_sptimes[pre_syn_pick[i_syn]]
if syn_idx in pars:
pars[syn_idx].extend(list(spike_times))
else:
pars[syn_idx] = list(spike_times)
for syn_idx in pars:
self.synapse_parameters.update({'idx': syn_idx})
synapse = LFPy.Synapse(self.cell, **self.synapse_parameters)
synapse.set_spike_times(np.array(pars[syn_idx]))
self.point_process['dur'] = 1
TimesStim = np.arange(tstop)
stim = np.array(3.6e-1 * np.sin(2. * 3.141 * 6.5 * TimesStim / 1000.))
for istim in range(tstop):
self.point_process['amp'] = stim[istim]
self.point_process['delay'] = istim
stimulus = LFPy.StimIntElectrode(self.cell, **self.point_process)
def makeStimulus(cell):
return LFPy.StimIntElectrode(cell=cell,
idx=0,
pptype='IClamp',
amp=1 + (.05 * np.random.randn()),
dur=100.,
delay=5.,
record_current=True)
def exercise1(soma_clamp_params, apic_clamp_params):
cell_parameters = {
'morphology': 'A140612.hoc', # File with cell morphology
'v_init': -62,
'passive': False,
'nsegs_method': None,
'dt': 2**-3, # [ms] Should be a power of 2
'tstart': -50, # [ms] Simulation start time
'tstop': 50, # [ms] Simulation end time
'custom_code': ['cell_model.hoc'] # Loads model specific code
}
### MAKING THE CELL
cell = LFPy.Cell(**cell_parameters)
### MAKING THE INPUT
apic_clamp_params['idx'] = cell.get_closest_idx(x=-150., y=750., z=0.)
cl_soma = LFPy.StimIntElectrode(cell, **soma_clamp_params)
cl_apic = LFPy.StimIntElectrode(cell, **apic_clamp_params)
cell.simulate(rec_vmem=True)
### PLOTTING THE RESULTS
cell_plot_idxs = [soma_clamp_params['idx'], apic_clamp_params['idx']]
cell_plot_colors = {cell_plot_idxs[idx]: plt.cm.Greens_r(1./(len(cell_plot_idxs) + 1) * idx + 0.1) for idx in range(len(cell_plot_idxs))}
# Plotting the morphology
plt.figure(figsize=(16,9))
plt.subplots_adjust(hspace=0.5)
plt.subplot(121, aspect='equal', xlabel='x [$\mu m$]', ylabel='y [$\mu m$]', xlim=[-400, 400], xticks=[-400, 0, 400], title='Green dots: Inputs')
[plt.plot([cell.xstart[idx], cell.xend[idx]], [cell.ystart[idx], cell.yend[idx]], c='k') for idx in range(cell.totnsegs)]
[plt.plot(cell.xmid[idx], cell.ymid[idx], 'o', c=cell_plot_colors[idx], ms=12) for idx in cell_plot_idxs]
# Plotting the membrane potentials
plt.subplot(222, title='Membrane potential', xlabel='Time [ms]', ylabel='mV', ylim=[-80, 20])
[plt.plot(cell.tvec, cell.vmem[idx, :], c=cell_plot_colors[idx], lw=2) for idx in cell_plot_idxs]
# Plotting the input currents
stim_lim = [2*np.min([cl_soma.i, cl_apic.i]), 2*np.max([cl_soma.i, cl_apic.i])]
plt.subplot(224, title='Input currents', xlabel='Time [ms]', ylabel='nA', ylim=stim_lim)
plt.plot(cell.tvec, cl_soma.i, c=cell_plot_colors[soma_clamp_params['idx']], lw=2)
plt.plot(cell.tvec, cl_apic.i, '--', c=cell_plot_colors[apic_clamp_params['idx']], lw=2)
def stickSimulationDotprodcoeffs(method):
stickParams = {
'morphology' : os.path.join(LFPy.__path__[0], 'test', 'stick.hoc'),
'cm' : 1,
'Ra' : 150,
'v_init' : -65,
'passive' : True,
'passive_parameters' : {'g_pas' : 1./30000, 'e_pas' : -65},
'tstart' : -100,
'tstop' : 100,
'dt' : 2**-6,
'nsegs_method' : 'lambda_f',
'lambda_f' : 1000,
}
electrodeParams = {
'sigma' : 0.3,
'x' : np.ones(11) * 100.,
'y' : np.zeros(11),
'z' : np.linspace(1000, 0, 11),
'method' : method
}
stimParams = {
'pptype' : 'SinSyn',
'delay' : -100.,
'dur' : 1000.,
'pkamp' : 1.,
'freq' : 100.,
'phase' : -np.pi/2,
'bias' : 0.,
'record_current' : True
}
stick = LFPy.Cell(**stickParams)
stick.set_pos(z=-stick.zstart[0])
#dummy variables for mapping
stick.imem = np.eye(stick.totnsegs)
stick.tvec = np.arange(stick.totnsegs)*stick.dt
electrode = LFPy.RecExtElectrode(stick, **electrodeParams)
electrode.calc_lfp()
#not needed anymore:
del stick.imem, stick.tvec
synapse = LFPy.StimIntElectrode(stick, stick.get_closest_idx(0, 0, 1000),
**stimParams)
stick.simulate(dotprodcoeffs=electrode.LFP,
rec_imem=True, rec_vmem=True)
return stick.dotprodresults[0]
def test_cell_simulate_current_dipole_moment_01(self):
stickParams = {
'morphology':
os.path.join(LFPy.__path__[0], 'test', 'stick.hoc'),
'templatefile':
os.path.join(LFPy.__path__[0], 'test', 'stick_template.hoc'),
'templatename':
'stick_template',
'templateargs':
None,
'cm':
1,
'Ra':
150,
'v_init':
-65,
'passive':
True,
'passive_parameters': {
'g_pas': 1. / 30000,
'e_pas': -65
},
'tstart':
-100,
'tstop':
100,
'dt':
2**-4,
'nsegs_method':
'lambda_f',
'lambda_f':
100,
}
stimParams = {
'pptype': 'SinSyn',
'delay': 0.,
'dur': 1000.,
'pkamp': 1.,
'freq': 100.,
'phase': 0,
'bias': 0.,
'record_current': False
}
for idx in range(31): #31 segments
if idx != 15: # no net dipole moment because of stick symmetry
stick = LFPy.TemplateCell(**stickParams)
synapse = LFPy.StimIntElectrode(stick, idx=idx, **stimParams)
stick.simulate(rec_imem=True, rec_current_dipole_moment=True)
p = np.dot(stick.imem.T, np.c_[stick.xmid, stick.ymid,
stick.zmid])
np.testing.assert_allclose(p, stick.current_dipole_moment)
def stickSimulationAveragingElectrode(contactRadius, contactNPoints, method):
stickParams = {
'morphology': os.path.join(LFPy.__path__[0], 'test', 'stick.hoc'),
'cm': 1,
'Ra': 150,
'v_init': -65,
'passive': True,
'passive_parameters': {
'g_pas': 1. / 30000,
'e_pas': -65
},
'tstart': -100,
'tstop': 100,
'dt': 2**-6,
'nsegs_method': 'lambda_f',
'lambda_f': 1000,
}
N = np.empty((11, 3))
for i in range(N.shape[0]):
N[i, ] = [1, 0, 0] #normal unit vec. to contacts
electrodeParams = {
'sigma': 0.3,
'x': np.ones(11) * 100.,
'y': np.zeros(11),
'z': np.linspace(1000, 0, 11),
'r': contactRadius,
'n': 10,
'N': N,
'method': method
}
stimParams = {
'pptype': 'SinSyn',
'delay': -100.,
'dur': 1000.,
'pkamp': 1.,
'freq': 100.,
'phase': -np.pi / 2,
'bias': 0.,
'record_current': True
}
electrode = LFPy.RecExtElectrode(**electrodeParams)
stick = LFPy.Cell(**stickParams)
stick.set_pos(z=-stick.zstart[0])
synapse = LFPy.StimIntElectrode(stick, stick.get_closest_idx(0, 0, 1000),
**stimParams)
stick.simulate(electrode, rec_imem=True, rec_vmem=True)
return electrode.LFP
def make_ZAP_stimuli(cell, input_idx, input_scaling):
ZAP_clamp = {
'idx': input_idx,
'record_current': True,
'dur': 20000,
'delay': 0,
'freq_start': 0,
'freq_end': 15,
'pkamp': input_scaling,
'pptype': 'ZAPClamp',
}
current_clamp = LFPy.StimIntElectrode(cell, **ZAP_clamp)
return cell, current_clamp
def currentPulse(self, cell, stimamp0=0.055, stimamp1=0.0):
PPparams0 = {
'idx': 0,
'pptype': 'IClamp',
'delay': 100,
'dur': 900,
'amp': stimamp0
}
PPparams1 = {
'idx': 0,
'pptype': 'IClamp',
'delay': 0,
'dur': 20000,
'amp': stimamp1,
}
if stimamp0 != 0:
stim0 = LFPy.StimIntElectrode(cell, **PPparams0)
if stimamp1 != 0:
stim1 = LFPy.StimIntElectrode(cell, **PPparams1)
cell.simulate(rec_vmem=True)
def test_cell_with_recextelectrode_01(self):
stickParams = {
'morphology': os.path.join(LFPy.__path__[0], 'test', 'stick.hoc'),
'cm': 1,
'Ra': 150,
'v_init': -65,
'passive': True,
'passive_parameters': {
'g_pas': 1. / 30000,
'e_pas': -65
},
'tstart': -100,
'tstop': 100,
'dt': 2**-4,
'nsegs_method': 'lambda_f',
'lambda_f': 100,
}
electrodeParams = {
'sigma': 0.3,
'x': np.ones(11) * 100.,
'y': np.zeros(11),
'z': np.linspace(1000, 0, 11),
'method': 'pointsource'
}
stimParams = {
'pptype': 'SinSyn',
'delay': 0.,
'dur': 1000.,
'pkamp': 1.,
'freq': 100.,
'phase': 0,
'bias': 0.,
'record_current': False
}
stick = LFPy.Cell(**stickParams)
synapse = LFPy.StimIntElectrode(stick,
stick.get_closest_idx(0, 0, 1000),
**stimParams)
electrode = LFPy.RecExtElectrode(**electrodeParams)
stick.simulate(electrode, rec_imem=True)
electrode1 = LFPy.RecExtElectrode(cell=stick, **electrodeParams)
electrode1.calc_lfp()
np.testing.assert_allclose(electrode.LFP, electrode1.LFP)
def test_StimIntElectrode_00(self):
cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test',
'ball_and_sticks.hoc'))
stim = LFPy.StimIntElectrode(cell=cell,
idx=0,
pptype='IClamp',
amp=1.,
dur=20.,
delay=10.,
record_potential=True,
record_current=True)
cell.simulate()
gt = np.zeros(cell.tvec.size)
gt[(cell.tvec > 10.) & (cell.tvec <= 30.)] = 1.
np.testing.assert_equal(gt, stim.i)
np.testing.assert_equal(cell.somav, stim.v)
def stickSimulation(method):
stickParams = {
'morphology': os.path.join(LFPy.__path__[0], 'test', 'stick.hoc'),
'cm': 1,
'Ra': 150,
'v_init': -65,
'passive': True,
'passive_parameters': {
'g_pas': 1. / 30000,
'e_pas': -65
},
'tstart': -100,
'tstop': 100,
'dt': 2**-6,
'nsegs_method': 'lambda_f',
'lambda_f': 1000,
}
electrodeParams = {
'sigma': 0.3,
'x': np.ones(11) * 100.,
'y': np.zeros(11),
'z': np.linspace(1000, 0, 11),
'method': method
}
stimParams = {
'pptype': 'SinSyn',
'delay': -100.,
'dur': 1000.,
'pkamp': 1.,
'freq': 100.,
'phase': -np.pi / 2,
'bias': 0.,
'record_current': True
}
electrode = LFPy.RecExtElectrode(**electrodeParams)
stick = LFPy.Cell(**stickParams)
stick.set_pos(z=-stick.zstart[0])
synapse = LFPy.StimIntElectrode(stick, stick.get_closest_idx(0, 0, 1000),
**stimParams)
stick.simulate(electrode, rec_imem=True, rec_vmem=True)
return electrode.LFP
def cellsim_w_HH(stim_I=0.2,
gnabar_hh=0.12,
gkbar_hh=0.036,
gl_hh=0.0003,
el_hh=-54.3):
#LFPy.TemplateCell params
cell_params = dict(
morphology='soma.hoc',
templatefile='LFPyCellTemplate.hoc',
templatename='LFPyCellTemplate',
passive=False,
nsegs_method=None,
tstartms=0,
tstopms=1000,
extracellular=False,
)
#LFPy.StimIntElectrode params
stim_params = {
'idx': 0,
'pptype': 'IClamp',
'delay': 100.,
'dur': 800.,
'amp': stim_I,
}
#Why templatecell - Hay2011 is one, see LFPy examples using it.
cell = LFPy.TemplateCell(**cell_params)
#throw on some HH channels
for sec in cell.allseclist:
sec.insert('hh')
#These are important, basically the DOFs were attempting to fit
for seg in sec:
seg.hh.gnabar = gnabar_hh
seg.hh.gkbar = gkbar_hh
seg.hh.gl = gl_hh
seg.hh.el = el_hh
#set stimulus
stim = LFPy.StimIntElectrode(cell, **stim_params)
#run the sim
cell.simulate()
#return data
return cell.tvec, cell.somav
def stickSimulation(self, method):
stickParams = {
'morphology': os.path.join(LFPy.__path__[0], 'stick.hoc'),
'rm': 30000,
'cm': 1,
'Ra': 150,
'tstartms': -100,
'tstopms': 100,
'timeres_python': 0.01,
'timeres_NEURON': 0.01,
'nsegs_method': 'lambda_f',
'lambda_f': 100,
}
electrodeParams = {
'sigma': 0.3,
'x': np.ones(11) * 100.,
'y': np.zeros(11),
'z': np.linspace(1000, 0, 11),
'method': method
}
stimParams = {
'pptype': 'SinSyn',
'delay': -100.,
'dur': 1000.,
'pkamp': 1.,
'freq': 100.,
'phase': -np.pi / 2,
'bias': 0.,
'record_current': True
}
electrode = LFPy.RecExtElectrode(**electrodeParams)
stick = LFPy.Cell(**stickParams)
synapse = LFPy.StimIntElectrode(stick,
stick.get_closest_idx(0, 0, 1000),
**stimParams)
stick.simulate(electrode, rec_imem=True, rec_istim=True, rec_vmem=True)
return electrode.LFP
def sine_synaptic_input(self, tstop=None):
if not tstop:
tstop = self.cell.tstop
frequencies = np.arange(0.5, 13, 0.5)
i = 0
distance = 0
nseg = self.cell.get_idx()
freq_step = sum(self.cell.length) / len(frequencies)
for j, istim in enumerate(nseg):
distance += self.cell.length[j]
if distance > (i + 1) * freq_step:
i += 1
freq = frequencies[i]
pointprocess = {
'idx': istim,
'pptype': 'SinSyn',
'pkamp': 3.6,
'freq': freq,
'phase': -np.pi / 2,
'dur': self.cell.tstop,
}
stimulus = LFPy.StimIntElectrode(self.cell, **pointprocess)
def clamp_ends(cell, pulse_start, pulse_end, voltage=-70., axis='z'):
'''
Clamp the extremities of a cell
Should only be used for ball and stick models, otherwise to update
Pay attention to the orientation, here the cell is assumed to be
horizontally oriented along the corresponding x/y/z axis.
'''
pointprocesses = {'pptype': 'SEClamp', 'amp1': voltage, 'dur1': pulse_end}
if axis == 'x':
lfpy.StimIntElectrode(cell, np.argmax(cell.xend), **pointprocesses)
lfpy.StimIntElectrode(cell, np.argmin(cell.xend), **pointprocesses)
elif axis == 'y':
lfpy.StimIntElectrode(cell, np.argmax(cell.yend), **pointprocesses)
lfpy.StimIntElectrode(cell, np.argmin(cell.yend), **pointprocesses)
elif axis == 'z':
lfpy.StimIntElectrode(cell, np.argmax(cell.zend), **pointprocesses)
lfpy.StimIntElectrode(cell, np.argmin(cell.zend), **pointprocesses)
return
def test_Network_02(self):
cellParameters = dict(
morphology=os.path.join(LFPy.__path__[0], 'test',
'ball_and_sticks_w_lists.hoc'),
templatefile=os.path.join(LFPy.__path__[0], 'test',
'ball_and_stick_template.hoc'),
templatename='ball_and_stick_template',
templateargs=None,
passive=False,
dt=2**-3,
tstop=100,
delete_sections=False,
)
populationParameters = dict(
CWD=None,
CELLPATH=None,
Cell=LFPy.NetworkCell,
cell_args=cellParameters,
pop_args=dict(radius=100, loc=0., scale=20.),
rotation_args=dict(x=0, y=0),
POP_SIZE=4,
name='test',
)
networkParameters = dict(dt=2**-3,
tstart=0.,
tstop=100.,
v_init=-65.,
celsius=6.3,
OUTPUTPATH='tmp_testNetworkPopulation')
clampParams = {
'idx': 0,
'pptype': 'VClamp',
'amp[0]': -65,
'dur[0]': 10,
'amp[1]': 0,
'dur[1]': 1,
'amp[2]': -65,
'dur[2]': 1E8,
}
# set up
network = LFPy.Network(**networkParameters)
network.create_population(**populationParameters)
connectivity = network.get_connectivity_rand(pre='test',
post='test',
connprob=1)
# test connectivity
self.assertTrue(
np.all(connectivity == (
np.eye(populationParameters['POP_SIZE']) == 0)))
# connect
network.connect(pre='test',
post='test',
connectivity=connectivity,
multapseargs=dict(loc=1, scale=1E-9))
# create synthetic AP in cell with gid == 0
for population in network.populations.values():
for cell in population.cells:
if cell.gid == 0:
vclamp = LFPy.StimIntElectrode(cell=cell, **clampParams)
# simulate
network.simulate()
# test output
for population in network.populations.values():
for cell in population.cells:
self.assertFalse(np.all(cell.somav == network.v_init))
network.pc.gid_clear()
os.system('rm -r tmp_testNetworkPopulation')
neuron.h('forall delete_section()')
def test_slice_shift_invariance_pointsource(self):
h = 200
z_shift_1 = 0
z_shift_2 = -352
electrodeParams_1 = {
'sigma_T': 0.3,
'sigma_S': 1.5,
'sigma_G': 0.0,
'h': h,
'z_shift': z_shift_1,
'x': np.linspace(0, 1000, 11),
'y': np.zeros(11),
'z': np.zeros(11) + z_shift_1,
'squeeze_cell_factor': None,
}
electrodeParams_2 = {
'sigma_T': 0.3,
'sigma_S': 1.5,
'sigma_G': 0.0,
'h': h,
'z_shift': z_shift_2,
'x': np.linspace(0, 1000, 11),
'y': np.zeros(11),
'z': np.zeros(11) + z_shift_2,
'squeeze_cell_factor': None,
}
stimParams = {
'pptype': 'SinSyn',
'delay': -100.,
'dur': 1000.,
'pkamp': 1.,
'freq': 100.,
'phase': -np.pi / 2,
'bias': 0.,
'record_current': True
}
stickParams = {
'morphology': os.path.join(
LFPy.__path__[0],
'test',
'ball_and_sticks.hoc'),
'passive_parameters': {
'g_pas': 1. / 30000,
'e_pas': -65},
'passive': True,
'tstart': -10,
'tstop': 20,
'dt': 2**-4,
'nsegs_method': 'lambda_f',
'lambda_f': 100,
}
stick = LFPy.Cell(**stickParams)
stick.set_rotation(y=np.pi / 2)
LFPy.StimIntElectrode(stick, stick.get_closest_idx(0, 0, 0),
**stimParams)
stick.simulate(rec_imem=True)
methods = ["pointsource", "linesource", "root_as_point"]
for method in methods:
electrodeParams_1["method"] = method
electrodeParams_2["method"] = method
stick.set_pos(z=z_shift_1 + h / 2)
MEA_shift_1 = LFPy.RecMEAElectrode(stick, **electrodeParams_1)
M_1 = MEA_shift_1.get_transformation_matrix()
stick.set_pos(z=z_shift_2 + h / 2)
MEA_shift_2 = LFPy.RecMEAElectrode(stick, **electrodeParams_2)
M_2 = MEA_shift_2.get_transformation_matrix()
np.testing.assert_allclose(M_1 @ stick.imem,
M_2 @ stick.imem, rtol=1E-7)
'record_current': True,
'pptype': 'IClamp',
'amp': amp,
'dur': sim_length,
'delay': 0
}
if z_injected == "soma":
pointprocess['idx'] = cell.get_idx(section='soma')[0]
elif z_injected == 'axon':
pointprocess['idx'] = cell.get_idx(section='axon1')[10]
else:
print("Bipolar LFP not implemented")
raise SystemExit(0)
# Create synapse and set time of synaptic input
stimulus = LFPy.StimIntElectrode(cell, **pointprocess)
x = np.arange(L_soma, 1.2 * L_axon + 1, 1)
y = np.array([1, 1.5, 2])
X, Y = np.meshgrid(x, y)
Z = np.zeros(X.shape)
# Define electrode parameters
grid_electrode_parameters = {
'sigma': 0.05, # extracellular conductivity (S/m?)
'x': X.flatten(), # electrode requires 1d vector of positions
'y': Y.flatten(), # electrode requires 1d vector of positions
'z': Z.flatten(),
'method': 'soma_as_point', # treat soma segment as line source
}
for morphologyfile in glob(os.path.join('morphology', '*')):
if COUNTER % SIZE == RANK:
# Instantiate the cell(s) using LFPy
cell = LFPy.TemplateCell(morphology=morphologyfile,
templatefile=posixpth(
os.path.join(NRN, 'template.hoc')),
templatename=templatename,
templateargs=1 if add_synapses else 0,
tstop=tstop,
dt=dt,
nsegs_method=None)
# set view as in most other examples
cell.set_rotation(x=np.pi / 2)
pointProcess = LFPy.StimIntElectrode(cell, **PointProcParams)
electrode = LFPy.RecExtElectrode(x=np.array([-40, 40., 0, 0]),
y=np.array([0, 0, -40, 40]),
z=np.zeros(4),
sigma=0.3,
r=5,
n=50,
N=np.array([[1, 0, 0], [1, 0, 0],
[1, 0, 0], [1, 0,
0]]),
method='soma_as_point')
# run simulation
cell.simulate(electrode=electrode)
# compute LFP
def test_compare_anisotropic_lfp_methods(self):
stickParams = {
'morphology': os.path.join(LFPy.__path__[0], 'test', 'stick.hoc'),
'passive_parameters': {'g_pas': 1. / 30000, 'e_pas': -65},
'passive': True,
'tstart': 0,
'tstop': 20,
'dt': 2**-4,
'nsegs_method': 'lambda_f',
'lambda_f': 1000,
}
stimParams = {
'pptype': 'SinSyn',
'delay': -100.,
'dur': 1000.,
'pkamp': 1.,
'freq': 100.,
'phase': -np.pi / 2,
'bias': 0.,
'record_current': True
}
electrodeParams = {
'sigma': [0.3, 0.3, 0.45],
'x': np.array([0, 1000]),
'y': np.zeros(2),
'z': np.zeros(2),
}
stick = LFPy.Cell(**stickParams)
stick.set_pos(z=-stick.z[0, 0])
LFPy.StimIntElectrode(stick, stick.get_closest_idx(0, 0, 1000),
**stimParams)
ps_electrodeParams = electrodeParams.copy()
ls_electrodeParams = electrodeParams.copy()
sap_electrodeParams = electrodeParams.copy()
ps_electrodeParams["method"] = "pointsource"
ls_electrodeParams["method"] = "linesource"
sap_electrodeParams["method"] = "root_as_point"
electrode_ps = LFPy.RecExtElectrode(stick, **ps_electrodeParams)
electrode_ls = LFPy.RecExtElectrode(stick, **ls_electrodeParams)
electrode_sap = LFPy.RecExtElectrode(stick, **sap_electrodeParams)
stick.simulate(probes=[electrode_ps, electrode_ls, electrode_sap],
rec_imem=True, rec_vmem=True)
# Test that distant electrode is independent of choice of method
np.testing.assert_almost_equal(electrode_ps.data[1, :],
electrode_ls.data[1, :])
np.testing.assert_almost_equal(electrode_ps.data[1, :],
electrode_sap.data[1, :])
# Hack to test that LFP close to stick is dependent on choice of method
np.testing.assert_raises(AssertionError, np.testing.assert_array_equal,
electrode_ps.data[0, :],
electrode_ls.data[0, :])
np.testing.assert_raises(AssertionError, np.testing.assert_array_equal,
electrode_ps.data[0, :],
electrode_sap.data[0, :])
