Changeset 84

Show
Ignore:
Timestamp:
01/12/08 21:42:26 (1 year ago)
Author:
LaurentPerrinet
Message:

Modification of the SpikeTrain and SpikeList classes from the CodeSprint? (TM). Getting the rest to work with the new methods...

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/analysis.py

    r78 r84  
    1414    output. 
    1515 
     16    >>> record(my_spike_train) 
     17 
    1618    """ 
    1719 
    1820 
    1921    # from the spike list 
    20     simtime_seconds = output.t_stop - output.t_start 
     22    simtime_seconds = (output.t_stop - output.t_start)/1000. 
    2123    #time = numpy.linspace(0, simtime_seconds , fs*simtime_seconds) 
    22     (trace,time) = numpy.histogram(output.spike_times, fs*simtime_seconds) 
     24    (trace,time) = numpy.histogram(output.spike_times*1000., fs*simtime_seconds) 
    2325 
    2426 
    …… 
    3941 
    4042    see playing_with_simple_single_neuron.py for a sample use 
     43 
     44    >>> play(my_spike_train) 
     45 
     46    TODO: make it possible to play multiple spike trains in stereo 
    4147    """ 
    4248 

  • trunk/benchmark.py

    r78 r84  
    110110 
    111111        This will generate one file per experiment and a default 
     112 
     113        TODO : use a more sexy filename with: 
     114        name='' 
     115        for key in data_root['run'][experiment].keys(): 
     116            name = name+'_'+key+'_'+str(data_root['run'][experiment][key]) 
    112117        """ 
    113118        if experiment == '': 
    …… 
    144149    # HIGHER-LEVEL FUNCTIONS 
    145150    def list_param(self,param): 
    146         """ Lists values for param in experiments, a bit the reverse of get_experiment_dict 
     151        """ Lists values for param in experiments = the reverse of get_experiment_dict 
    147152 
    148153        """ 
    …… 
    208213        Execute all experiments from experiment_list. 
    209214 
    210         This should be a batch osf experiments to launch on one core. 
     215        This should be a batch of experiments to launch on one core. 
    211216 
    212217        """ 

  • trunk/examples/retina/benchmark_noise.py

    r77 r84  
    5050    pylab.xlabel('Noise amplitude') 
    5151    pylab.axis('tight') 
    52     pylab.savefig(benchmark.filename + '/benchmark_noise.png')#, dpi=300) # 
     52    pylab.savefig(benchmark.name + '/benchmark_noise.png')#, dpi=300) # 
    5353    #command = 'epstopdf  "%s" "%s"'% (pdffile, psfile) 
    5454    #os.system(command) 
    …… 
    7171    tag = 'test' # going OO 
    7272 
    73     filename = 'results/' + tag + '_benchmark_noise' 
     73    name = 'results/' + tag + '_benchmark_noise' 
    7474 
    7575    # create the list of experiments as all possibilities accross parameter vectors 
    …… 
    7777 
    7878    # create benchmark (or open it if it exists) 
    79     B = benchmark.Benchmark(filename,ret,run) 
     79    B = benchmark.Benchmark(name,ret,run) 
    8080    # there are many ways to get data from the benchmark. see benchmark.py 
    8181    B.run_simulations() 

  • trunk/examples/retina/benchmark_retina.py

    r78 r84  
    193193 
    194194    figure_format , dpi = '.png' , 150 
    195     figure1(benchmark.filename + '/benchmark_retina' + figure_format,dpi) 
    196     figure2(benchmark.filename + '/benchmark_retina_CRF' + figure_format,dpi) 
    197     figure3(benchmark.filename + '/benchmark_retina_input' + figure_format,dpi) 
     195    figure1(benchmark.name + '/benchmark_retina' + figure_format,dpi) 
     196    figure2(benchmark.name + '/benchmark_retina_CRF' + figure_format,dpi) 
     197    figure3(benchmark.name + '/benchmark_retina_input' + figure_format,dpi) 
    198198 
    199199if __name__ == '__main__': 

  • trunk/examples/retina/make_all.py

    r78 r84  
    3333### testing the noise response 
    3434import benchmark_noise 
    35 filename =  'results/' + tag + '_benchmark_noise' 
     35name =  'results/' + tag + '_benchmark_noise' 
    3636ret = Retina(N) 
    3737# create the list of experiments as all possibilities accross parameter vectors 
    3838run = get_experiment_dict({'noise_std':linspace(.10,4.0,N_exp), 'snr' : [ 0.0 ]}) 
    3939# create benchmark (or open it if it exists) 
    40 B = Benchmark(filename,ret,run) 
     40B = Benchmark(name,ret,run) 
    4141# there are many ways to get data from the benchmark. see benchmark.py 
    4242B.run_simulations() 
    …… 
    4545### testing the linear response 
    4646import benchmark_linear 
    47 filename =  'results/' + tag + '_benchmark_linear' 
     47name =  'results/' + tag + '_benchmark_linear' 
    4848 
    4949ret = Retina(N) 
    …… 
    5151 
    5252run = get_experiment_dict({'snr' : 10.**(linspace(-.50,.75,N_exp))}) 
    53 B = Benchmark(filename,ret,run) 
     53B = Benchmark(name,ret,run) 
    5454B.run_simulations() 
    5555benchmark_linear.show(B) 
    …… 
    5858import benchmark_retina 
    5959 
    60 filename =  'results/' + tag + '_benchmark_retina' 
     60name =  'results/' + tag + '_benchmark_retina' 
    6161ret = Retina(N) 
    6262snr  = ret.params['snr'] * 10.**(linspace(-.50,.75,N_exp)) 
    …… 
    6464run = get_experiment_dict({'snr':snr,'kernelseed':seeds}) 
    6565 
    66 B = Benchmark(filename,ret,run) 
     66B = Benchmark(name,ret,run) 
    6767B.run_simulations() 
    6868benchmark_retina.show(B) 

  • trunk/examples/retina/retina.py

    r78 r84  
    7272import datetime 
    7373 
    74 from NeuroTools.spikes import tmpfile2spikelist 
     74from NeuroTools.spikes import loadSpikeList 
    7575from NeuroTools.benchmark import Model 
    7676import pyNN.nest1 as sim 
    …… 
    219219 
    220220        # TODO LUP use something like "for pop in [phr, out]" ? 
    221         out_ON.printSpikes(out_ON_filename)#,compatible_output=False) 
    222         out_OFF.printSpikes(out_OFF_filename)#,compatible_output=False) 
    223  
    224         # TODO LUP  get out_ON_DATA on a 2D grid independantly of out_ON.cell.astype(int) 
    225221        out_ON_filename=os.path.join(tmpdir,'out_on.gdf') 
    226222        out_OFF_filename=os.path.join(tmpdir,'out_off.gdf') 
    227         out_ON_DATA = tmpfile2spikelist(out_ON_filename,N, 
    228                                         t_start=0.0, t_stop=params['simtime']/1000.) 
    229         out_OFF_DATA = tmpfile2spikelist(out_OFF_filename,N, 
    230                                         t_start=0.0, t_stop=params['simtime']/1000.) 
     223        out_ON.printSpikes(out_ON_filename)# 
     224        out_OFF.printSpikes(out_OFF_filename)# 
     225 
     226        # TODO LUP  get out_ON_DATA on a 2D grid independantly of out_ON.cell.astype(int) 
     227        out_ON_DATA = loadSpikeList(out_ON_filename,range(N), 
     228                                        t_start=0.0, t_stop=params['simtime']) 
     229        out_OFF_DATA = loadSpikeList(out_OFF_filename,range(N), 
     230                                        t_start=0.0, t_stop=params['simtime']) 
    231231 
    232232        out = {'out_ON_DATA':out_ON_DATA, 
    …… 
    285285        ax.set_ylabel('X') 
    286286        ax.set_zlabel('Y') 
    287         ax.set_xlim([0,self.params['simtime']/1000.]) 
     287        ax.set_xlim([0,self.params['simtime']]) 
    288288        pylab.show() 
    289289        ####    spike_time=numpy.cumsum(out_ON_DATA[:,0]) * ret.params['dt'] 
    …… 
    311311    #ret.params['noise_std'] = 4.0 
    312312    #ret.params['snr'] = 5.0 
    313     out = ret.run() 
     313    out = ret.run(ret.params) 
    314314    ret.show(out) #(ret.params) 
    315315 

  • trunk/examples/retina/retina_nest2.py

    r77 r84  
    1010( https://facets.kip.uni-heidelberg.de/private/wiki/index.php/V1_hypercolumn#Benchmark_one ) 
    1111 
    12 : This version uses specifically nest2 calls  
     12: This version uses specifically nest2 calls 
    1313 
    1414 
    …… 
    1818import datetime 
    1919 
    20 from NeuroTools.sandbox import tmpfile2spikelist 
     20from NeuroTools.spikes import loadSpikeList 
    2121from NeuroTools.benchmark import Model 
    2222import pyNN.nest2 as sim 
    …… 
    6767##        'TauSyn_I': 10.0, 'V_reversal_sfa': -70.0, 'q_sfa': 0., #14.48, 
    6868##        'Tau_sfa':110.0, 'V_reversal_relref': -70.0, 'q_relref': 3214.0, 
    69 ##        'Tau_relref': 1.97}#,'python':True}         
     69##        'Tau_relref': 1.97}#,'python':True} 
    7070        self.params['parameters_gc'] = {'v_thresh':-57.0, 'v_reset': -70.0, 
    71         'v_init': -63.0, 'tau_m': 0.5, 'cm':289.5,  
     71        'v_init': -63.0, 'tau_m': 0.5, 'cm':289.5, 
    7272        'e_rev_E': 0.0, 'e_rev_I': -75.0, 'tau_syn_E':1.5, 'tau_syn_I': 10.0} 
    73          
     73 
    7474        # default input image # TODO add start and stop time 
    7575 
    …… 
    101101        N = params['N'] 
    102102        #dc_generator 
    103         phr_ON = sim.Population((N,N),'dc_generator') 
    104         phr_OFF  = sim.Population((N,N),'dc_generator') 
     103        phr_ON = sim.Population(N,'dc_generator') 
     104        phr_OFF  = sim.Population(N,'dc_generator') 
    105105        for phr in [phr_ON, phr_OFF]: 
    106106                        phr.set({ 'start' : params['simtime']/4, 'stop' : params['simtime']/4*3}) 
    107107 
    108108        # TODO LUP : justify this noise model 
    109         noise_ON = sim.Population((N,N),'noise_generator',{'mean':0.,'std':params['noise_std']}) 
    110         noise_OFF = sim.Population((N,N),'noise_generator',{'mean':0.,'std':params['noise_std']}) 
     109        noise_ON = sim.Population(N,'noise_generator',{'mean':0.,'std':params['noise_std']}) 
     110        noise_OFF = sim.Population(N,'noise_generator',{'mean':0.,'std':params['noise_std']}) 
    111111 
    112112        phr_ON.tset('amplitude', params['amplitude'] *  params['snr']) 
    …… 
    114114 
    115115        # target ON and OFF populations (what about a tridimensional Population?) 
    116         out_ON = sim.Population((N,N) , sim.IF_cond_alpha,params['parameters_gc'])#'iaf_sfa_neuron')#)#sim.IF_curr_alpha)# sim.IF_cond_alpha)#,params['parameters_gc'])#'iaf_cond_neuron')# IF_cond_alpha) # 
    117         out_OFF = sim.Population((N,N) ,sim.IF_cond_alpha,params['parameters_gc'])# 'iaf_sfa_neuron',params['parameters_gc'])#sim.IF_curr_alpha)#'iaf_sfa_neuron') 
     116        out_ON = sim.Population(N , sim.IF_cond_alpha)#,params['parameters_gc'])#'iaf_sfa_neuron')#)#sim.IF_curr_alpha)# sim.IF_cond_alpha)#,params['parameters_gc'])#'iaf_cond_neuron')# IF_cond_alpha) # 
     117        out_OFF = sim.Population(N ,sim.IF_cond_alpha)#,params['parameters_gc'])# 'iaf_sfa_neuron',params['parameters_gc'])#sim.IF_curr_alpha)#'iaf_sfa_neuron') 
    118118        # initialize membrane potential TODO: and conductances? 
    119119        # TODO just store the seed 
    120120        numpy.random.seed(params['kernelseed']) 
    121121 
    122         for out_ in [out_ON, out_OFF]: 
    123             V_init = params['parameters_gc']['v_init'] + numpy.random.rand(N,N)*(params['parameters_gc']['v_thresh'] - params['parameters_gc']['v_reset']) 
    124             out_.tset('v_init',V_init) 
     122##        for out_ in [out_ON, out_OFF]: 
     123##            V_init = params['parameters_gc']['v_init'] + numpy.random.rand(N,N)*(params['parameters_gc']['v_thresh'] - params['parameters_gc']['v_reset']) 
     124##            out_.tset('v_init',V_init) 
    125125##  alternatively 
    126126##    >>> from pyNN.random import RandomDistribution 
    …… 
    133133        for (pre, post) in [(phr_ON,out_ON), (noise_ON,out_ON),(phr_OFF,out_OFF), (noise_OFF,out_OFF)]: 
    134134            sim.nest.ConnectWD(pre.cell.flatten().tolist(),post.cell.flatten().tolist(),[params['weight']],[10.0]) 
    135   
     135 
    136136##        retina_proj_ON = sim.Projection(phr_ON, out_ON, 'oneToOne') 
    137137##        #print type(params['weight']) # TODO: fix numpy.float64 problem 
    …… 
    146146##        noise_proj_OFF.setWeights(params['weight'])#* numpy.ones((N,N)) 
    147147 
    148         out_ON_filename=os.path.join(tmpdir,'out_on.gdf') 
    149         out_OFF_filename=os.path.join(tmpdir,'out_off.gdf') 
     148        out_ON_filename=tmpdir+'out_on.gdf'#os.path.join(tmpdir,'out_on.gdf') 
     149        out_OFF_filename=tmpdir+'out_on.gdf'#os.path.join(tmpdir,'out_off.gdf') 
    150150 
    151151        out_ON.record() 
    …… 
    167167 
    168168        # TODO LUP  get out_ON_DATA on a 2D grid independantly of out_ON.cell.astype(int) 
    169         out_ON_DATA = tmpfile2spikelist(out_ON_filename + '-0',params['dt'])#,compatible_output=False) 
    170         out_OFF_DATA = tmpfile2spikelist(out_OFF_filename + '-0',params['dt'])#,compatible_output=False) 
     169        out_ON_DATA = loadSpikeList(out_ON_filename,range(N), 
     170                                        t_start=0.0, t_stop=params['simtime']/1000.) 
     171        out_OFF_DATA = loadSpikeList(out_OFF_filename,range(N), 
     172                                        t_start=0.0, t_stop=params['simtime']/1000.) 
    171173        out = {'out_ON_DATA':out_ON_DATA,'out_OFF_DATA':out_OFF_DATA} 
    172174        # cleans up 
    173         os.remove(out_ON_filename + '-0') 
    174         os.remove(out_OFF_filename + '-0') 
     175        os.remove(out_ON_filename) 
     176        os.remove(out_OFF_filename) 
    175177        os.rmdir(tmpdir) 
    176178 

  • trunk/examples/single_neuron/benchmark_neuron_vs_noise.py

    r78 r84  
    4343if __name__ == '__main__': 
    4444 
    45     filename =  'results/benchmark_neuron_vs_noise' 
     45    name =  'results/benchmark_neuron_vs_noise' 
    4646 
    4747    myFibers = model.FiberChannel() 
    …… 
    4949    run = benchmark.get_experiment_dict({'snr' :[0], 'noise_std' : 10.**(numpy.linspace(-.50,2.,25))}) 
    5050 
    51     B = benchmark.Benchmark(filename,myFibers,run) 
     51    B = benchmark.Benchmark(name,myFibers,run) 
    5252    B.run_simulations() 
    5353    show(B) 

  • trunk/examples/single_neuron/benchmark_neuron_vs_signal.py

    r78 r84  
    2323 
    2424    """ 
    25     from numpy import sin, cos, pi, zeros 
     25    from numpy import sin, cos, pi, zeros, where 
    2626    params = benchmark.get('params') 
    2727    N, simtime = params['N'], params['simtime'] 
    2828    experiments = benchmark.list_experiments() 
    29     noise_list = benchmark.list_param('noise_std') 
    30     n_noise = len(noise_list) 
    31     n_snr = len(experiments) / len(noise_list) 
    32     noise, snr, CRF = zeros(n_noise),zeros((n_noise,n_snr)), zeros((n_noise,n_snr)) 
    33     for i_noise, noise in enumerate(noise_list): 
    34         snr_list = benchmark.list_where('noise_std',noise) 
    35         noise[i_noise] = benchmark.get('experiments')[experiment]['noise_std'] 
    36  
    37         for i_snr, experiment in enumerate(snr_list): 
    38             out_ON_DATA = benchmark.get('out',experiment).as_list_id_list_time() 
    39             snr[i_noise,i_snr] = benchmark.get('experiments')[experiment]['snr'] 
    40             spikes_during_signal = where((out_ON_DATA[1]/simtime-1/2)<1/4) 
    41             CRF[i_noise,i_snr] = len(spikes_during_signal) / N / simtime 
     29    #noise_list = benchmark.list_param('noise_std') 
     30    #n_noise = len(noise_list) 
     31    n_snr = len(experiments) #/ len(noise_list) 
     32    noise, snr, CRF = zeros(n_snr),zeros(n_snr), zeros(n_snr) 
     33##    for i_noise in noise_list: 
     34##        snr_list = benchmark.list_where('noise_std',noise) 
     35## 
     36##        for i_snr, experiment in enumerate(snr_list): 
     37##            out_ON_DATA = benchmark.get('out',experiment).as_list_id_list_time() 
     38##            #print noise#out_ON_DATA 
     39##            snr[i_noise,i_snr] = benchmark.get('experiments')[experiment]['snr'] 
     40##            #spikes_during_signal = where((out_ON_DATA[1]/simtime-1/2)<1/4) 
     41##            spikes_during_signal = where((out_ON_DATA[1]>simtime/4)&(out_ON_DATA[1]<3*simtime/4)) # more elegant 
     42##            CRF[i_noise,i_snr] = len(spikes_during_signal) / N / simtime 
     43    for i_exp,experiment in enumerate(experiments): 
     44        out_SL = benchmark.get('out',experiment)#.as_list_id_list_time() 
     45        snr[i_exp] = benchmark.get('experiments')[experiment]['snr'] 
     46        noise[i_exp] = benchmark.get('experiments')[experiment]['noise_std'] 
     47        #TODO use subSpikeList 
     48        #spikes_during_signal = where((out_ON_DATA[1]>simtime/4)&(out_ON_DATA[1]<3*simtime/4)) # more elegant 
     49        CRF[i_exp] = out_SL.mean_rate()# len(spikes_during_signal) / N / simtime 
    4250 
    4351 
    4452    #pylab.subplot(111) 
    45     pylab.plot(snr,CRF,'o', color = (sin(2*pi*noise)**2,cos(2*pi*noise)**2,1)) 
     53    pylab.scatter(snr,CRF, c = noise) #color = (sin(2*pi*noise_list)**2,cos(2*pi*noise_list)**2,1)) 
    4654    pylab.ylabel('Firing Frequency (Hz)') 
    4755    pylab.xlabel('Signal (nA?)') 
     56    pylab.colorbar() 
    4857    pylab.axis('tight') 
    4958    pylab.savefig('results/benchmark_neuron_vs_signal.png') # 
    …… 
    5160if __name__ == '__main__': 
    5261 
    53     filename =  'results/benchmark_neuron_vs_signal_and_noise' 
     62    name =  'results/benchmark_neuron_vs_signal_and_noise' 
    5463 
    5564    myFibers = model.FiberChannel() 
    …… 
    5968                                        'snr' : numpy.linspace(-4.,4.,N_exp)}) 
    6069 
    61     B = benchmark.Benchmark(filename,myFibers,run) 
     70    B = benchmark.Benchmark(name,myFibers,run) 
    6271    B.run_simulations() 
    6372    show(B) 

  • trunk/examples/single_neuron/benchmark_synaptic_strength.py

    r78 r84  
    4242if __name__ == '__main__': 
    4343 
    44     filename =  'results/benchmark_synaptic_strength' 
     44    name =  'results/benchmark_synaptic_strength' 
    4545 
    4646    myFibers = model.FiberChannel() 
    …… 
    4949    run = benchmark.get_experiment_dict({'weight' : 10.**(numpy.linspace(-.50,.75,N_exp))}) 
    5050 
    51     B = benchmark.Benchmark(filename,myFibers,run) 
     51    B = benchmark.Benchmark(name,myFibers,run) 
    5252    B.run_simulations() 
    5353    show(B) 

  • trunk/examples/single_neuron/playing_with_simple_single_neuron.py

    r78 r84  
    1313 
    1414myFibers = model.FiberChannel() 
    15 myFibers.params['simtime'] = 4.*10**3 # 4 seconds 
    1615myFibers.params['N'] = 1 # 
    1716 

  • trunk/examples/single_neuron/simple_single_neuron.py

    r79 r84  
    1919import sys, os, tempfile 
    2020import pyNN.nest1 as sim 
    21 from NeuroTools.spikes import tmpfile2spikelist 
     21from NeuroTools.spikes import loadSpikeList 
    2222from NeuroTools.benchmark import Model 
    2323 
    …… 
    5858 
    5959        # internal noise model 
    60         print params['noise_std'] 
    6160        noise = sim.Population(N,'noise_generator',{'mean':0.,'std':params['noise_std']}) 
    6261 
    …… 
    9089        output_filename=os.path.join(tmpdir,'output.gdf') 
    9190        output.printSpikes(output_filename)# 
    92         output_DATA = tmpfile2spikelist(output_filename,N, 
    93                                         t_start=0.0, t_stop=params['simtime']/1000.) 
     91        output_DATA = loadSpikeList(output_filename,N, 
     92                                        t_start=0.0, t_stop=params['simtime']) 
    9493 
    9594 
    …… 
    10099        print "Number of Neurons  : ", N 
    101100        #print "Input rate   : ", input.meanSpikeCount(), "spikes/neuron in ", params['simtime'], "ms" 
    102         print "Output rate    : ", output.meanSpikeCount(), "spikes/neuron in ",params['simtime'], "ms" 
     101        print "Mean Output rate    : ", output_DATA.mean_rate(), " during ",params['simtime'], "ms" 
    103102        print "Build time         : ", buildCPUTime, "s" 
    104103        print "Simulation time    : ", simCPUTime, "s" 

  • trunk/spikes.py

    r83 r84  
    1414    This class defines a spike train as a list of the events times. 
    1515 
    16     Event times are given in a list (sparse representation) in ISO units (seconds). 
     16    Event times are given in a list (sparse representation) in milliseconds. 
    1717 
    1818    >>> s1 = SpikeTrain([0.0, 0.1, 0.2, 0.5]) 
    …… 
    3434    def __init__(self, spike_times, dt=None, t_start=None, t_stop=None): 
    3535        """ 
    36         `spike_times` is a list/numpy array of spike times (in seconds) 
     36        `spike_times` is a list/numpy array of spike times (in milliseconds) 
    3737 
    3838        TODO: We proposed innitially that : 
    3939        If `dt`is specified, the time values should be ints, 
    4040        and will be multiplied by `dt`, otherwise time values should be floats. 
    41  
    42         this is confusing. All times should be in seconds. period. 
     41        Markus suggested that the internal representation should be integer and that analysis methods also. 
    4342 
    4443        If `t_start` and `t_stop` are not specified, they are inferred from the data. 
    …… 
    128127    def time_axis(self, binwidth): 
    129128        return numpy.arange(self.t_start, self.t_stop, binwidth) 
    130      
    131      
     129 
     130 
    132131    def subSpikeTrain(self, t_start, t_stop): 
    133132        idx = numpy.where((self.spike_times >= t_start) & (self.spike_times <= t_stop))[0] 
    …… 
    147146 
    148147        if normalized: 
    149             hist *= 1000.0/binwidth # TODO why 1000.0 ?? we are using seconds everywhere 
     148            hist *= 1000.0/binwidth 
    150149        return hist 
    151150 
    …… 
    300299 
    301300 
     301    def concatenate(SpikeList_list): 
     302        # We check that Spike Lists have similar time_axis 
     303        sl_=SpikeList_list[0] 
     304        for sl in SpikeList_list: 
     305            if not((sl.t_start==sl_.t_start)&(sl.t_stop==sl_.t_stop)&(sl.dt==sl_.dt)): 
     306                raise Exception("Spike Lists should have similar time_axis") 
     307 
     308        new_SpkList = SpikeList([], [], self.dt, self.t_start, self.t_stop) 
     309        for sl in SpikeList_list: 
     310            for id in sl.id_list: 
     311                new_SpkList.append(id, sl.spiketrains[id]) 
     312        return new_SpkList 
     313 
     314 
    302315    def idsubSpikeList(self, id_list): 
    303316        # We check what are the elements that are in self.id_list and not in 
    …… 
    315328        """ 
    316329        returns a new SpikeList 
    317          
     330 
    318331        """ 
    319332        new_SpkList = SpikeList([], [], self.dt, t_start, t_stop) 
    …… 
    405418    def cv_isi(self, nbins=100, display=False): 
    406419        cvs_isi = [] 
    407         for idx,id in enumerate(self.id_list):  
     420        for idx,id in enumerate(self.id_list): 
    408421            isi = self.spiketrains[id].isi() 
    409422            if len(isi) > 1: 
    …… 
    462475        Calculate firing rate traces (in Hz) from arrays of spike times. 
    463476 
    464         Spike times and binwidth should are in seconds. 
     477        Spike times and binwidth should are in milliseconds. 
    465478        Returns a tuple (list_of_firing_rate_traces,bins) 
    466479 
    467         >>> pylab.plot(output[0].time_axis(0.02),sum(output.firing_rate(0.02))) 
     480        >>> pylab.plot(output[0].time_axis(dt),sum(output.firing_rate(dt))) 
    468481        """ 
    469482        return self.spike_histogram(binwidth, normalized=True, display=display) 
    …… 
    475488        fano = numpy.var(firing_rate)/numpy.mean(firing_rate) 
    476489        return fano 
    477      
    478      
     490 
     491 
    479492    def pairwise_correlation(self): 
    480493        pass 
    …… 
    521534def population2spikelist(output, N, dt , t_start, t_stop): 
    522535    """ 
    523     WARNING: all times in ms in PyNN, in seconds here. 
    524  
     536    TODO sl2pynn 
    525537    """ 
    526538    import os, tempfile 
    …… 
    529541    output_filename=os.path.join(tmpdir,'output.gdf') 
    530542    output.printSpikes(output_filename)# 
    531     output_DATA = tmpfile2spikelist(output_filename, N= N, dt = dt, t_start=t_start, t_stop=t_stop) 
     543    output_DATA = loadSpikeList(output_filename, N= N, dt = dt, t_start=t_start, t_stop=t_stop) 
    532544    os.remove(output_filename) 
    533545    os.rmdir(tmpdir) 
    …… 
    538550    myfile = open(filename, "r", 10000) 
    539551    contents = myfile.readlines() 
    540     myfile.close()  
     552    myfile.close() 
    541553    data = [] 
    542554    for line in contents: 
    …… 
    557569    since last event, neuron_id); neuron_id and time are integers 
    558570 
    559     All times in seconds. 
     571    All times in milliseconds. 
    560572 
    561573    The PyNN-NEST format (with compatible_output=True) is: 
    …… 
    565577 
    566578    """ 
     579    if isinstance(id_list,int): # allows to just specify the number of neurons 
     580        id_list = range(id_list) 
    567581    spikes = readSpikeFile(filename) 
    568582    return SpikeList(spikes, id_list, dt, t_start, t_stop)