def __init__(self, rflum, tsample, fps=30.0, amplitude_transform='linear',
amp_max=60, freq=20, pulse_dur=.5 / 1000.,
interphase_dur=.5 / 1000.,
pulsetype='cathodicfirst', stimtype='pulsetrain'):
"""
Parameters
----------
rflum : 1D array
Values between 0 and 1
tsample : suggest TemporalModel.tsample
"""
# set up the individual pulses
pulse = get_pulse(pulse_dur, tsample, interphase_dur, pulsetype)
# set up the sequence
dur = rflum.shape[-1] / fps
if stimtype == 'pulsetrain':
interpulsegap = np.zeros(int(round((1.0 / freq) / tsample)) -
len(pulse))
ppt = []
for j in range(0, int(np.ceil(dur * freq))):
ppt = np.concatenate((ppt, interpulsegap), axis=0)
ppt = np.concatenate((ppt, pulse), axis=0)
ppt = ppt[0:round(dur / tsample)]
intfunc = interpolate.interp1d(np.linspace(0, len(rflum), len(rflum)),
rflum)
amp = intfunc(np.linspace(0, len(rflum), len(ppt)))
data = amp * ppt * amp_max
TimeSeries.__init__(self, tsample, data)
def __init__(self, tsample, freq=20, amp=20, dur=0.5, delay=0,
pulse_dur=0.45 / 1000, interphase_dur=0.45 / 1000,
pulsetype='cathodicfirst',
pulseorder='pulsefirst'):
"""
tsample : float
Sampling interval in seconds parameters, use TemporalModel.tsample.
----------
optional parameters
freq : float
Frequency of the pulse envelope in Hz.
dur : float
Stimulus duration in seconds.
pulse_dur : float
Single-pulse duration in seconds.
interphase_duration : float
Single-pulse interphase duration (the time between the positive
and negative phase) in seconds.
delay : float
Delay until stimulus on-set in seconds.
amp : float
Max amplitude of the pulse train in micro-amps.
pulsetype : string
Pulse type {"cathodicfirst" | "anodicfirst"}, where
'cathodicfirst' has the negative phase first.
pulseorder : string
Pulse order {"gapfirst" | "pulsefirst"}, where
'pulsefirst' has the pulse first, followed by the gap.
"""
# Stimulus size given by `dur`
stim_size = int(np.round(1.0 * dur / tsample))
if freq == 0 or amp == 0:
TimeSeries.__init__(self, tsample, np.zeros(stim_size))
return
# Envelope size (single pulse + gap) given by `freq`
envelope_size = int(np.round(1.0 / float(freq) / tsample))
# Delay given by `delay`
delay_size = int(np.round(1.0 * delay / tsample))
if delay_size < 0:
raise ValueError("Delay must fit within 1/freq interval.")
delay = np.zeros(delay_size)
# Single pulse given by `pulse_dur`
pulse = amp * get_pulse(pulse_dur, tsample,
interphase_dur,
pulsetype)
pulse_size = pulse.size
if pulse_size < 0:
raise ValueError("Single pulse must fit within 1/freq interval.")
# Then gap is used to fill up what's left
gap_size = envelope_size - (delay_size + pulse_size)
if gap_size < 0:
raise ValueError("Pulse and delay must fit within 1/freq "
"interval.")
gap = np.zeros(gap_size)
pulse_train = []
for j in range(int(np.round(dur * freq))):
if pulseorder == 'pulsefirst':
pulse_train = np.concatenate((pulse_train, delay, pulse,
gap), axis=0)
elif pulseorder == 'gapfirst':
pulse_train = np.concatenate((pulse_train, delay, gap,
pulse), axis=0)
else:
raise ValueError("Acceptable values for `pulseorder` are "
"'pulsefirst' or 'gapfirst'")
# If `freq` is not a nice number, the resulting pulse train might not
# have the desired length
if pulse_train.size < stim_size:
fill_size = stim_size - pulse_train.shape[-1]
pulse_train = np.concatenate((pulse_train, np.zeros(fill_size)),
axis=0)
# Trim to correct length (takes care of too long arrays, too)
pulse_train = pulse_train[:stim_size]
TimeSeries.__init__(self, tsample, pulse_train)
