def setVClamp(seg, durs, amps):
## VClamp as vstim
amps = [x if isinstance(x, (int, float)) else h.v_init for x in amps]
vstim = h.VClamp(seg)
vstim.dur[0], vstim.dur[1], vstim.dur[2] = durs[0], durs[1], durs[2]
vstim.amp[0], vstim.amp[1], vstim.amp[2] = amps[0], amps[1], amps[2]
return vstim
def setVClamp(seg, durs, amps):
## VClamp as vstim
amps = [x if isinstance(x, (int, float, complex)) else h.v_init for x in amps]
vstim = h.VClamp(seg)
vstim.dur[0], vstim.dur[1], vstim.dur[2] = durs[0], durs[1], durs[2]
vstim.amp[0], vstim.amp[1], vstim.amp[2] = amps[0], amps[1], amps[2]
## SEClamp as vstim
# vstim = h.SEClamp(csomas[cell].drgsoma(0.5))
# vstim.dur1, vstim.dur2, vstim.dur3 = durs[0], durs[1], durs[2]
# vstim.amp1, vstim.amp2, vstim.amp3 = amps[0], amps[1], amps[2]
return vstim
def inject_VClamp(parameters, injectsite):
"""Injects SEClamp for `NEURON <https://neuron.yale.edu/neuron/>`_
**Keyword Arguments:**
+----------------+--------------------------------------------------------------+
| Keys | Value type |
+================+==============================================================+
| ``parameters`` | - list such that each element is a dictionary [ {}, {}, {} ] |
| | - Eg: [ {"amp": 0.0, "dur": 50.0}, |
| | {"amp": 10.0, "dur": 100.0}, |
| | {"amp": 20.0, "dur": 150.0} ] |
| |**NOTE** There is no amp[>2] (therefore no dur[>2]) |
| | - To change clamp parameters with keys "gain", "rstim", |
} |"tau1" and "tau2", do it just once. They should be the same |
| |for all because its the same setup, just the amplitude changes|
| | - Since "Clamp is on at 0, off at time dur[0]+dur[1]+dur[2]" |
| |if you don't want to start the simulation with it just set the|
| | first "amp": 0.0 |
+----------------+--------------------------------------------------------------+
| ``injectsite`` | ``neuron`` ``section``, for e.g., ``cell.soma`` |
+----------------+--------------------------------------------------------------+
**Returned values:** a ``hoc`` object ``h.VClamp``.
**NOTE:**
- The ``h.VClamp`` function is available in NEURON as `VClamp <https://neuron.yale.edu/neuron/static/new_doc/modelspec/programmatic/mechanisms/mech.html#VClamp>`_ by default.
- By default the electrode resistance (Re but VClamp attribute is ``rstim``) is made very small ``1E-6``. This is because the input resistance (Rin) for the voltmeter (i.e, the measuring circuit) must be very large (i.e, infinite resistance) so that the voltage drop across the voltmeter (given by the voltage divider equation, the resistance is Rin/(Rin+Re)) is as close as possible to the membrane voltage it is supposed to be clamping. By making the electrode resistance very small it is the same as infinite Rin.
"""
# NOTE: Do not insert several instances of this model at the same location
# to make level changes. That is equivalent to independent clamps and they
# will have incompatible internal state values.
no_of_voltages = len(parameters)
clampingvoltages = h.VClamp(0.5, sec=injectsite)
clampingvoltages.rstim = 1E-6
for i in range(no_of_voltages):
for key, value in parameters[i].items():
if key in clampingvoltages.__dict__:
if key in ["gain", "rstim", "tau1", "tau2"]:
setattr(clampingvoltages, key, value)
else:
clampattr = getattr(clampingvoltages, key)
clampattr[i] = value
else:
raise AttributeError(key +
" is not an attribute in h.VClamp.")
return clampingvoltages
def run(self, pre_sec, post_sec, n_synapses, temp=34.0, dt=0.025,
vclamp=40.0, iterations=1, tstop=240.0, stim_params=None, synapsetype='multisite', **kwds):
"""
Basic synapse test. Connects sections of two cells with *n_synapses*.
The cells are allowed to negotiate the details of the connecting
synapse. The presynaptic soma is then driven with a pulse train
followed by a recovery pulse of varying delay.
*stim_params* is an optional dictionary with keys 'NP', 'Sfreq', 'delay',
'dur', 'amp'.
Analyses:
* Distribution of PSG amplitude, kinetics, and latency
* Synaptic depression / facilitation and recovery timecourses
"""
Protocol.run(self, **kwds)
pre_cell = cells.cell_from_section(pre_sec)
post_cell = cells.cell_from_section(post_sec)
synapses = []
for i in range(n_synapses):
synapses.append(pre_cell.connect(post_cell, type=synapsetype))
self.synapses = synapses
self.pre_sec = synapses[0].terminal.section
self.post_sec = synapses[0].psd.section
self.pre_cell = pre_cell
self.post_cell = post_cell
self.plots={} # store plot information here
#
# voltage clamp the target cell
#
clampV = vclamp
vccontrol = h.VClamp(0.5, sec=post_cell.soma)
vccontrol.dur[0] = 10.0
vccontrol.amp[0] = clampV
vccontrol.dur[1] = 100.0
vccontrol.amp[1] = clampV
vccontrol.dur[2] = 20.0
vccontrol.amp[2] = clampV
#
# set up stimulation of the presynaptic axon/terminal
#
istim = h.iStim(0.5, sec=pre_cell.soma)
stim = {
'NP': 10,
'Sfreq': 100.0,
'delay': 10.0,
'dur': 0.5,
'amp': 10.0,
'PT': 0.0,
'dt': dt,
}
if stim_params is not None:
stim.update(stim_params)
(secmd, maxt, tstims) = util.make_pulse(stim)
self.stim = stim
if tstop is None:
tstop = len(secmd) * dt
istim.delay = 0
istim.dur = 1e9 # these actually do not matter...
istim.iMax = 0.0
# istim current pulse train
i_stim_vec = h.Vector(secmd)
i_stim_vec.play(istim._ref_i, dt, 0)
# create hoc vectors for each parameter we wish to monitor and display
synapse = synapses[0]
self.all_psd = []
if isinstance(synapses[0].psd, GlyPSD) or isinstance(synapses[0].psd, GluPSD):
for syn in synapses:
self.all_psd.extend(syn.psd.all_psd)
elif isinstance(synapses[0].psd, Exp2PSD):
for syn in synapses:
self.all_psd.append(syn)
#for i, cleft in enumerate(synapse.psd.clefts):
#self['cleft_xmtr%d' % i] = cleft._ref_CXmtr
#self['cleft_pre%d' % i] = cleft._ref_pre
#self['cleft_xv%d' % i] = cleft._ref_XV
#self['cleft_xc%d' % i] = cleft._ref_XC
#self['cleft_xu%d' % i] = cleft._ref_XU
#
# Run simulation
#
h.tstop = tstop # duration of a run
h.celsius = temp
h.dt = dt
self.temp = temp
self.dt = dt
self.isoma = []
self.currents = {'ampa': [], 'nmda': []}
self.all_releases = []
self.all_release_events = []
start_time = timeit.default_timer()
for nrep in xrange(iterations): # could do multiple runs....
self.reset()
self['v_pre'] = pre_cell.soma(0.5)._ref_v
self['t'] = h._ref_t
self['v_soma'] = pre_cell.soma(0.5)._ref_v
if not isinstance(synapse.psd, Exp2PSD):
self['relsite_xmtr'] = synapse.terminal.relsite._ref_XMTR[0]
if isinstance(synapse.psd, GluPSD):
# make a synapse monitor for each release zone
self.all_nmda = []
self.all_ampa = []
for syn in synapses:
# collect all PSDs across all synapses
self.all_ampa.extend(syn.psd.ampa_psd)
self.all_nmda.extend(syn.psd.nmda_psd)
# Record current through all PSDs individually
syn.psd.record('i', 'g', 'Open')
#for k,p in enumerate(self.all_nmda):
#self['iNMDA%03d' % k] = p._ref_i
#self['opNMDA%03d' % k] = p._ref_Open
#for k,p in enumerate(self.all_ampa):
#self['iAMPA%03d' % k] = p._ref_i
#self['opAMPA%03d' % k] = p._ref_Open
elif isinstance(synapse.psd, GlyPSD):
# Record current through all PSDs individually
for k,p in enumerate(self.all_psd):
self['iGLY%03d' % k] = p._ref_i
self['opGLY%03d' % k] = p._ref_Open
psd = self.all_psd
if synapse.psd.psdType == 'glyslow':
nstate = 7
self['C0'] = psd[0]._ref_C0
self['C1'] = psd[0]._ref_C1
self['C2'] = psd[0]._ref_C2
self['O1'] = psd[0]._ref_O1
self['O2'] = psd[0]._ref_O2
self['D1'] = psd[0]._ref_D1
#self['D3'] = psd[0]._ref_D3
#self['O1'] = psd[0]._ref_O1
elif synapse.psd.psdType == 'glyfast':
nstate = 7
self['C0'] = psd[0]._ref_C0
self['C1'] = psd[0]._ref_C1
self['C2'] = psd[0]._ref_C2
self['C3'] = psd[0]._ref_C3
self['O1'] = psd[0]._ref_O1
self['O2'] = psd[0]._ref_O2
elif isinstance(synapse.psd, Exp2PSD):
self['iPSD'] = self.all_psd[0].psd.syn._ref_i
if not isinstance(synapse.psd, Exp2PSD):
for i, s in enumerate(synapses):
s.terminal.relsite.rseed = util.random_seed.current_seed() + nrep
util.custom_init()
h.run()
# add up psd current across all runs
if isinstance(synapse.psd, GluPSD):
iampa = np.zeros_like(synapse.psd.get_vector('ampa', 'i'))
inmda = iampa.copy()
for syn in self.synapses:
for i in range(syn.psd.n_psd):
iampa += syn.psd.get_vector('ampa', 'i', i)
inmda += syn.psd.get_vector('nmda', 'i', i)
isoma = iampa + inmda
self.currents['ampa'].append(iampa)
self.currents['nmda'].append(inmda)
elif isinstance(synapse.psd, GlyPSD):
isoma = np.zeros_like(self['iGLY000'])
for k in range(len(self.all_psd)):
isoma += self['iGLY%03d'%k]
elif isinstance(synapse.psd, Exp2PSD):
isoma = self['iPSD']
self.isoma.append(isoma)
self.all_releases.append(self.release_timings())
self.all_release_events.append(self.release_events())
elapsed = timeit.default_timer() - start_time
print 'Elapsed time for %d Repetions: %f' % (iterations, elapsed)
# self.ap_dend.nseg = 23
# self.ap_dend.insert('hh')
# self.ap_dend.gnabar_hh = 0.012
# self.ap_dend.gkbar_hh = 0.0036
# self.ap_dend.gl_hh = 0.00003
# self.ap_dend.connect(self.soma, 1.0, 0)
# synaptic input
self.esyn = h.Exp2Syn(0.5, sec=self.soma) #syn points to ap_dend,0.5
# end of class HHneuron
# cells
hh_neuron = [HHneuron() for i in range(1)]
vcl = h.VClamp()
vcl = h.VClamp(0.5, sec=hh_neuron[0].soma)
# synapse
stim = h.NetStim(0.5)
stim.interval = 50.0
stim.number = 2
stim.start = 50.0
stim.noise = 0
# connections
nclist = []
nclist.append(h.NetCon(stim, hh_neuron[0].esyn, 0.0, 0, 0.005))
tstop = 200
dt = 0.01
import toolbox as tb
from neuron import h
from neuron import gui
h.nrn_load_dll('$i386/')
gocs = Goc(np.array([0.,0.,0.]),record_all=1)
# stim = h.IClamp(.5, sec=gocs[0][1][1].soma)
# stim.amp = -0.015
# stim.dur = 200
gocs.createsyn(ngoc=1,record_all=1)
vc = h.VClamp(0.5)
vc.amp[0] = 0
vc.dur[0] = 200
stim = h.NetStim(0.5)
stim.number = 1
stim.interval = 10
stim.start = 20
# print gocs.GRC_L[0].postsyns.keys()
# print gocs.PF_L[0].postsyns.keys()
nc1 = h.NetCon(stim,gocs.GOC_L[0].input,0,0,1)
# v = h.Vector()
# nc.record(v)
import toolbox as tb
from neuron import h
from neuron import gui
h.nrn_load_dll('$i386/')
gocs = Goc(np.array([0., 0., 0.]), record_all=1)
# stim = h.IClamp(.5, sec=gocs[0][1][1].soma)
# stim.amp = -0.015
# stim.dur = 200
gocs.createsyn(naa=1, record_all=1)
vc = h.VClamp(0.5, sec=gocs.soma)
vc.amp[0] = -70
vc.dur[0] = 10000
# cc = h.IClamp(0.5)
# cc.amp = -0.065
# cc.dur = 2000
# cc.delay = 0
stim = h.NetStim(0.5)
stim.number = 1
stim.interval = 10
stim.start = 2000
nc_mf = [h.NetCon(stim, goc.input, 0, 0, 1) for goc in gocs.GRC_AA_L]
def run(self,
pre_sec,
post_sec,
temp=34.0,
dt=0.025,
vclamp=-65.0,
iterations=1,
tstop=200.0,
stim_params=None,
**kwds):
"""
"""
Protocol.run(self, **kwds)
pre_cell = cells.cell_from_section(pre_sec)
post_cell = cells.cell_from_section(post_sec)
synapse = pre_cell.connect(post_cell, type='simple')
self.synapse = synapse
self.pre_sec = synapse.terminal.section
self.post_sec = synapse.psd.section
self.pre_cell = pre_cell
self.post_cell = post_cell
#
# voltage clamp the target cell
#
vccontrol = h.VClamp(0.5, sec=post_cell.soma)
vccontrol.dur[0] = tstop
vccontrol.amp[0] = vclamp
#vccontrol.dur[1] = 100.0
#vccontrol.amp[1] = clampV
#vccontrol.dur[2] = 20.0
#vccontrol.amp[2] = clampV
#
# set up stimulation of the presynaptic axon/terminal
#
istim = h.iStim(0.5, sec=pre_cell.soma)
stim = {
'NP': 10,
'Sfreq': 100.0,
'delay': 10.0,
'dur': 0.5,
'amp': 10.0,
'PT': 0.0,
'dt': dt,
}
if stim_params is not None:
stim.update(stim_params)
(secmd, maxt, tstims) = util.make_pulse(stim)
self.stim = stim
if tstop is None:
tstop = len(secmd) * dt
istim.delay = 0
istim.dur = 1e9 # these actually do not matter...
istim.iMax = 0.0
# istim current pulse train
i_stim_vec = h.Vector(secmd)
i_stim_vec.play(istim._ref_i, dt, 0)
#
# Run simulation
#
h.tstop = tstop # duration of a run
h.celsius = temp
h.dt = dt
self.temp = temp
self.dt = dt
for nrep in xrange(iterations): # could do multiple runs....
self.reset()
self['v_pre'] = pre_cell.soma(0.5)._ref_v
self['t'] = h._ref_t
self['v_soma'] = post_cell.soma(0.5)._ref_v
self['i_soma'] = vccontrol._ref_i
util.custom_init()
h.run()
