def create_net(): # Use a bit of a complicated spike and connection pattern with # heterogeneous delays # Note: it is important that all objects have the same name, this would # be the case if we were running this in a new process but to not rely # on garbage collection we will assign explicit names here source = SpikeGeneratorGroup( 5, np.arange(5).repeat(3), [3, 4, 1, 2, 3, 7, 5, 4, 1, 0, 5, 9, 7, 8, 9] * ms, name='source') target = NeuronGroup(10, 'v:1', name='target') synapses = Synapses(source, target, model='w:1', on_pre='v+=w', name='synapses') synapses.connect('j>=i') synapses.w = 'i*1.0 + j*2.0' synapses.delay = '(5-i)*ms' state_mon = StateMonitor(target, 'v', record=True, name='statemonitor') input_spikes = SpikeMonitor(source, name='input_spikes') net = Network(source, target, synapses, state_mon, input_spikes) return net
def test_store_restore_to_file_differing_nets(): # Check that the store/restore mechanism is not used with differing # networks filename = tempfile.mktemp(suffix='state', prefix='brian_test') source = SpikeGeneratorGroup(5, [0, 1, 2, 3, 4], [0, 1, 2, 3, 4] * ms, name='source_1') mon = SpikeMonitor(source, name='monitor') net = Network(source, mon) net.store(filename=filename) source_2 = SpikeGeneratorGroup(5, [0, 1, 2, 3, 4], [0, 1, 2, 3, 4] * ms, name='source_2') mon = SpikeMonitor(source_2, name='monitor') net = Network(source_2, mon) assert_raises(KeyError, lambda: net.restore(filename=filename)) net = Network(source) # Without the monitor assert_raises(KeyError, lambda: net.restore(filename=filename))
def test_spikegenerator(): """ Test dictionary representation of SpikeGenerator """ # example 1 size = 1 index = [0] time = [10] * ms spike_gen = SpikeGeneratorGroup(size, index, time) spike_gen_dict = collect_SpikeGenerator(spike_gen, get_local_namespace(0)) assert spike_gen_dict['N'] == size assert spike_gen_dict['indices'] == [0] assert spike_gen_dict['indices'].dtype == int assert spike_gen_dict['times'] == time assert spike_gen_dict['times'].has_same_dimensions(10 * ms) assert spike_gen_dict['times'].dtype == float # example 2 spike_gen2 = SpikeGeneratorGroup(10, index, time, period=20 * ms) var = 0.00002 spike_gen2.run_regularly('var = var + 1', dt=10 * ms, name='spikerr') spike_gen_dict = collect_SpikeGenerator(spike_gen2, get_local_namespace(0)) assert spike_gen_dict['N'] == 10 assert spike_gen_dict['period'] == [20] * ms assert spike_gen_dict['period'].has_same_dimensions(20 * ms) assert spike_gen_dict['period'].dtype == float # (check run_regularly) assert spike_gen_dict['run_regularly'][0]['name'] == 'spikerr' assert spike_gen_dict['run_regularly'][0]['code'] == 'var = var + 1' assert spike_gen_dict['run_regularly'][0]['dt'] == 10 * ms assert spike_gen_dict['run_regularly'][0]['when'] == 'start' assert spike_gen_dict['run_regularly'][0]['order'] == 0 assert spike_gen_dict['identifiers']['var'] == var with pytest.raises(IndexError): spike_gen_dict['run_regularly'][1]
def get_stimulus(start, stop, frequency): """ start -- start time of stimulus stop -- stop time of stimulus frequency -- frequency of stimulus """ times = np.arange(start / ms, stop / ms, 1 / (frequency / Hz) * 1e3) * ms stimulus = SpikeGeneratorGroup(1, [0] * len(times), times) return stimulus
def test_simple_syntax(): """ Simple example """ set_device('markdown') N = 10 tau = 10 * ms v_th = 0.9 * volt v_rest = -79 * mV eqn = 'dv/dt = (v_th - v)/tau :volt' refractory = 'randn() * tau / N' rates = 'rand() * 5 * Hz' group = NeuronGroup(N, eqn, method='euler', threshold='v > v_th', reset='v = v_rest; v = rand() * v_rest', refractory=refractory, events={'custom': 'v > v_th + 10 * mV', 'custom_1': 'v > v_th - 10 * mV'}) group.run_on_event('custom', 'v = v_rest') group.run_on_event('custom_1', 'v = v_rest - 0.001 * mV') spikegen = SpikeGeneratorGroup(N, [0, 1, 2], [1, 2, 3] * ms, period=5 * ms) po_grp = PoissonGroup(N - 1, rates=rates) syn = Synapses(spikegen, group, model='w :volt', on_pre='v = rand() * w + v_th; v = rand() * w', on_post='v = rand() * w + v_rest; v = rand() * w', delay=tau, method='euler') group.v[:] = v_rest group.v['i%2 == 0'] = 'rand() * v_rest' group.v[0:5] = 'v_rest + 10 * mV' condition = 'abs(i-j)<=5' syn.connect(condition=condition, p=0.999, n=2) syn.w = '1 * mV' net = Network(group, spikegen, po_grp, syn) mon = StateMonitor(syn, 'w', record=True) mon2 = SpikeMonitor(po_grp) mon3 = EventMonitor(group, 'custom') net.add(mon, mon2, mon3) net.run(0.01 * ms) md_str = device.md_text assert _markdown_lint(md_str) check = 'randn({sin({$w$}|$v_rest$ - $v$|/{\tau}})})' assert _markdown_lint(check) # check invalid strings with pytest.raises(SyntaxError): check = '**Initializing values at starting:*' assert _markdown_lint(check) check = '- Variable v$ of with $-79. mV$ to all members' assert _markdown_lint(check) check = 'randn({sin(})})' assert _markdown_lint(check) check = 'randn({sin({$w$}|$v_rest$ - $v$|/{\tau})})' assert _markdown_lint(check) device.reinit()
def test_spikemonitor(): """ Test collector function for SpikeMonitor """ # example 1 grp = NeuronGroup(5, '''dv/dt = (v0 - v)/tau :volt''', method='exact', threshold='v > v_th', reset='v = v0', name="My_Neurons") tau = 10 * ms v0 = -70 * mV v_th = 800 * mV mon = SpikeMonitor(grp, 'v', record=[0, 4]) mon_dict = collect_SpikeMonitor(mon) assert mon_dict['source'] == 'My_Neurons' assert mon_dict['variables'].sort() == ['i', 't', 'v'].sort() assert mon_dict['record'] == [0, 4] assert mon_dict['event'] == 'spike' assert mon_dict['when'] == 'thresholds' assert mon_dict['order'] == 1 # example 2 pos = PoissonGroup(5, rates=100 * Hz) smon = SpikeMonitor(pos, record=[0, 1, 2, 3, 4]) smon_dict = collect_SpikeMonitor(smon) assert smon_dict['source'] == pos.name assert 'i' in smon_dict['variables'] assert smon_dict['record'] == [0, 1, 2, 3, 4] assert smon_dict['when'] == 'thresholds' assert smon_dict['order'] == 1 # example 3 spk = SpikeGeneratorGroup(10, [2, 6, 8], [5 * ms, 10 * ms, 15 * ms]) spkmon = SpikeMonitor(spk, ['t', 'i'], record=0) smon_dict = collect_SpikeMonitor(spkmon) assert smon_dict['record'] == np.array([0]) assert 't' in smon_dict['variables'] assert smon_dict['source'] == spk.name assert smon_dict['when'] == 'thresholds' assert smon_dict['order'] == 1
def setup_generator(components): """ Setup the spike generator with 4+1 neurons and a spike monitor. The first 4 neurons represent the 4 input components in the following order: [I.up, I.dn, Q.up, Q.dn]. The last neuron fires a stop signal at the end of each input stimulus Parameters ---------- components : object previously defined network components Returns ------- components : dict network components """ gGen = SpikeGeneratorGroup(5, np.array([]), np.array([]) * ms, name='gGen') mGen = SpikeMonitor(gGen, name='mGen') components['generator'] = gGen components['monitors']['mGen'] = mGen return components
nAnfsPerInputFile = 40 nGbcsCoPerLson = 8 # Gjoni et al. 2018 nSbcsIpPerLson = 40 # Gjoni et al. 2018 #nGbcsCoPerLson = 1 # showing unitary IPSP #nSbcsIpPerLson = 1 # showing unitary EPSP #gbCoCellIndices = np.array([0]) #gbCoSpkTimes = np.array([10.0]) * ms sbIpCellIndices = np.array([0]) sbIpSpkTimes = np.array([5.0]) * ms #gbCoSpkGenGrp = SpikeGeneratorGroup(nAnfsPerInputFile, gbCoCellIndices, gbCoSpkTimes) sbIpSpkGenGrp = SpikeGeneratorGroup(nAnfsPerInputFile, sbIpCellIndices, sbIpSpkTimes) # Membrane and Ion-Channel parameters C = 21.7 * pF # 21.7pF: non-principal LSO neuron (Barnes-Davies et al. 2004) Eh = -43 * mV EK = -70 * mV # -77*mV in mod file El = -65 * mV ENa = 50 * mV nf = 0.85 # proportion of n vs p kinetics zss = 0.5 # steady state inactivation of glt # default temp_degC = 37., human body temperature in degree celcius # q10 for ion-channel time-constants (RM2003, p.3106): q10 = 3.**((temp_degC - 22.) / 10.) # q10 for ion-channel gbar parameters (RM2003, p.3106): q10gbar = 2.**((temp_degC - 22.) / 10.) # hcno current (octopus cell)
# Be careful to check that the offset data will stay within network boundaries xoff = 2 yoff = 3 for k in range(num_orientations): pop_data_R[str(k)] = pop_data_R[str(k)] + xoff + yoff * input_size_x #%% Spike generators - Simple Neruon stimuli # Set two spike generators that will play the data recorded during the esecution # of Monocular_neurons.py simple_neurons_L = [] simple_neurons_R = [] for k in range(num_orientations): simple_neurons_L.append( SpikeGeneratorGroup(num_input_neurons, pop_data_L[str(k)], pop_data_L[str(k) + 't'])) simple_neurons_R.append( SpikeGeneratorGroup(num_input_neurons, pop_data_R[str(k)], pop_data_R[str(k) + 't'])) #%% Setting up Network start_time = time.time() start = pop_data_L['start'] end = pop_data_L['end'] Net = teiliNetwork() # Neurons disparity_neurons = []
def lson(lsoInputSpkFileTuple, temp_degC=37): defaultclock.dt = 0.02*ms # for better precision neuron_type = 'LsoNp1a' # non-principal, moderately slow (typical) Vrest = -64.1*mV # observed resting potential for model LsoNp1a nLsons = 1 # number of LSO neurons # As in Wang & Colburn (2012), the LSO model has simplified inputs. # Spike times from model auditory nerve fibers represent inputs # driven by the cochlear nucleus: contralateral inhibitory inputs # driven by globular bushy cells via the MNTB, and ipsilateral # excitatory inputs from spherical bushy cells. nAnfsPerInputFile = 40 nGbcsCoPerLson = 8 # Gjoni et al. 2018 nSbcsIpPerLson = 40 # Gjoni et al. 2018 # sbCoSpkFile = inputSpkFileTuple[0] # sbIpSpkFile = lsoInputSpkFileTuple[1] # gbCoSpkFile = lsoInputSpkFileTuple[2] # gbIpSpkFile = inputSpkFileTuple[3] anCoSpkFile = lsoInputSpkFileTuple[0] anIpSpkFile = lsoInputSpkFileTuple[1] # sbCoIdxSpktimeArray = np.loadtxt(sbCoSpkFile) # sbCoCellIndices = sbCoIdxSpktimeArray[:, 0].astype(int) # sbCoSpkTimes = sbCoIdxSpktimeArray[:, 1] * ms # sbCoSpkGenGrp = SpikeGeneratorGroup(nSbcsCo, sbCoCellIndices, sbCoSpkTimes) gbCoIdxSpktimeArray = np.loadtxt(anCoSpkFile) gbCoCellIndices = gbCoIdxSpktimeArray[:, 0].astype(int) # For now, spiketimes from Zilany AN in SECONDS, so * 1000*ms gbCoSpkTimes = gbCoIdxSpktimeArray[:, 1] * 1000. * ms gbCoSpkGenGrp = SpikeGeneratorGroup(nAnfsPerInputFile, gbCoCellIndices, gbCoSpkTimes) sbIpIdxSpktimeArray = np.loadtxt(anIpSpkFile) sbIpCellIndices = sbIpIdxSpktimeArray[:, 0].astype(int) # For now, spiketimes from Zilany AN in SECONDS, so * 1000*ms sbIpSpkTimes = sbIpIdxSpktimeArray[:, 1] * 1000. * ms sbIpSpkGenGrp = SpikeGeneratorGroup(nAnfsPerInputFile, sbIpCellIndices, sbIpSpkTimes) # gbIpIdxSpktimeArray = np.loadtxt(gbIpSpkFile) # gbIpCellIndices = gbIpIdxSpktimeArray[:, 0].astype(int) # gbIpSpkTimes = gbIpIdxSpktimeArray[:, 1] * ms # gbIpSpkGenGrp = SpikeGeneratorGroup(nGbcsIp, gbIpCellIndices, gbIpSpkTimes) # anfIdxSpktimeArray = np.loadtxt(anfSpkFile) # anfIndices = anfIdxSpktimeArray[:, 0].astype(int) # nANF = 132 # #anfSpkTimes = [i * second for i in anfIdxSpktimeArray[:, 1]] # anfSpkTimes = anfIdxSpktimeArray[:, 1] * 1000*ms # anfSpkGeneratorGrp = SpikeGeneratorGroup(nANF, anfIndices, anfSpkTimes) # Membrane and Ion-Channel parameters # C = 12*pF C = 21.7*pF # 21.7pF: non-principal LSO neuron (Barnes-Davies et al. 2004) Eh = -43*mV EK = -70*mV # -77*mV in mod file El = -65*mV ENa = 50*mV nf = 0.85 # proportion of n vs p kinetics zss = 0.5 # steady state inactivation of glt # default temp_degC = 37., human body temperature in degree celcius # q10 for ion-channel time-constants (RM2003, p.3106): q10 = 3. ** ((temp_degC - 22.) / 10.) # q10 for ion-channel gbar parameters (RM2003, p.3106): q10gbar = 2. ** ((temp_degC - 22.) / 10.) # hcno current (octopus cell) frac = 0.0 qt = 4.5 ** ((temp_degC - 33.) / 10.) # Synaptic parameters: Es_e = 0.*mV tausE = 1.5*ms Es_i = -90*mV tausI = 3.0*ms '''Synaptic weights are unitless according to Brian2. The effective unit is siemens, so they can work in amp, volt, siemens eqns. We multiply synaptic weight w_e by unit siemens when adding it to g_e. We use a local variable w_e for synaptic weight rather than the standard w:''' w_elson = 4.5e-9 #0.7e-9 w_ilson = 45.e-9 #7e-9 # 6e-9 @ 200Hz; 12e-9 @ 600 Hz '''Here's why: The synapses sbc3SynE.w synaptic weight references the Same State Variable as as the neuron group sbc3Grp.w (klt activation w). Update sbc3Grp.w, and you set sbc3SynE.w to same value, and vice versa. This way klt activation and synaptic weight are identical and quite ridiculous. So use a local variable other than w for the synaptic weight!''' # Maximal conductances of different cell types in nS maximal_conductances = dict( LsoNp1a=(1000, 150, 0, 0, 1.85, 0, 7.4), type1c=(1000, 150, 0, 0, 0.5, 0, 2), type1t=(1000, 80, 0, 65, 0.5, 0, 2), type12=(1000, 150, 20, 0, 2, 0, 2), type21=(1000, 150, 35, 0, 3.5, 0, 2), type2=(1000, 150, 200, 0, 20, 0, 2), type2g2x=(2000, 300, 400, 0, 40, 0, 2), type2g1p5x=(1000, 150, 300, 0, 30, 0, 2), type2g1p2x=(1200, 180, 240, 0, 24, 0, 2), type2g0p5x=(1000, 150, 100, 0, 10, 0, 2), type2o=(1000, 150, 600, 0, 0, 40, 2) # octopus cell ) gnabar, gkhtbar, gkltbar, gkabar, ghbar, gbarno, gl = [x * nS for x in maximal_conductances[neuron_type]] # # Maximal conductances of different cell types in nS # maximal_conductances = dict( # type1c=(1000, 150, 0, 0, 0.5, 0, 2), # type1t=(1000, 80, 0, 65, 0.5, 0, 2), # type12=(1000, 150, 20, 0, 2, 0, 2), # type21=(1000, 150, 35, 0, 3.5, 0, 2), # type2=(1000, 150, 200, 0, 20, 0, 2), # type2gLTH2x=(1000, 150, 400, 0, 40, 0, 2), # type2gLTH0p5x=(1000, 150, 100, 0, 10, 0, 2), # type2o=(1000, 150, 600, 0, 0, 40, 2) # octopus cell # ) # gnabar, gkhtbar, gkltbar, gkabar, ghbar, gbarno, gl = [x * nS for x in maximal_conductances[neuron_type]] # Classical Na channel eqs_na = """ ina = gnabar*m**3*h*(ENa-v) : amp dm/dt=q10*(minf-m)/mtau : 1 dh/dt=q10*(hinf-h)/htau : 1 minf = 1./(1+exp(-(vu + 38.) / 7.)) : 1 hinf = 1./(1+exp((vu + 65.) / 6.)) : 1 mtau = ((10. / (5*exp((vu+60.) / 18.) + 36.*exp(-(vu+60.) / 25.))) + 0.04)*ms : second htau = ((100. / (7*exp((vu+60.) / 11.) + 10.*exp(-(vu+60.) / 25.))) + 0.6)*ms : second """ # KHT channel (delayed-rectifier K+) eqs_kht = """ ikht = gkhtbar*(nf*n**2 + (1-nf)*p)*(EK-v) : amp dn/dt=q10*(ninf-n)/ntau : 1 dp/dt=q10*(pinf-p)/ptau : 1 ninf = (1 + exp(-(vu + 15) / 5.))**-0.5 : 1 pinf = 1. / (1 + exp(-(vu + 23) / 6.)) : 1 ntau = ((100. / (11*exp((vu+60) / 24.) + 21*exp(-(vu+60) / 23.))) + 0.7)*ms : second ptau = ((100. / (4*exp((vu+60) / 32.) + 5*exp(-(vu+60) / 22.))) + 5)*ms : second """ # Ih channel (subthreshold adaptive, non-inactivating) eqs_ih = """ ih = ghbar*r*(Eh-v) : amp dr/dt=q10*(rinf-r)/rtau : 1 rinf = 1. / (1+exp((vu + 76.) / 7.)) : 1 rtau = ((100000. / (237.*exp((vu+60.) / 12.) + 17.*exp(-(vu+60.) / 14.))) + 25.)*ms : second """ # KLT channel (low threshold K+) eqs_klt = """ iklt = gkltbar*w**4*z*(EK-v) : amp dw/dt=q10*(winf-w)/wtau : 1 dz/dt=q10*(zinf-z)/ztau : 1 winf = (1. / (1 + exp(-(vu + 48.) / 6.)))**0.25 : 1 zinf = zss + ((1.-zss) / (1 + exp((vu + 71.) / 10.))) : 1 wtau = ((100. / (6.*exp((vu+60.) / 6.) + 16.*exp(-(vu+60.) / 45.))) + 1.5)*ms : second ztau = ((1000. / (exp((vu+60.) / 20.) + exp(-(vu+60.) / 8.))) + 50)*ms : second """ # Ka channel (transient K+) eqs_ka = """ ika = gkabar*a**4*b*c*(EK-v): amp da/dt=q10*(ainf-a)/atau : 1 db/dt=q10*(binf-b)/btau : 1 dc/dt=q10*(cinf-c)/ctau : 1 ainf = (1. / (1 + exp(-(vu + 31) / 6.)))**0.25 : 1 binf = 1. / (1 + exp((vu + 66) / 7.))**0.5 : 1 cinf = 1. / (1 + exp((vu + 66) / 7.))**0.5 : 1 atau = ((100. / (7*exp((vu+60) / 14.) + 29*exp(-(vu+60) / 24.))) + 0.1)*ms : second btau = ((1000. / (14*exp((vu+60) / 27.) + 29*exp(-(vu+60) / 24.))) + 1)*ms : second ctau = ((90. / (1 + exp((-66-vu) / 17.))) + 10)*ms : second """ # Leak eqs_leak = """ ileak = gl*(El-v) : amp """ # h current for octopus cells eqs_hcno = """ ihcno = gbarno*(h1*frac + h2*(1-frac))*(Eh-v) : amp dh1/dt=(hinfno-h1)/tau1 : 1 dh2/dt=(hinfno-h2)/tau2 : 1 hinfno = 1./(1+exp((vu+66.)/7.)) : 1 tau1 = bet1/(qt*0.008*(1+alp1))*ms : second tau2 = bet2/(qt*0.0029*(1+alp2))*ms : second alp1 = exp(1e-3*3*(vu+50)*9.648e4/(8.315*(273.16+temp_degC))) : 1 bet1 = exp(1e-3*3*0.3*(vu+50)*9.648e4/(8.315*(273.16+temp_degC))) : 1 alp2 = exp(1e-3*3*(vu+84)*9.648e4/(8.315*(273.16+temp_degC))) : 1 bet2 = exp(1e-3*3*0.6*(vu+84)*9.648e4/(8.315*(273.16+temp_degC))) : 1 """ eqs = """ dv/dt = (ileak + ina + ikht + iklt + ika + ih + ihcno + I + Is_e + Is_i)/C : volt Is_e = gs_e * (Es_e - v) : amp gs_e : siemens Is_i = gs_i * (Es_i - v) : amp gs_i : siemens vu = v/mV : 1 # unitless v I : amp """ #Added Is_i to RM2003 eqs += eqs_leak + eqs_ka + eqs_na + eqs_ih + eqs_klt + eqs_kht + eqs_hcno lsonGrp = NeuronGroup(nLsons, eqs, method='exponential_euler', threshold='v > -30*mV', refractory='v > -45*mV') #gbcGrp.I = 2500.0*pA lsonGrp.I = 0.0*pA # Initialize model near v_rest with no inputs lsonGrp.v = Vrest vu = lsonGrp.v/mV # unitless v lsonGrp.m = 1./(1+exp(-(vu + 38.) / 7.)) lsonGrp.h = 1./(1+exp((vu + 65.) / 6.)) lsonGrp.n = (1 + exp(-(vu + 15) / 5.))**-0.5 lsonGrp.p = 1. / (1 + exp(-(vu + 23) / 6.)) lsonGrp.r = 1. / (1+exp((vu + 76.) / 7.)) lsonGrp.w = (1. / (1 + exp(-(vu + 48.) / 6.)))**0.25 lsonGrp.z = zss + ((1.-zss) / (1 + exp((vu + 71.) / 10.))) lsonGrp.a = (1. / (1 + exp(-(vu + 31) / 6.)))**0.25 lsonGrp.b = 1. / (1 + exp((vu + 66) / 7.))**0.5 lsonGrp.c = 1. / (1 + exp((vu + 66) / 7.))**0.5 lsonGrp.h1 = 1./(1+exp((vu+66.)/7.)) lsonGrp.h2 = 1./(1+exp((vu+66.)/7.)) #lsonGrp.gs_e = 0.0*siemens #netGbcEq = Network(gbcGrp, report='text') #netGbcEq.run(50*ms, report='text') lsonSynI = Synapses(gbCoSpkGenGrp, lsonGrp, model='''dg_i/dt = -g_i/tausI : siemens (clock-driven) gs_i_post = g_i : siemens (summed)''', on_pre='g_i += w_ilson*siemens', method = 'exact') lsonSynI.connect(i=np.arange(nGbcsCoPerLson), j=0) lsonSynE = Synapses(sbIpSpkGenGrp, lsonGrp, model='''dg_e/dt = -g_e/tausE : siemens (clock-driven) gs_e_post = g_e : siemens (summed)''', on_pre='g_e += w_elson*siemens', method = 'exact') lsonSynE.connect(i=np.arange(nSbcsIpPerLson), j=0) lsonSpks = SpikeMonitor(lsonGrp) lsonState = StateMonitor(lsonGrp, ['v','gs_e'], record=True) run(8150*ms, report='text') plt.plot(lsonState.t / ms, lsonState[0].v / mV) #plt.plot(gbcState.t / ms, gbcState[0].gs_e) #plt.plot(gSynEState.t / ms, gSynEState[0].gs_e_post) #plt.plot(gSynEState.t / ms, gSynEState[0].g_e) plt.xlabel('t (ms)') plt.ylabel('v (mV)') plt.show() dBSPLStrCo = anCoSpkFile[28:30] dBSPLStrIp = anIpSpkFile[28:30] dBSPLCo = int(dBSPLStrCo) dBSPLIp = int(dBSPLStrIp) IIDdB = dBSPLCo - dBSPLIp if (IIDdB >= 0): IIDdBStr = 'IIDP' + str(IIDdB).zfill(2) + 'dBSPL' elif (IIDdB < 0): IIDdBStr = 'IIDN' + str(-IIDdB).zfill(2) + 'dBSPL' # Synaptic parameters in output filename if (abs(round(tausE/ms)-(tausE/ms)) < 0.1): Te = str(round(tausE/ms)) else: #Te = str(tausE/ms) Te = str(round(10*tausE/ms)/10.) Te = Te.replace('.','p') if (abs(round(w_elson/1e-9)-(w_elson/1e-9)) < 0.1): We = str(round(w_elson/1e-9)) else: #We = str(w_elson/1e-9) We = str(round(10*w_elson/1e-9)/10) We = We.replace('.','p') if (abs(round(tausI/ms)-(tausI/ms)) < 0.1): Ti = str(round(tausI/ms)) else: Ti = str(tausI/ms) Ti = Ti.replace('.','p') if (abs(round(w_ilson/1e-9)-(w_ilson/1e-9)) < 0.1): Wi = str(round(w_ilson/1e-9)) else: Wi = str(w_ilson/1e-9) Wi = Wi.replace('.','p') # lsonSpkFile = 'Lso1aSpTms' + anCoSpkFile[6:13] + anCoSpkFile[16:23] + 'Te'+Te + 'We'+We + 'Ti'+Ti + 'Wi'+Wi + EIPDstr + 'Co' + anCoSpkFile[38:40] + anCoSpkFile[23:31] + anCoSpkFile[45:] # CaCF, Te We Ti Wi, IID, SPLdBiNNcDD, .txt lsonSpkFile = 'Lso1aSpTms' + anCoSpkFile[10:17] + 'Te'+Te + 'We'+We + 'Ti'+Ti + 'Wi'+Wi + IIDdBStr + 'co'+dBSPLStrCo + 'ip'+dBSPLStrIp + anCoSpkFile[35:] file0 = open(lsonSpkFile,'w') for index in range(len(lsonSpks.t)): file0.write(str(lsonSpks.i[index]) + " " + str(lsonSpks.t[index] / ms) + '\n') file0.close() return (lsonGrp, lsonSpks, lsonState) # end of mkgbcs
def rotating_bar(length=10, input_size_x=240, input_size_y=180, offx=0, offy=0, angle_step=10, ts_offset=10 * ms): """ This function returns a single spikegenerator group (Brian object), and the events related to it. It produces a stimuli of a rotating bar, ideal for testing orientation selective populations Args: length (int): `length` of the bar in pixel. input_size_x(int) : size of the input population x coordinate by default set as the DAVIS resolution input_size_y(int) : size of the input population y coordinate by default set as the DAVIS resolution offx(int): horizontal offset of the stimuli center (0, or centered in the middle by default) offy(int): vertical offset of the stimuli center (0, or centered in the middle by default) angle step(int) : the number of steps that the bar will use in order to rotate starting from 0 to 2*pi ts_offset (seconds_brian): time between each consecutive fire of the population (time occurring between each bar position) It's only applied in the spike generator, the event timestamps don't have units! Returns: SpikeGenerator obj: Brian2 objects which holds the spiketimes as well as the respective neuron indices events list: A list containing the events as x,y coordinates, polatirty and timestamps """ x_coord = [] y_coord = [] pol = [] ts = [] center = (input_size_x / 2 + offx, input_size_y / 2 + offy) angles = np.linspace(0, np.pi * 2, angle_step) for i, cAngle in enumerate(angles): endy_1 = center[1] + ((length / 2) * np.sin((cAngle))) endx_1 = center[0] + ((length / 2) * np.cos((cAngle))) endy_2 = center[1] - ((length / 2) * np.sin((cAngle))) endx_2 = center[0] - ((length / 2) * np.cos((cAngle))) start = np.asarray((endx_1, endy_1)) end = np.asarray((endx_2, endy_2)) max_direction, max_length = max(enumerate(abs(end - start)), key=operator.itemgetter(1)) dv = (end - start) / max_length line = [dda_round(start)] for step in range(int(max_length)): line.append(dda_round((step + 1) * dv + start)) for coord in line: x_coord.append(coord[0]) y_coord.append(coord[1]) ts.append(i) pol.append(1) events = np.zeros((4, len(x_coord))) events[0, :] = np.asarray(x_coord) events[1, :] = np.asarray(y_coord) events[2, :] = np.asarray(ts) events[3, :] = np.asarray(pol) ind = xy2ind(events[0, :], events[1, :], input_size_x) stimuli_generator = SpikeGeneratorGroup(input_size_x * input_size_y, indices=ind, times=ts * ts_offset, name='rotating_bar') return stimuli_generator, events
# Chopping data and renaming variables(explicit separation of ON and OFF events) indOn = indInp2[0][0][(indInp2[0][1][:] * us >= start) * (indInp2[0][1][:] * us <= end)] indOff = indInp2[1][0][(indInp2[1][1][:] * us >= start) * (indInp2[1][1][:] * us <= end)] timeOn = indInp2[0][1][(indInp2[0][1][:] * us >= start) * (indInp2[0][1][:] * us <= end)] timeOff = indInp2[1][1][(indInp2[1][1][:] * us >= start) * (indInp2[1][1][:] * us <= end)] timeOn = (timeOn * ms) - start timeOff = (timeOff * ms) - start # select if you want to process ON or OFF events retina = SpikeGeneratorGroup(image_res, indices=indOn, times=timeOn, name='gPre') #retina = SpikeGeneratorGroup(image_res, indices=indOff, times=timeOff, name='gPre') #%% Artificial stimuli # Rotating bar with known angles, used to assest the net ability to encode orientation length = 15 center_offx = 0 center_offy = 0 angle_step = 40 ts_offset = 10 * defaultclock.dt retina, events = rotating_bar(length, input_size_x, input_size_y, center_offx, center_offy, angle_step, ts_offset)
def test_from_papers_example(): """ Test Izhikevich_2007 example `brian2.readthedocs.io/en/stable/examples/frompapers.Izhikevich_2007.html` """ set_device('markdown', build_on_run=False) # Parameters simulation_duration = 6 * second # Neurons taum = 10*ms Ee = 0*mV vt = -54*mV vr = -60*mV El = -74*mV taue = 5*ms # STDP taupre = 20*ms taupost = taupre gmax = .01 dApre = .01 dApost = -dApre * taupre / taupost * 1.05 dApost *= gmax dApre *= gmax # Dopamine signaling tauc = 1000*ms taud = 200*ms taus = 1*ms epsilon_dopa = 5e-3 # Setting the stage # Stimuli section input_indices = array([0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0]) input_times = array([500, 550, 1000, 1010, 1500, 1510, 3500, 3550, 4000, 4010, 4500, 4510])*ms input = SpikeGeneratorGroup(2, input_indices, input_times) neurons = NeuronGroup(2, '''dv/dt = (ge * (Ee-vr) + El - v) / taum : volt dge/dt = -ge / taue : 1''', threshold='v>vt', reset='v = vr', method='exact') neurons.v = vr neurons_monitor = SpikeMonitor(neurons) synapse = Synapses(input, neurons, model='''s: volt''', on_pre='v += s') synapse.connect(i=[0, 1], j=[0, 1]) synapse.s = 100. * mV # STDP section synapse_stdp = Synapses(neurons, neurons, model='''mode: 1 dc/dt = -c / tauc : 1 (clock-driven) dd/dt = -d / taud : 1 (clock-driven) ds/dt = mode * c * d / taus : 1 (clock-driven) dApre/dt = -Apre / taupre : 1 (event-driven) dApost/dt = -Apost / taupost : 1 (event-driven)''', on_pre='''ge += s Apre += dApre c = clip(c + mode * Apost, -gmax, gmax) s = clip(s + (1-mode) * Apost, -gmax, gmax) ''', on_post='''Apost += dApost c = clip(c + mode * Apre, -gmax, gmax) s = clip(s + (1-mode) * Apre, -gmax, gmax) ''', method='euler' ) synapse_stdp.connect(i=0, j=1) synapse_stdp.mode = 0 synapse_stdp.s = 1e-10 synapse_stdp.c = 1e-10 synapse_stdp.d = 0 synapse_stdp_monitor = StateMonitor(synapse_stdp, ['s', 'c', 'd'], record=[0]) # Dopamine signaling section dopamine_indices = array([0, 0, 0]) dopamine_times = array([3520, 4020, 4520])*ms dopamine = SpikeGeneratorGroup(1, dopamine_indices, dopamine_times) dopamine_monitor = SpikeMonitor(dopamine) reward = Synapses(dopamine, synapse_stdp, model='''''', on_pre='''d_post += epsilon_dopa''', method='exact') reward.connect() # Simulation # Classical STDP synapse_stdp.mode = 0 run(simulation_duration/2) # Dopamine modulated STDP synapse_stdp.mode = 1 run(simulation_duration/2) device.build() md_str = device.md_text assert _markdown_lint(md_str) device.reinit()
from brian2 import ms, mV, cm, uF, mS from brian2 import NeuronGroup, StateMonitor, Network, collect from brian2 import Synapses, SpikeGeneratorGroup, defaultclock, array import matplotlib.pyplot as plt # ============================================================================= # Simulation parameters simtime = 100 * ms defaultclock.dt = 0.1 * ms # ============================================================================= # ============================================================================= # EXTERNAL INPUTS indices = array([0]) times = array([50]) * ms EXT1 = SpikeGeneratorGroup(1, indices, times) EXT2 = SpikeGeneratorGroup(1, indices, times) # ============================================================================= print ("Building the Network...") # Parameters for Excitatory Neurons E_L = -80. * mV # reversal (rest) membrane potential V_thr = -45. * mV # threshold for spike V_reset = -80. * mV # reset potential after an emission of a spike C_m_E = 1.0 * uF/cm**2 # membrane capacitance g_L = 0.1 * mS/cm**2 # leak conductunce g_c = 0.2 * mS/cm**2 # coupling conductance tau_rp_E = 2.0 * ms # refractory period
# sbIpSpkGenGrp = SpikeGeneratorGroup(nAnfsPerInputFile, sbIpCellIndices, sbIpSpkTimes) nAnfsPerInputFile = 40 nGbcsCoPerLson = 8 # Gjoni et al. 2018 nSbcsIpPerLson = 40 # Gjoni et al. 2018 #nGbcsCoPerLson = 1 # showing unitary IPSP #nSbcsIpPerLson = 1 # showing unitary EPSP gbCoCellIndices = np.array([0]) gbCoSpkTimes = np.array([5.0]) * ms #sbIpCellIndices = np.array([0, 0]) #sbIpSpkTimes = np.array([10.0, 40.0]) * ms gbCoSpkGenGrp = SpikeGeneratorGroup(nAnfsPerInputFile, gbCoCellIndices, gbCoSpkTimes) #sbIpSpkGenGrp = SpikeGeneratorGroup(nAnfsPerInputFile, sbIpCellIndices, sbIpSpkTimes) # Membrane and Ion-Channel parameters C = 12 * pF Eh = -43 * mV EK = -70 * mV # -77*mV in mod file El = -65 * mV ENa = 55 * mV # 55*mV in RM2003; 50*mv by Brette nf = 0.85 # proportion of n vs p kinetics zss = 0.5 # steady state inactivation of glt # default temp_degC = 37., human body temperature in degree celcius # q10 for ion-channel time-constants (RM2003, p.3106): q10 = 3.**((temp_degC - 22.) / 10.) # q10 for ion-channel gbar parameters (RM2003, p.3106): q10gbar = 2.**((temp_degC - 22.) / 10.)
def lson(lsoInputSpkFileTuple, temp_degC=37): defaultclock.dt = 0.02 * ms # for better precision neuron_type = 'type2' # medium-fast membrane f0 180-260Hz, CF4kHz #temp_degC=37. Vrest = -63.6 * mV # resting potential for type1c from RM2003 nLsons = 1 # number of LSO neurons nGbcsCo = 4 # nGbcsIp = 4 # nSbcsCo = 4 nSbcsIp = 4 # nSbcs = 4 # nAnfsPerSbc = 3 # nGbcs = 4 # nAnfsPerGbc=30 nAnfsPerInputFile = 40 nGbcsCoPerLson = 8 # Gjoni et al. 2018 nSbcsIpPerLson = 40 # Gjoni et al. 2018 # sbCoSpkFile = inputSpkFileTuple[0] # sbIpSpkFile = lsoInputSpkFileTuple[1] # gbCoSpkFile = lsoInputSpkFileTuple[2] # gbIpSpkFile = inputSpkFileTuple[3] anCoSpkFile = lsoInputSpkFileTuple[0] anIpSpkFile = lsoInputSpkFileTuple[1] # sbCoIdxSpktimeArray = np.loadtxt(sbCoSpkFile) # sbCoCellIndices = sbCoIdxSpktimeArray[:, 0].astype(int) # sbCoSpkTimes = sbCoIdxSpktimeArray[:, 1] * ms # sbCoSpkGenGrp = SpikeGeneratorGroup(nSbcsCo, sbCoCellIndices, sbCoSpkTimes) gbCoIdxSpktimeArray = np.loadtxt(anCoSpkFile) gbCoCellIndices = gbCoIdxSpktimeArray[:, 0].astype(int) # For now, spiketimes from Zilany AN in SECONDS, so * 1000*ms gbCoSpkTimes = gbCoIdxSpktimeArray[:, 1] * 1000. * ms gbCoSpkGenGrp = SpikeGeneratorGroup(nAnfsPerInputFile, gbCoCellIndices, gbCoSpkTimes) sbIpIdxSpktimeArray = np.loadtxt(anIpSpkFile) sbIpCellIndices = sbIpIdxSpktimeArray[:, 0].astype(int) # For now, spiketimes from Zilany AN in SECONDS, so * 1000*ms sbIpSpkTimes = sbIpIdxSpktimeArray[:, 1] * 1000. * ms sbIpSpkGenGrp = SpikeGeneratorGroup(nAnfsPerInputFile, sbIpCellIndices, sbIpSpkTimes) # gbIpIdxSpktimeArray = np.loadtxt(gbIpSpkFile) # gbIpCellIndices = gbIpIdxSpktimeArray[:, 0].astype(int) # gbIpSpkTimes = gbIpIdxSpktimeArray[:, 1] * ms # gbIpSpkGenGrp = SpikeGeneratorGroup(nGbcsIp, gbIpCellIndices, gbIpSpkTimes) # anfIdxSpktimeArray = np.loadtxt(anfSpkFile) # anfIndices = anfIdxSpktimeArray[:, 0].astype(int) # nANF = 132 # #anfSpkTimes = [i * second for i in anfIdxSpktimeArray[:, 1]] # anfSpkTimes = anfIdxSpktimeArray[:, 1] * 1000*ms # anfSpkGeneratorGrp = SpikeGeneratorGroup(nANF, anfIndices, anfSpkTimes) # Membrane and Ion-Channel parameters C = 12 * pF EH = -43 * mV EK = -70 * mV # -77*mV in mod file EL = -65 * mV ENa = 55 * mV # 55*mV in RM2003; 50*mv by Brette nf = 0.85 # proportion of n vs p kinetics zss = 0.5 # steady state inactivation of glt # default temp_degC = 37., human body temperature in degree celcius # q10 for ion-channel time-constants (RM2003, p.3106): q10 = 3.**((temp_degC - 22.) / 10.) # q10 for ion-channel gbar parameters (RM2003, p.3106): q10gbar = 2.**((temp_degC - 22.) / 10.) # hcno current (octopus cell) frac = 0.0 qt = 4.5**((temp_degC - 33.) / 10.) # Synaptic parameters: Es_e = 0. * mV tausE = 0.5 * ms Es_i = -90 * mV tausI = 1.0 * ms '''Synaptic weights are unitless according to Brian2. The effective unit is siemens, so they can work in amp, volt, siemens eqns. We multiply synaptic weight w_e by unit siemens when adding it to g_e. We use a local variable w_e for synaptic weight rather than the standard w:''' w_elson = 5e-9 w_ilson = 50e-9 # 6e-9 @ 200Hz; 12e-9 @ 600 Hz '''Here's why: The synapses sbc3SynE.w synaptic weight references the Same State Variable as as the neuron group sbc3Grp.w (klt activation w). Update sbc3Grp.w, and you set sbc3SynE.w to same value, and vice versa. This way klt activation and synaptic weight are identical and quite ridiculous. So use a local variable other than w for the synaptic weight!''' # Maximal conductances of different cell types in nS maximal_conductances = dict( type1c=(1000, 150, 0, 0, 0.5, 0, 2), type1t=(1000, 80, 0, 65, 0.5, 0, 2), type12=(1000, 150, 20, 0, 2, 0, 2), type21=(1000, 150, 35, 0, 3.5, 0, 2), type2=(1000, 150, 200, 0, 20, 0, 2), type2g1p5x=(1000, 150, 300, 0, 30, 0, 2), type2g0p5x=(1000, 150, 100, 0, 10, 0, 2), type2o=(1000, 150, 600, 0, 0, 40, 2) # octopus cell ) gnabar, gkhtbar, gkltbar, gkabar, ghbar, gbarno, gl = [ x * nS for x in maximal_conductances[neuron_type] ] # Classical Na channel eqs_na = """ ina = gnabar*m**3*h*(ENa-v) : amp dm/dt=q10*(minf-m)/mtau : 1 dh/dt=q10*(hinf-h)/htau : 1 minf = 1./(1+exp(-(vu + 38.) / 7.)) : 1 hinf = 1./(1+exp((vu + 65.) / 6.)) : 1 mtau = ((10. / (5*exp((vu+60.) / 18.) + 36.*exp(-(vu+60.) / 25.))) + 0.04)*ms : second htau = ((100. / (7*exp((vu+60.) / 11.) + 10.*exp(-(vu+60.) / 25.))) + 0.6)*ms : second """ # KHT channel (delayed-rectifier K+) eqs_kht = """ ikht = gkhtbar*(nf*n**2 + (1-nf)*p)*(EK-v) : amp dn/dt=q10*(ninf-n)/ntau : 1 dp/dt=q10*(pinf-p)/ptau : 1 ninf = (1 + exp(-(vu + 15) / 5.))**-0.5 : 1 pinf = 1. / (1 + exp(-(vu + 23) / 6.)) : 1 ntau = ((100. / (11*exp((vu+60) / 24.) + 21*exp(-(vu+60) / 23.))) + 0.7)*ms : second ptau = ((100. / (4*exp((vu+60) / 32.) + 5*exp(-(vu+60) / 22.))) + 5)*ms : second """ # Ih channel (subthreshold adaptive, non-inactivating) eqs_ih = """ ih = ghbar*r*(EH-v) : amp dr/dt=q10*(rinf-r)/rtau : 1 rinf = 1. / (1+exp((vu + 76.) / 7.)) : 1 rtau = ((100000. / (237.*exp((vu+60.) / 12.) + 17.*exp(-(vu+60.) / 14.))) + 25.)*ms : second """ # KLT channel (low threshold K+) eqs_klt = """ iklt = gkltbar*w**4*z*(EK-v) : amp dw/dt=q10*(winf-w)/wtau : 1 dz/dt=q10*(zinf-z)/ztau : 1 winf = (1. / (1 + exp(-(vu + 48.) / 6.)))**0.25 : 1 zinf = zss + ((1.-zss) / (1 + exp((vu + 71.) / 10.))) : 1 wtau = ((100. / (6.*exp((vu+60.) / 6.) + 16.*exp(-(vu+60.) / 45.))) + 1.5)*ms : second ztau = ((1000. / (exp((vu+60.) / 20.) + exp(-(vu+60.) / 8.))) + 50)*ms : second """ # Ka channel (transient K+) eqs_ka = """ ika = gkabar*a**4*b*c*(EK-v): amp da/dt=q10*(ainf-a)/atau : 1 db/dt=q10*(binf-b)/btau : 1 dc/dt=q10*(cinf-c)/ctau : 1 ainf = (1. / (1 + exp(-(vu + 31) / 6.)))**0.25 : 1 binf = 1. / (1 + exp((vu + 66) / 7.))**0.5 : 1 cinf = 1. / (1 + exp((vu + 66) / 7.))**0.5 : 1 atau = ((100. / (7*exp((vu+60) / 14.) + 29*exp(-(vu+60) / 24.))) + 0.1)*ms : second btau = ((1000. / (14*exp((vu+60) / 27.) + 29*exp(-(vu+60) / 24.))) + 1)*ms : second ctau = ((90. / (1 + exp((-66-vu) / 17.))) + 10)*ms : second """ # Leak eqs_leak = """ ileak = gl*(EL-v) : amp """ # h current for octopus cells eqs_hcno = """ ihcno = gbarno*(h1*frac + h2*(1-frac))*(EH-v) : amp dh1/dt=(hinfno-h1)/tau1 : 1 dh2/dt=(hinfno-h2)/tau2 : 1 hinfno = 1./(1+exp((vu+66.)/7.)) : 1 tau1 = bet1/(qt*0.008*(1+alp1))*ms : second tau2 = bet2/(qt*0.0029*(1+alp2))*ms : second alp1 = exp(1e-3*3*(vu+50)*9.648e4/(8.315*(273.16+temp_degC))) : 1 bet1 = exp(1e-3*3*0.3*(vu+50)*9.648e4/(8.315*(273.16+temp_degC))) : 1 alp2 = exp(1e-3*3*(vu+84)*9.648e4/(8.315*(273.16+temp_degC))) : 1 bet2 = exp(1e-3*3*0.6*(vu+84)*9.648e4/(8.315*(273.16+temp_degC))) : 1 """ eqs = """ dv/dt = (ileak + ina + ikht + iklt + ika + ih + ihcno + I + Is_e + Is_i)/C : volt Is_e = gs_e * (Es_e - v) : amp gs_e : siemens Is_i = gs_i * (Es_i - v) : amp gs_i : siemens vu = v/mV : 1 # unitless v I : amp """ #Added Is_i to RM2003 eqs += eqs_leak + eqs_ka + eqs_na + eqs_ih + eqs_klt + eqs_kht + eqs_hcno lsonGrp = NeuronGroup(nLsons, eqs, method='exponential_euler', threshold='v > -30*mV', refractory='v > -45*mV') #gbcGrp.I = 2500.0*pA lsonGrp.I = 0.0 * pA # Initialize model near v_rest with no inputs lsonGrp.v = Vrest #vu = EL/mV # unitless v vu = lsonGrp.v / mV # unitless v lsonGrp.m = 1. / (1 + exp(-(vu + 38.) / 7.)) lsonGrp.h = 1. / (1 + exp((vu + 65.) / 6.)) lsonGrp.n = (1 + exp(-(vu + 15) / 5.))**-0.5 lsonGrp.p = 1. / (1 + exp(-(vu + 23) / 6.)) lsonGrp.r = 1. / (1 + exp((vu + 76.) / 7.)) lsonGrp.w = (1. / (1 + exp(-(vu + 48.) / 6.)))**0.25 lsonGrp.z = zss + ((1. - zss) / (1 + exp((vu + 71.) / 10.))) lsonGrp.a = (1. / (1 + exp(-(vu + 31) / 6.)))**0.25 lsonGrp.b = 1. / (1 + exp((vu + 66) / 7.))**0.5 lsonGrp.c = 1. / (1 + exp((vu + 66) / 7.))**0.5 lsonGrp.h1 = 1. / (1 + exp((vu + 66.) / 7.)) lsonGrp.h2 = 1. / (1 + exp((vu + 66.) / 7.)) #lsonGrp.gs_e = 0.0*siemens #netGbcEq = Network(gbcGrp, report='text') #netGbcEq.run(50*ms, report='text') lsonSynI = Synapses(gbCoSpkGenGrp, lsonGrp, model='''dg_i/dt = -g_i/tausI : siemens (clock-driven) gs_i_post = g_i : siemens (summed)''', on_pre='g_i += w_ilson*siemens', method='exact') lsonSynI.connect(i=np.arange(nGbcsCoPerLson), j=0) lsonSynE = Synapses(sbIpSpkGenGrp, lsonGrp, model='''dg_e/dt = -g_e/tausE : siemens (clock-driven) gs_e_post = g_e : siemens (summed)''', on_pre='g_e += w_elson*siemens', method='exact') lsonSynE.connect(i=np.arange(nSbcsIpPerLson), j=0) lsonSpks = SpikeMonitor(lsonGrp) lsonState = StateMonitor(lsonGrp, ['v', 'gs_e'], record=True) run(300 * ms, report='text') # Console Output Won't Clear from Script # Memory issue with so many repeated simulations: # Comment out the plt commands #plt.plot(lsonState.t / ms, lsonState[0].v / mV) #plt.xlabel('t (ms)') #plt.ylabel('v (mV)') #plt.show() # Output file - EIPD in output filename. Spiketimes in file EPhsStrCo = anCoSpkFile[27:31] EPhsStrIp = anIpSpkFile[27:31] if (EPhsStrCo[0] == 'N'): EPhsIntCo = -1 * int(EPhsStrCo[1:4]) else: EPhsIntCo = int(EPhsStrCo[0:3]) if (EPhsStrIp[0] == 'N'): EPhsIntIp = -1 * int(EPhsStrIp[1:4]) else: EPhsIntIp = int(EPhsStrIp[0:3]) # EIPD = (EPhsIntCo - EPhsIntIp) % 360 EIPDint = (EPhsIntCo - EPhsIntIp) # unwrapped Envelope IPD #EIPDstr = str(EIPDint) if (EIPDint == 15): EIPDstr = 'EIPDP015' elif (EIPDint == 30): EIPDstr = 'EIPDP030' elif (EIPDint == 45): EIPDstr = 'EIPDP045' elif (EIPDint == 60): EIPDstr = 'EIPDP060' elif (EIPDint == 75): EIPDstr = 'EIPDP075' elif (EIPDint == 90): EIPDstr = 'EIPDP090' elif (EIPDint == -15): EIPDstr = 'EIPDN015' elif (EIPDint == -30): EIPDstr = 'EIPDN030' elif (EIPDint == -45): EIPDstr = 'EIPDN045' elif (EIPDint == -60): EIPDstr = 'EIPDN060' elif (EIPDint == -75): EIPDstr = 'EIPDN075' elif (EIPDint == -90): EIPDstr = 'EIPDN090' elif (EIPDint > 0): EIPDstr = 'EIPDP' + str(EIPDint) elif (EIPDint < 0): EIPDstr = 'EIPDN' + str(-EIPDint) elif (EIPDint == 0): EIPDstr = 'EIPDP000' # if (EIPDint < 0): # EIPDstr = EIPDstr.replace('-','N') # Synaptic parameters in output filename if (abs(round(tausE / ms) - (tausE / ms)) < 0.1): Te = str(round(tausE / ms)) else: Te = str(tausE / ms) Te = Te.replace('.', 'p') if (abs(round(w_elson / 1e-9) - (w_elson / 1e-9)) < 0.1): We = str(round(w_elson / 1e-9)) else: We = str(w_elson / 1e-9) We = We.replace('.', 'p') if (abs(round(tausI / ms) - (tausI / ms)) < 0.1): Ti = str(round(tausI / ms)) else: Ti = str(tausI / ms) Ti = Ti.replace('.', 'p') if (abs(round(w_ilson / 1e-9) - (w_ilson / 1e-9)) < 0.1): Wi = str(round(w_ilson / 1e-9)) else: Wi = str(w_ilson / 1e-9) Wi = Wi.replace('.', 'p') lsonSpkFile = 'Lso2SpTms' + anCoSpkFile[6:13] + anCoSpkFile[ 16: 23] + 'Te' + Te + 'We' + We + 'Ti' + Ti + 'Wi' + Wi + EIPDstr + 'Co' + anCoSpkFile[ 38:40] + anCoSpkFile[23:31] + anCoSpkFile[45:] file0 = open(lsonSpkFile, 'w') for index in range(len(lsonSpks.t)): file0.write( str(lsonSpks.i[index]) + " " + str(lsonSpks.t[index] / ms) + '\n') file0.close() return (lsonGrp, lsonSpks, lsonState) # end of mkgbcs
ii_synapses = get_synapses( "ii_synapses", inh_neurons, inh_neurons, C=0.1, l=l_lambda, tau_I=6 * ms, A=-19 * nA, U=0.32, D=0.144 * second, F=0.06 * second, delay=0.8 * ms, ) # place holder for stimulus stimulus = SpikeGeneratorGroup(1, [], [] * ms, name="stimulus") spike_monitor_stimulus = SpikeMonitor(stimulus) static_synapses_exc = Synapses(stimulus, exc_neurons, "A : ampere (shared, constant)", on_pre="I_stimulus += A") static_synapses_exc.connect(p=1) static_synapses_exc.A = 18 * nA static_synapses_inh = Synapses(stimulus, inh_neurons, "A : ampere (shared, constant)", on_pre="I_stimulus += A") static_synapses_inh.connect(p=1)