def test_traj_with_three_pauses_is_cleaned_correctly(self): speeds = cc([np.random.uniform(0, 1, 100) + 3, np.random.uniform(0, 0.01, 20), # long pause np.random.uniform(0, 1, 80) + 3, np.random.uniform(0, 0.01, 5), # short pause np.random.uniform(0, 1, 95) + 3, np.random.uniform(0, 0.01, 20), # long pause np.random.uniform(0, 1, 80) + 3]) dists = cc([np.random.uniform(0, 1, 100) + 3, np.random.uniform(0, 0.01, 20), # long pause np.random.uniform(0, 1, 80) + 3, np.random.uniform(0, 0.01, 5), # short pause np.random.uniform(0, 1, 95) + 3, np.random.uniform(0, 0.01, 20), # long pause np.random.uniform(0, 1, 80) + 3]) start_timepoint_id = 98 traj = Trajectory(start_timepoint_id, speeds, dists) clean_portions = clean_trajectories.clean_traj(traj, CLEANING_PARAMS) self.assertEqual(len(clean_portions), 3) self.assertEqual(clean_portions[0, 0], start_timepoint_id) self.assertEqual(clean_portions[0, 1], start_timepoint_id + 100 - 1) self.assertEqual(clean_portions[1, 0], start_timepoint_id + 120) self.assertEqual(clean_portions[1, 1], start_timepoint_id + 300 - 1) self.assertEqual(clean_portions[2, 0], start_timepoint_id + 320) self.assertEqual(clean_portions[2, 1], traj.end_timepoint_id)
def test_two_long_pauses_in_middle_with_too_short_traj_between_is_cleaned_correctly(self): speeds = cc([np.random.uniform(0, 1, 100) + 3, np.random.uniform(0, 0.01, 20), # long pause np.random.uniform(0, 1, 30) + 3, # short trajectory np.random.uniform(0, 0.01, 20), # long pause np.random.uniform(0, 1, 80) + 3]) dists = cc([np.random.uniform(0, 1, 100) + 3, np.random.uniform(0, 0.01, 20), # long pause np.random.uniform(0, 1, 30) + 3, # short trajectory np.random.uniform(0, 0.01, 20), # long pause np.random.uniform(0, 1, 80) + 3]) start_timepoint_id = 1003 traj = Trajectory(start_timepoint_id, speeds, dists) clean_portions = clean_trajectories.clean_traj(traj, CLEANING_PARAMS) self.assertEqual(len(clean_portions), 2) self.assertEqual(clean_portions[0, 0], start_timepoint_id) self.assertEqual(clean_portions[0, 1], start_timepoint_id + 100 -1) self.assertEqual(clean_portions[1, 0], start_timepoint_id + 170) self.assertEqual(clean_portions[1, 1], traj.end_timepoint_id)
def initialize(self): """Reset insect history.""" # check that all params are set for param in [ self.r, self.d, self.a, self.tau, self.w, self.loglike_function ]: if param is None: param_str = ', '.join(self.param_names) msg = ( 'Please make sure all of the following parameters are set:' '%s.' % param_str) raise ValueError(msg) # reset clock self.ts = 0 # timestep self.t = 0. # time # reset src pos logprob self.logprob = np.zeros(self.env.shape, dtype=float) # get odor domain from loglikelihood function self.odor_domain = self.loglike_function.domain # calculate extended loglikelihood map # get environment geometry xext = self.env.x - self.env.x[0] xext = cc([-xext[1:][::-1], xext]) yext = self.env.y - self.env.y[0] yext = cc([-yext[1:][::-1], yext]) zext = self.env.z - self.env.z[0] zext = cc([-zext[1:][::-1], zext]) central_idx = ((len(xext) - 1) / 2, (len(yext) - 1) / 2, (len(zext) - 1) / 2) map_shape = (len(xext), len(yext), len(zext)) self.loglike_map = np.zeros((len(self.odor_domain), ) + map_shape, dtype=float) for odor_idx, odor in enumerate(self.odor_domain): loglike = self.loglike_function(odor, central_idx, xext=xext, yext=yext, zext=zext, dt=self.dt, w=self.w, r=self.r, d=self.d, a=self.a, tau=self.tau) self.loglike_map[odor_idx] = loglike
def test_traj_ends_with_long_pause_has_pause_removed(self): speeds = cc([np.random.uniform(0, 1, 500) + 3, np.random.uniform(0, 0.01, 20)]) dists = cc([np.random.uniform(0, 1, 500) + 9, np.random.uniform(0, 0.003, 20)]) start_timepoint_id = 1008 traj = Trajectory(start_timepoint_id, speeds, dists) clean_portions = clean_trajectories.clean_traj(traj, CLEANING_PARAMS) self.assertEqual(len(clean_portions), 1) self.assertEqual(clean_portions[0, 0], start_timepoint_id) self.assertEqual(clean_portions[0, 1], traj.end_timepoint_id - 20)
def testmergeVec(self): d = lammpsdata(Atoms()) direct, phi = d.mergeVec([1, 0, 0], [0, 2, 0]) self.assertTrue(cc(direct, [0, 0, 1])) self.assertEqual(phi, pi / 2) direct, phi = d.mergeVec([1, 0, 1], [1, 1, 1]) self.assertTrue(cc(direct, [-1 / sqrt(2), 0, 1 / sqrt(2)])) self.assertEqual(cos(phi), sqrt(2.0 / 3)) direct, phi = d.mergeVec([1, 0, 0], [1, 0, 0]) self.assertTrue(cc(direct, [1, 0, 0])) self.assertEqual(cos(phi), 1)
def test_traj_starting_with_short_pause_is_untouched(self): speeds = cc([np.random.uniform(0, 0.01, 5), np.random.uniform(0, 1, 500) + 3]) dists = cc([np.random.uniform(0, 0.003, 5), np.random.uniform(0, 1, 500) + 9]) start_timepoint_id = 20010 traj = Trajectory(start_timepoint_id, speeds, dists) clean_portions = clean_trajectories.clean_traj(traj, CLEANING_PARAMS) self.assertEqual(len(clean_portions), 1) self.assertEqual(clean_portions[0, 0], start_timepoint_id) self.assertEqual(clean_portions[0, 1], traj.end_timepoint_id)
def testmergeVec(self): d=lammpsdata(Atoms()) direct,phi=d.mergeVec([1,0,0],[0,2,0]) self.assertTrue(cc(direct,[0,0,1])) self.assertEqual(phi,pi/2) direct,phi=d.mergeVec([1,0,1],[1,1,1]) self.assertTrue(cc(direct,[-1/sqrt(2),0,1/sqrt(2)])) self.assertEqual(cos(phi),sqrt(2.0/3)) direct,phi=d.mergeVec([1,0,0],[1,0,0]) self.assertTrue(cc(direct,[1,0,0])) self.assertEqual(cos(phi),1)
def testwritedata(self): a=Atoms('C2',[[1,0,1],[0,1,1]]) a.set_cell([[1,0,1],[0,1,1],[0,0,1]]) d=lammpsdata(a,['C','N']) d.writedata() b=data('structure') self.assertEqual(b.headers["atoms"],2) self.assertEqual(b.headers["atom types"],2) self.assertEqual(b.title ,'C2\n') self.assertTrue(cc(b.headers["xlo xhi"],[0,sqrt(2)])) self.assertTrue(cc(b.headers["ylo yhi"],[0,sqrt(2)*sqrt(3)/2])) self.assertTrue(cc(b.headers["xy xz yz"][0:1],[sqrt(2)/2])) b.map(1,'id',2,'type',3,'x',4,'y',5,'z') atoms=b.viz(0)[2] self.assertTrue(cc(atoms,[[1,1,sqrt(2),0,0],[2,1,sqrt(2)/2,sqrt(2)*sqrt(3)/2,0]])) shell_exec('rm structure')
def update(self, t, inputTrain): if inputTrain[t]: # check for input spike self.t_list = cc([self.t_list, [1]]) # Calculate synaptic current due to current and past input spikes self.g_syn = np.sum(self.alpha_func[self.t_list]) self.I_syn = self.g_syn * (self.E_syn - self.V) # Update spike times if np.any(self.t_list): self.t_list = self.t_list + 1 if self.t_list[ 0] == self.synConductanceMaxDuration: # Reached max duration of syn conductance self.t_list = self.t_list[1:] # Compute membrane voltage # Euler method: V(t+h) = V(t) + h*dV/dt if not self.fired: self.V = self.V + (-((self.V - self.E_leak) * (1 + self.R * self.g_ad) / (self.R * self.C)) + (self.I_syn / self.C)) self.g_ad = self.g_ad + (-self.g_ad / self.tau_ad ) # spike rate adaptation else: self.fired -= 1 self.V = self.V_th - 10 # reset voltage after spike self.g_ad = 0 # Generate spike if (self.V > self.V_th) and not self.fired: self.V = self.V_spike self.fired = 4 self.g_ad = self.g_ad + self.G_inc
def test_trajectory_with_speed_pause_but_not_distance_pause_is_left_untouched(self): speeds = cc([np.random.uniform(0, 1, 500) + 3, np.random.uniform(0, 0.01, 20), np.random.uniform(0, 1, 500) + 3]) dists = cc([np.random.uniform(0, 1, 500) + 9, np.random.uniform(0, 0.003, 20) + 4, np.random.uniform(0, 1, 500) + 9]) start_timepoint_id = 10883 traj = Trajectory(start_timepoint_id, speeds, dists) clean_portions = clean_trajectories.clean_traj(traj, CLEANING_PARAMS) self.assertEqual(len(clean_portions), 1) self.assertEqual(clean_portions[0, 0], traj.start_timepoint_id) self.assertEqual(clean_portions[0, 1], traj.end_timepoint_id)
def testget_rotated_atoms(self): a = Atoms('C2', [[1, 0, 1], [0, 1, 1]]) a.set_cell([[1, 0, 1], [0, 1, 1], [0, 0, 1]]) d = lammpsdata(a) unit = d.get_rotated_atoms() self.assertTrue( cc(unit.cell[:2], [[sqrt(2), 0, 0], [sqrt(2) / 2, sqrt(2) * sqrt(3) / 2, 0]]))
def initialize(self): """Reset insect history.""" # check that all params are set for param in [self.r, self.d, self.a, self.tau, self.w, self.loglike_function]: if param is None: param_str = ', '.join(self.param_names) msg = ('Please make sure all of the following parameters are set:' '%s.' % param_str) raise ValueError(msg) # reset clock self.ts = 0 # timestep self.t = 0. # time # reset src pos logprob self.logprob = np.zeros(self.env.shape, dtype=float) # get odor domain from loglikelihood function self.odor_domain = self.loglike_function.domain # calculate extended loglikelihood map # get environment geometry xext = self.env.x - self.env.x[0] xext = cc([-xext[1:][::-1], xext]) yext = self.env.y - self.env.y[0] yext = cc([-yext[1:][::-1], yext]) zext = self.env.z - self.env.z[0] zext = cc([-zext[1:][::-1], zext]) central_idx = ((len(xext) - 1)/2, (len(yext) - 1)/2, (len(zext) - 1)/2) map_shape = (len(xext), len(yext), len(zext)) self.loglike_map = np.zeros((len(self.odor_domain), ) + map_shape, dtype=float) for odor_idx, odor in enumerate(self.odor_domain): loglike = self.loglike_function(odor, central_idx, xext=xext, yext=yext, zext=zext, dt=self.dt, w=self.w, r=self.r, d=self.d, a=self.a, tau=self.tau) self.loglike_map[odor_idx] = loglike
def segment_by_threshold(data, th=1., seg_start='last', seg_end='next', idxs=None): """Function to segment a 1D data time-series.""" # create mask of all points that at least threshold above_th = (np.array(data) >= th).astype(int) # create onset/offset trigger array trigger = np.diff(cc([[0], above_th, [0]])) # identify onsets onsets = (trigger == 1).nonzero()[0] # identify offsets offsets = (trigger == -1).nonzero()[0] offsets -= 1 # add segment starts and ends if specified if seg_start == 'last': starts = np.zeros(onsets.shape, dtype=int) starts[1:] = offsets[:-1] + 1 if idxs is not None: starts = idxs[starts] starts = starts[:, None] else: starts = np.zeros(onsets.shape + (0, ), dtype=int) if seg_end == 'next': ends = len(data) * np.ones(offsets.shape, dtype=int) ends[:-1] = onsets[1:] ends -= 1 if idxs is not None: ends = idxs[ends] ends = ends[:, None] else: ends = np.zeros(onsets.shape + (0, ), dtype=int) if idxs is not None: onsets = idxs[onsets] offsets = idxs[offsets] onsets = onsets[:, None] offsets = offsets[:, None] return cc([starts, onsets, offsets, ends], 1)
def testwritedata(self): a = Atoms('C2', [[1, 0, 1], [0, 1, 1]]) a.set_cell([[1, 0, 1], [0, 1, 1], [0, 0, 1]]) d = lammpsdata(a, ['C', 'N']) d.writedata() b = data('structure') self.assertEqual(b.headers["atoms"], 2) self.assertEqual(b.headers["atom types"], 2) self.assertEqual(b.title, 'C2\n') self.assertTrue(cc(b.headers["xlo xhi"], [0, sqrt(2)])) self.assertTrue(cc(b.headers["ylo yhi"], [0, sqrt(2) * sqrt(3) / 2])) self.assertTrue(cc(b.headers["xy xz yz"][0:1], [sqrt(2) / 2])) b.map(1, 'id', 2, 'type', 3, 'x', 4, 'y', 5, 'z') atoms = b.viz(0)[2] self.assertTrue( cc(atoms, [[1, 1, sqrt(2), 0, 0], [2, 1, sqrt(2) / 2, sqrt(2) * sqrt(3) / 2, 0]])) shell_exec('rm structure')
def test_traj_with_pause_in_middle_has_pause_removed(self): speeds = cc([np.random.uniform(0, 1, 500) + 3, np.random.uniform(0, 0.01, 20), np.random.uniform(0, 1, 500) + 3]) dists = cc([np.random.uniform(0, 1, 500) + 9, np.random.uniform(0, 0.003, 20), np.random.uniform(0, 1, 500) + 9]) start_timepoint_id = 10883 traj = Trajectory(start_timepoint_id, speeds, dists) clean_portions = clean_trajectories.clean_traj(traj, CLEANING_PARAMS) self.assertEqual(len(clean_portions), 2) self.assertEqual(clean_portions[0, 0], start_timepoint_id) self.assertEqual(clean_portions[0, 1], start_timepoint_id + 500 - 1) self.assertEqual(clean_portions[1, 0], start_timepoint_id + 520) self.assertEqual(clean_portions[1, 1], traj.end_timepoint_id)
def fit(self, xs, y): """Fit signal & feedback filters from an input & output timeseries. Args: xs: list of input signals. """ # convert xs into fittable data array ## the format of the data matrix that will be fed into the statsmodels ## api is D = [1, x1, x2, x3, ..., y], where rows correspond to ## timepoints, 1 is a column vector of ones, x1 is a sliding window matrix ## for the first signal, etc., and y is a toeplitz matrix for the ## output ## generate sliding window matrices for each x xswms = [None] * self.sig_dim for sctr, x in enumerate(xs): sf_len = self.sig_filter_lens[sctr] start = self.max_filter_len - sf_len xswms[sctr] = swm(x, sf_len, start=start, end=-1) ## generate sliding window matrix for y start = self.max_filter_len - self.fdbk_filter_len yswm = swm(y, self.fdbk_filter_len, start=start, end=-1) ## generate complete input data array data_in = cc(xswms + [yswm], axis=1) # add constant to data data_in = sm.add_constant(data_in) # count rows nrows = data_in.shape[0] # fit data model = sm.GLM(y[-nrows:], data_in, family=sm.families.Gaussian()) params = model.fit().params # store parameters self.constant = params[0] ctr = 1 for sctr in range(self.sig_dim): sf_len = self.sig_filter_lens[sctr] self.sig_filters[sctr] = params[ctr:ctr + sf_len][::-1] ctr += sf_len self.fdbk_filter = params[ctr:][::-1]
def test_traj_with_middle_and_end_pause_is_cleaned_correctly(self): speeds = cc([np.random.uniform(0, 1, 100) + 3, np.random.uniform(0, 0.01, 20), # long pause np.random.uniform(0, 1, 80) + 3, np.random.uniform(0, 0.01, 20)]) # long pause dists = cc([np.random.uniform(0, 1, 100) + 3, np.random.uniform(0, 0.01, 20), # long pause np.random.uniform(0, 1, 80) + 3, np.random.uniform(0, 0.01, 20)]) # long pause start_timepoint_id = 9809 traj = Trajectory(start_timepoint_id, speeds, dists) clean_portions = clean_trajectories.clean_traj(traj, CLEANING_PARAMS) self.assertEqual(len(clean_portions), 2) self.assertEqual(clean_portions[0, 0], start_timepoint_id) self.assertEqual(clean_portions[0, 1], start_timepoint_id + 100 - 1) self.assertEqual(clean_portions[1, 0], start_timepoint_id + 120) self.assertEqual(clean_portions[1, 1], traj.end_timepoint_id - 20)
def gen(self, xs): """Generate an output signal from an input signal. Args: xs: list of input signals. """ # get signal length sig_len = len(xs[0]) # zeropad x's to make convolution easier zp = np.zeros((self.max_filter_len, ), dtype=float) xzps = [None for x in xs] for xctr, x in enumerate(xs): xzps[xctr] = cc([zp, x]) # generate zeropadded y yzp = np.zeros(xzps[0].shape, dtype=float) # fill in y (t refers to yzp's idx) for t in range(self.max_filter_len, self.max_filter_len + sig_len): # sequentially add components of y for each signal result = 0 for sctr in range(self.sig_dim): # get signal filter, its length, and relevant signal sf = self.sig_filters[sctr] sf_len = self.sig_filter_lens[sctr] sig = xzps[sctr][t - sf_len:t] # dot filter with signal (remembering to flip filter) result += np.dot(sf[::-1], sig) # add output feedback component ## get relevant output output = yzp[t - self.fdbk_filter_len:t] ## dot filter with output (remembering to flip filter) result += np.dot(self.fdbk_filter[::-1], output) # add constant result += self.constant # add Gaussian noise result += np.random.normal(0, self.noise) # store output in correct position yzp[t] = result # remove initial zeros from yzp and return return yzp[self.max_filter_len:]
ref_max = 4 / h # Starting value of ref period counter t_list = np.array([], dtype=int) V = E_leak V_trace = [V] t_trace = [0] plt.figure(2) plt.subplot(len(t_peaks), 2, 2 * index + 1) plt.plot(np.arange(0, t_max, h), spike_train) plt.title('Input spike train') for t in range(tstop): # Compute input if spike_train[t]: # check for input spike t_list = cc([t_list, [1]]) # Calculate synaptic current due to current and past input spikes g_syn = np.sum(alpha_func[t_list]) I_syn = g_syn * (E_syn - V) # Update spike times if np.any(t_list): t_list = t_list + 1 if t_list[0] == t_a: # Reached max duration of syn conductance t_list = t_list[1:] # Compute membrane voltage # Euler method: V(t+h) = V(t) + h*dV/dt if not ref: V = V + h * (-((V - E_leak) * (1 + R * g_ad) / (R * C)) +
def testget_rotated_atoms(self): a=Atoms('C2',[[1,0,1],[0,1,1]]) a.set_cell([[1,0,1],[0,1,1],[0,0,1]]) d=lammpsdata(a) unit=d.get_rotated_atoms() self.assertTrue(cc(unit.cell[:2],[[sqrt(2),0,0],[sqrt(2)/2,sqrt(2)*sqrt(3)/2,0]]))
# plot out vs. in-degree scatter axs[0,0].scatter(indeg, outdeg) axs[0,0].set_xlabel('indegree') axs[0,0].set_ylabel('outdegree') # plot out & in-degree distributions axs[0,1].hist(outdeg, bins=NBINS, orientation='horizontal') axs[0,1].set_ylabel('outdegree') axs[0,1].set_xlabel('# nodes') axs[1,0].hist(indeg, bins=NBINS) axs[1,0].set_xlabel('indegree') axs[1,0].set_ylabel('# nodes') # plot percent_indeg & percent_outdeg distributions axs[1,1].hist(cc([percent_indeg[None,:], percent_outdeg[None,:]]).T, bins=NBINS) axs[1,1].set_xlabel('% indegree (blue), % outdegree (green)') axs[1,1].set_ylabel('# nodes') [set_fontsize(ax, FONTSIZE) for ax in axs.flatten()] # plot total degree, vs in-out degree difference fig, axs = plt.subplots(2, 2, facecolor=FACECOLOR, tight_layout=True) # plot scatter axs[0,0].scatter(deg, deg_diff) axs[0,0].set_xlabel('degree') axs[0,0].set_ylabel('outdegree - indegree') # plot distributions axs[0,1].hist(deg_diff, bins=NBINS, orientation='horizontal')
V_spike = 50 # spike value mV ref_max = 4/h # Starting value of ref period counter t_list = np.array([], dtype=int) V = E_leak V_trace = [V] t_trace = [0] fig, axs = plt.subplots(2, 1) axs[0].plot(np.arange(0,t_max,h), spike_train) axs[0].set_title('Input spike train') for t in range(tstop): # Compute input if spike_train[t]: # check for input spike t_list = cc([t_list, [1]]) # print(t_list) # Calculate synaptic current due to current and past input spikes g_syn = np.sum(alpha_func[t_list]) I_syn = g_syn*(E_syn - V) # Update spike times if np.any(t_list): t_list = t_list + 1 if t_list[0] == t_a: # Reached max duration of syn conductance t_list = t_list[1:] # Compute membrane voltage # Euler method: V(t+h) = V(t) + h*dV/dt if not ref:
def fire_neuron(alpha_func, t_peak, t_max, ref=0): # alpha func synaptic conductance t_a = 100 # Max duration of syn conductance g_peak = 0.05 # nS (peak synaptic conductance) const = g_peak / (t_peak * np.exp(-1)) t_vec = np.arange(0, t_a + h, h) alpha_func = const * t_vec * (np.exp(-t_vec / t_peak)) plt.plot(t_vec[:80], alpha_func[:80]) plt.xlabel('t (in ms)') plt.title('Alpha Function (Synaptic Conductance for Spike at t=0)') plt.draw() #time.sleep(2) # capacitance and leak resistance C = 0.5 # nF R = 40 # M ohms print('C = {}'.format(C)) print('R = {}'.format(R)) # conductance and associated parameters to simulate spike rate adaptation g_ad = 0 G_inc = 1 / h tau_ad = 2 # Initialize basic parameters E_leak = -60 # mV, equilibrium potential E_syn = 0 # Excitatory synapse (why is this excitatory?) g_syn = 0 # Current syn conductance V_th = -40 # spike threshold mV V_spike = 50 # spike value mV ref_max = 4 / h # Starting value of ref period counter t_list = np.array([], dtype=int) V = E_leak V_trace = [V] t_trace = [0] fig, axs = plt.subplots(2, 1) axs[0].plot(np.arange(0, t_max, h), spike_train) axs[0].set_title('Input spike train') nSpikes = 0 for t in range(tstop): # Compute input if spike_train[t]: # check for input spike t_list = cc([t_list, [1]]) # Calculate synaptic current due to current and past input spikes g_syn = np.sum(alpha_func[t_list]) I_syn = g_syn * (E_syn - V) # Update spike times if np.any(t_list): t_list = t_list + 1 if t_list[0] == t_a: # Reached max duration of syn conductance t_list = t_list[1:] # Compute membrane voltage # Euler method: V(t+h) = V(t) + h*dV/dt if not ref: V = V + h * (-((V - E_leak) * (1 + R * g_ad) / (R * C)) + (I_syn / C)) g_ad = g_ad + h * (-g_ad / tau_ad) # spike rate adaptation else: ref -= 1 V = V_th - 10 # reset voltage after spike g_ad = 0 # Generate spike if (V > V_th) and not ref: V = V_spike ref = ref_max g_ad = g_ad + G_inc nSpikes += 1 V_trace += [V] t_trace += [t * h] axs[1].plot(t_trace, V_trace) plt.draw() axs[1].set_title('Output spike train') return (nSpikes, fig)
def main(val): numspikes = 0 np.random.seed(0) # I & F implementation dV/dt = - V/RC + I/C h = 1. # step size, Euler method, = dt ms t_max= 200 # ms, simulation time period tstop = int(t_max/h) # number of time steps ref = 0 # refractory period counter # Generate random input spikes # Note: This is not entirely realistic - no refractory period # Also: if you change step size h, input spike train changes too... thr = 0.9 # threshold for random spikes spike_train = np.random.rand(tstop) > thr # alpha func synaptic conductance t_a = 100 # Max duration of syn conductance t_peak = val # ms g_peak = 0.05 # nS (peak synaptic conductance) const = g_peak / (t_peak*np.exp(-1)); t_vec = np.arange(0, t_a + h, h) alpha_func = const * t_vec * (np.exp(-t_vec/t_peak)) '''plt.plot(t_vec[:80], alpha_func[:80]) plt.xlabel('t (in ms)') plt.title('Alpha Function (Synaptic Conductance for Spike at t=0)') plt.draw()''' # capacitance and leak resistance C = 0.5 # nF R = 40 # M ohms #print 'C = {}'.format(C) #print 'R = {}'.format(R) # conductance and associated parameters to simulate spike rate adaptation g_ad = 0 G_inc = 1/h tau_ad = 2 # Initialize basic parameters E_leak = -60 # mV, equilibrium potential E_syn = 0 # Excitatory synapse (why is this excitatory?) g_syn = 0 # Current syn conductance V_th = -40 # spike threshold mV V_spike = 50 # selfpike value mV ref_max = 4/h # Starting value of ref period counter t_list = np.array([], dtype=int) V = E_leak V_trace = [V] t_trace = [0] fig, axs = plt.subplots(2, 1) axs[0].plot(np.arange(0,t_max,h), spike_train) axs[0].set_title('Input spike train') for t in range(tstop): # Compute input if spike_train[t]: # check for input spike t_list = cc([t_list, [1]]) # Calculate synaptic current due to current and past input spikes g_syn = np.sum(alpha_func[t_list]) I_syn = g_syn*(E_syn - V) # Update spike times if np.any(t_list): t_list = t_list + 1 if t_list[0] == t_a: # Reached max duration of syn conductance t_list = t_list[1:] # Compute membrane voltage # Euler method: V(t+h) = V(t) + h*dV/dt if not ref: V = V + h*(-((V-E_leak)*(1+R*g_ad)/(R*C)) + (I_syn/C)) g_ad = g_ad + h*(-g_ad/tau_ad) # spike rate adaptation else: ref -= 1 V = V_th - 10 # reset voltage after spike g_ad = 0 # Generate spike if (V > V_th) and not ref: numspikes += 1 V = V_spike ref = ref_max g_ad = g_ad + G_inc V_trace += [V] t_trace += [t*h] '''