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)