def ousim(mu_amp, mu_offs, sigma_amp, sigma_offs, freq, V_th):
    # mu_amp, mu_offs, sigma_amp, sigma_offs, freq, V_th = config
    if sigma_amp > sigma_offs:
        sigma_amp = sigma_offs
    # print("Setting up OU LIF simulation...")
    ounet = Network()
    clock.reinit_default_clock()
    eqs =Equations('dV/dt = mu-(V+V0)/tau + sigma*I/sqrt(dt) : volt')
    eqs+=Equations('dI/dt = -I/dt + xi/sqrt(dt) : 1')
    eqs+=Equations('mu = mu_amp*sin(t*freq*2*pi) + mu_offs : volt/second')
    eqs+=Equations('sigma = sigma_amp*sin(t*freq*2*pi) + sigma_offs :'
                                                        ' volt/sqrt(second)')
    eqs.prepare()
    ounrn = NeuronGroup(1, eqs, threshold=V_th, refractory=t_refr,
                                                                reset=V_reset)
    ounet.add(ounrn)

    ounrn.V = V0
    V_mon = StateMonitor(ounrn, 'V', record=True)
    st_mon = SpikeMonitor(ounrn)
    ounet.add(V_mon, st_mon)

    ounet.run(duration)

    V_mon.insert_spikes(st_mon, value=V_th*2)
    times = V_mon.times
    membrane = V_mon[0]
    return times, st_mon.spiketimes[0], membrane
示例#2
0
def test_voxel():

    voxel_params = default_params
    #    voxel_params.e_base=.7
    #    voxel_params.tau_o=2.7*second
    #    voxel_params.tau_s=0.95
    voxel = Voxel(params=voxel_params)
    voxel.G_base = 0.01 * nS
    voxel_monitor = MultiStateMonitor(
        voxel,
        vars=['G_total', 's', 'f_in', 'v', 'f_out', 'q', 'y'],
        record=True)

    @network_operation(when='start')
    def get_input():
        if 5 * second < defaultclock.t < 5.05 * second:
            voxel.G_total = 1 * nS
        else:
            voxel.G_total = voxel.G_base

    net = Network(voxel, get_input, voxel_monitor)
    reinit_default_clock()
    net.run(15 * second)

    voxel_params = zheng_params
    #voxel_params.e_base=.7
    #voxel_params.tau_o=2.7*second
    #voxel_params.tau_s=0.95
    new_voxel = ZhengVoxel(params=voxel_params)
    new_voxel.G_base = 0.01 * nS
    new_voxel_monitor = MultiStateMonitor(new_voxel,
                                          vars=[
                                              'G_total', 's', 'f_in', 'v',
                                              'f_out', 'q', 'y', 'g', 'cmr_o',
                                              'o_e', 'cb'
                                          ],
                                          record=True)

    @network_operation(when='start')
    def get_new_input():
        if 5 * second < defaultclock.t < 5.05 * second:
            new_voxel.G_total = 1 * nS
        else:
            new_voxel.G_total = new_voxel.G_base

    @network_operation()
    def compute_cmro():
        #print('phi=%.3f, f_in=%.3f, o_e=%.3f, o_elog=%.3f, c_ab=%.3f, cb=%.3f, cmr_o=%.3f, g=%.3f' %
        #      (new_voxel.phi, new_voxel.f_in, new_voxel.o_e, new_voxel.oe_log, new_voxel.c_ab, new_voxel.cb, new_voxel.cmr_o, new_voxel.g))
        #new_voxel.cmr_o=(new_voxel.cb-new_voxel.g*new_voxel.params.c_ab)/(new_voxel.params.cb_0-new_voxel.params.g_0*new_voxel.params.c_ab)
        new_voxel.oe_log = np.log(1.0 - new_voxel.o_e / (1.0 - new_voxel.g))

    new_net = Network(new_voxel, get_new_input, compute_cmro,
                      new_voxel_monitor)
    reinit_default_clock()
    new_net.run(15 * second)

    plot_results(voxel_monitor, new_voxel_monitor)
示例#3
0
def test_voxel():

    voxel_params=default_params
#    voxel_params.e_base=.7
#    voxel_params.tau_o=2.7*second
#    voxel_params.tau_s=0.95
    voxel=Voxel(params=voxel_params)
    voxel.G_base=0.01*nS
    voxel_monitor = MultiStateMonitor(voxel, vars=['G_total','s','f_in','v','f_out','q','y'], record=True)

    @network_operation(when='start')
    def get_input():
        if 5*second < defaultclock.t < 5.05*second:
            voxel.G_total=1*nS
        else:
            voxel.G_total=voxel.G_base

    net=Network(voxel, get_input, voxel_monitor)
    reinit_default_clock()
    net.run(15*second)

    voxel_params=zheng_params
    #voxel_params.e_base=.7
    #voxel_params.tau_o=2.7*second
    #voxel_params.tau_s=0.95
    new_voxel=ZhengVoxel(params=voxel_params)
    new_voxel.G_base=0.01*nS
    new_voxel_monitor = MultiStateMonitor(new_voxel, vars=['G_total','s','f_in','v','f_out','q','y','g','cmr_o','o_e','cb'],
        record=True)

    @network_operation(when='start')
    def get_new_input():
        if 5*second < defaultclock.t < 5.05*second:
            new_voxel.G_total=1*nS
        else:
            new_voxel.G_total=new_voxel.G_base

    @network_operation()
    def compute_cmro():
        #print('phi=%.3f, f_in=%.3f, o_e=%.3f, o_elog=%.3f, c_ab=%.3f, cb=%.3f, cmr_o=%.3f, g=%.3f' %
        #      (new_voxel.phi, new_voxel.f_in, new_voxel.o_e, new_voxel.oe_log, new_voxel.c_ab, new_voxel.cb, new_voxel.cmr_o, new_voxel.g))
        #new_voxel.cmr_o=(new_voxel.cb-new_voxel.g*new_voxel.params.c_ab)/(new_voxel.params.cb_0-new_voxel.params.g_0*new_voxel.params.c_ab)
        new_voxel.oe_log=np.log(1.0-new_voxel.o_e/(1.0-new_voxel.g))

    new_net=Network(new_voxel, get_new_input, compute_cmro, new_voxel_monitor)
    reinit_default_clock()
    new_net.run(15*second)

    plot_results(voxel_monitor, new_voxel_monitor)
示例#4
0
def test_max_delay():
    '''Test that changing delays after compression works. '''
    
    reinit_default_clock()
    inp = SpikeGeneratorGroup(1, [(0, 1*ms)])
    G = NeuronGroup(1, model='v:1')
    mon = StateMonitor(G, 'v', record=True)
    
    # one synapse
    syn = Synapses(inp, G, model='w:1', pre='v+=w', max_delay=5*ms)
    
    syn[:, :] = 1
    syn.w[:, :] = 1
    syn.delay[:, :] = 0 * ms
    
    net = Network(inp, G, syn, mon)    
    net.run(defaultclock.dt)
    syn.delay[:, :] = 5 * ms    
    net.run(6.5*ms)
    
    # spike should arrive at 5 + 1 ms    
    assert (mon[0][mon.times >= 6 * ms] == 1).all() 
    assert (mon[0][mon.times < 6 * ms] == 0).all()
    
    # same as above but with two synapses
    reinit_default_clock()
    mon.reinit()
    G.reinit()
    
    syn = Synapses(inp, G, model='w:1', pre='v+=w', max_delay=5*ms)
    
    syn[:, :] = 2
    syn.w[:, :] = 1
    syn.delay[:, :] = [0 * ms, 0 * ms]
    
    net = Network(inp, G, syn, mon)    
    net.run(defaultclock.dt)
    syn.delay[:, :] = [5 * ms, 5 * ms]
    net.run(6.5*ms)
    
    # spike should arrive at 5 + 1 ms
    assert (mon[0][mon.times >= 6 * ms] == 2).all()
    assert (mon[0][mon.times < 6 * ms] == 0).all()    
示例#5
0
def test_max_delay():
    '''Test that changing delays after compression works. '''

    reinit_default_clock()
    inp = SpikeGeneratorGroup(1, [(0, 1 * ms)])
    G = NeuronGroup(1, model='v:1')
    mon = StateMonitor(G, 'v', record=True)

    # one synapse
    syn = Synapses(inp, G, model='w:1', pre='v+=w', max_delay=5 * ms)

    syn[:, :] = 1
    syn.w[:, :] = 1
    syn.delay[:, :] = 0 * ms

    net = Network(inp, G, syn, mon)
    net.run(defaultclock.dt)
    syn.delay[:, :] = 5 * ms
    net.run(6.5 * ms)

    # spike should arrive at 5 + 1 ms
    assert (mon[0][mon.times >= 6 * ms] == 1).all()
    assert (mon[0][mon.times < 6 * ms] == 0).all()

    # same as above but with two synapses
    reinit_default_clock()
    mon.reinit()
    G.reinit()

    syn = Synapses(inp, G, model='w:1', pre='v+=w', max_delay=5 * ms)

    syn[:, :] = 2
    syn.w[:, :] = 1
    syn.delay[:, :] = [0 * ms, 0 * ms]

    net = Network(inp, G, syn, mon)
    net.run(defaultclock.dt)
    syn.delay[:, :] = [5 * ms, 5 * ms]
    net.run(6.5 * ms)

    # spike should arrive at 5 + 1 ms
    assert (mon[0][mon.times >= 6 * ms] == 2).all()
    assert (mon[0][mon.times < 6 * ms] == 0).all()
def lifsim(mu_amp, mu_offs, simga_amp, sigma_offs, freq, V_th):
    lifnet = Network()
    clock.reinit_default_clock()
    eqs = Equations('dV/dt = (-V+V0)/tau : volt')
    eqs.prepare()
    lifnrn = NeuronGroup(1, eqs, threshold=V_th, refractory=t_refr,
                         reset=V_reset)
    lifnet.add(lifnrn)
    pulse_times = (np.arange(1, duration*freq, 1)+0.25)/freq
    pulse_spikes = []
    Npoiss = 5000
    Npulse = 5000
    wpoiss = (mu_offs-mu_amp)/(Npoiss*freq)
    wpulse = mu_amp/(Npulse*freq)
    sigma = 1/(freq*5)
    if (wpulse != 0):
        for pt in pulse_times:
            pp = PulsePacket(t=pt*second, n=Npulse, sigma=sigma)
            pulse_spikes.extend(pp.spiketimes)
        pulse_input = SpikeGeneratorGroup(Npulse, pulse_spikes)
        pulse_conn = Connection(pulse_input, lifnrn, 'V', weight=wpulse)
        lifnet.add(pulse_input, pulse_conn)
    if (wpoiss != 0):
        poiss_input = PoissonGroup(Npoiss, freq)
        poiss_conn = Connection(poiss_input, lifnrn, 'V', weight=wpoiss)
        lifnet.add(poiss_input, poiss_conn)

    V_mon = StateMonitor(lifnrn, 'V', record=True)
    st_mon = SpikeMonitor(lifnrn)
    lifnet.add(V_mon, st_mon)

    lifnet.run(duration)

    V_mon.insert_spikes(st_mon, value=V_th*2)
    times = V_mon.times
    membrane = V_mon[0]
    return times, st_mon.spiketimes[0], membrane
示例#7
0
        plt.title('Click responses')

    plt.figure(2)
    plt.subplot(len(levels), 1, idx + 1)
    plt.plot(R_mon.times / ms, R_mon[idx])
    plt.xlabel('Time (msec)')
    plt.xlabel('Time (msec)')
    plt.text(15, np.nanmax(s_mon[idx])/2., 'Peak SPL=%s SPL' % str(level*dB));
    plt.ylim(ymin, ymax)
    if idx == 0:
        plt.title('Click responses (with spikes and refractoriness)')
    plt.plot(spike_mon.spiketimes[idx] / ms,
         np.ones(len(spike_mon.spiketimes[idx])) * np.nanmax(R_mon[idx]), 'rx')

print 'Testing tone response'
reinit_default_clock()
duration = 60*ms    
levels = [0, 20, 40, 60, 80]
tones = Sound([Sound.sequence([tone(cf, duration).atlevel(level*dB).ramp(when='both',
                                                                         duration=10*ms,
                                                                         inplace=False),
                               silence(duration=duration/2)])
               for level in levels])
ihc = TanCarney(MiddleEar(tones), [cf] * len(levels), update_interval=1)
syn = ZhangSynapse(ihc, cf)
s_mon = StateMonitor(syn, 's', record=True, clock=syn.clock)
R_mon = StateMonitor(syn, 'R', record=True, clock=syn.clock)
spike_mon = SpikeMonitor(syn)
net = Network(syn, s_mon, R_mon, spike_mon)
net.run(duration * 1.5)
for idx, level in enumerate(levels):