class VectorSpikeSource(hclass(h.VecStim)):
parameter_names = ('spike_times', )
def __init__(self, spike_times=[]):
self.spike_times = spike_times
self.source = self
self.source_section = None
def _set_spike_times(self, spike_times):
try:
self._spike_times = h.Vector(spike_times)
except RuntimeError:
raise errors.InvalidParameterValueError(
"spike_times must be an array of floats")
self.play(self._spike_times)
def _get_spike_times(self):
return self._spike_times
spike_times = property(fget=_get_spike_times, fset=_set_spike_times)
def record(self, active):
"""
Since spike_times are specified by user, recording is meaningless, but
we need to provide a stub for consistency with other models.
"""
pass
class RandomSpikeSource(hclass(h.NetStimFD)):
parameter_names = ('start', '_interval', 'duration')
def __init__(self, start=0, _interval=1e12, duration=0):
self.start = start
self.interval = _interval
self.duration = duration
self.noise = 1
self.spike_times = h.Vector(0)
self.source = self
self.rec = h.NetCon(self, None)
self.switch = h.NetCon(None, self)
self.source_section = None
# should allow user to set specific seeds somewhere, e.g. in setup()
self.seed(state.mpi_rank + state.native_rng_baseseed)
def __new__(cls, *arg, **kwargs):
return super().__new__(cls, *arg, **kwargs)
def _set_interval(self, value):
self.switch.weight[0] = -1
self.switch.event(h.t + 1e-12, 0)
self.interval = value
self.switch.weight[0] = 1
self.switch.event(h.t + 2e-12, 1)
def _get_interval(self):
return self.interval
_interval = property(fget=_get_interval, fset=_set_interval)
class RandomSpikeSource(hclass(h.NetStimFD)):
parameter_names = ('start', '_interval', 'duration')
def __init__(self, start=0, _interval=1e12, duration=0):
self.start = start
self.interval = _interval
self.duration = duration
self.noise = 1
self.spike_times = h.Vector(0)
self.source = self
self.switch = h.NetCon(None, self)
def _set_interval(self, value):
self.switch.weight[0] = -1
self.switch.event(h.t+1e-12, 0)
self.interval = value
self.switch.weight[0] = 1
self.switch.event(h.t+2e-12, 1)
def _get_interval(self):
return self.interval
_interval = property(fget=_get_interval, fset=_set_interval)
def record(self, active):
if active:
self.rec = h.NetCon(self, None)
self.rec.record(self.spike_times)
class VectorSpikeSource(hclass(h.VecStim)):
parameter_names = ('spike_times', )
def __init__(self, spike_times=[]):
self.spike_times = spike_times
self.source = self
self.source_section = None
self.rec = None
def _set_spike_times(self, spike_times):
# spike_times should be a Sequence object
try:
self._spike_times = h.Vector(spike_times.value)
except (RuntimeError, AttributeError):
raise errors.InvalidParameterValueError(
"spike_times must be an array of floats")
if numpy.any(spike_times.value[:-1] > spike_times.value[1:]):
raise errors.InvalidParameterValueError(
"Spike times given to SpikeSourceArray must be in increasing order"
)
self.play(self._spike_times)
def _get_spike_times(self):
return self._spike_times
spike_times = property(fget=_get_spike_times, fset=_set_spike_times)
def clear_past_spikes(self):
"""If previous recordings are cleared, need to remove spikes from before the current time."""
end = self._spike_times.indwhere(">", h.t)
if end > 0:
self._spike_times.remove(0, end - 1) # range is inclusive
class A1(neuron.hclass(neuron.h.A)):
def __new__(cls, arg):
return super().__new__(cls, arg)
def __init__(self, arg):
self.bp = self.baseattr("p")
def p(self):
self.bp()
return self.x
class VectorSpikeSource(hclass(h.VecStim)):
parameter_names = ('spike_times', )
def __init__(self, spike_times=[]):
self.recording = False
self.spike_times = spike_times
self.source = self
self.source_section = None
self.rec = None
self._recorded_spikes = np.array([])
def __new__(cls, *arg, **kwargs):
return super().__new__(cls, *arg, **kwargs)
def _set_spike_times(self, spike_times):
# spike_times should be a Sequence object
try:
self._spike_times = h.Vector(spike_times.value)
except (RuntimeError, AttributeError):
raise errors.InvalidParameterValueError(
"spike_times must be an array of floats")
if np.any(spike_times.value[:-1] > spike_times.value[1:]):
raise errors.InvalidParameterValueError(
"Spike times given to SpikeSourceArray must be in increasing order"
)
self.play(self._spike_times)
if self.recording:
self._recorded_spikes = np.hstack(
(self._recorded_spikes, spike_times.value))
def _get_spike_times(self):
return self._spike_times.as_numpy()
spike_times = property(fget=_get_spike_times, fset=_set_spike_times)
@property
def recording(self):
return self._recording
@recording.setter
def recording(self, value):
self._recording = value
if value:
# when we turn recording on, the cell may already have had its spike times assigned
self._recorded_spikes = np.hstack(
(self._recorded_spikes, self.spike_times))
def get_recorded_spike_times(self):
return self._recorded_spikes
def clear_past_spikes(self):
"""If previous recordings are cleared, need to remove spikes from before the current time."""
self._recorded_spikes = self._recorded_spikes[
self._recorded_spikes > h.t]
class RandomPoissonRefractorySpikeSource(hclass(h.PoissonStimRefractory)):
parameter_names = ('rate', 'tau_refrac', 'start', 'duration')
def __init__(self, rate=1, tau_refrac=0.0, start=0, duration=0):
self.rate = rate
self.tau_refrac = tau_refrac
self.start = start
self.duration = duration
self.spike_times = h.Vector(0)
self.source = self
self.rec = h.NetCon(self, None)
self.source_section = None
self.seed(state.mpi_rank + state.native_rng_baseseed)
class RandomGammaSpikeSource(hclass(h.GammaStim)):
parameter_names = ('alpha', 'beta', 'start', 'duration')
def __init__(self, alpha=1, beta=0.1, start=0, duration=0):
self.alpha = alpha
self.beta = beta
self.start = start
self.duration = duration
self.spike_times = h.Vector(0)
self.source = self
self.rec = h.NetCon(self, None)
self.switch = h.NetCon(None, self)
self.source_section = None
self.seed(state.mpi_rank + state.native_rng_baseseed)
class VectorSpikeSource(hclass(h.VecStim)):
parameter_names = ('spike_times',)
def __init__(self, spike_times=[]):
self.spike_times = spike_times
self.source = self
self.source_section = None
self.rec = None
def _set_spike_times(self, spike_times):
# spike_times should be a Sequence object
try:
self._spike_times = h.Vector(spike_times.value)
except (RuntimeError, AttributeError):
raise errors.InvalidParameterValueError("spike_times must be an array of floats")
self.play(self._spike_times)
def _get_spike_times(self):
return self._spike_times
spike_times = property(fget=_get_spike_times,
fset=_set_spike_times)
class B(neuron.hclass(h.A)):
x = 0 # overrides h.A.x
def __init__(self):
self.x = 2
