Changeset 1006

Timestamp:

11/10/11 13:17:57 (6 months ago)

Author:

apdavison

Message:

New recording system based on Neo now integrated into pyNN.neuron for a single Segment (without reset() support)

Location:

branches/neo_output

Files:

• examples/VAbenchmarks.py (modified) (4 diffs)
• src/brian/recording.py (modified) (1 diff)
• src/common/populations.py (modified) (7 diffs)
• src/core.py (modified) (2 diffs)
• src/moose/recording.py (modified) (1 diff)
• src/nemo/recording.py (modified) (1 diff)
• src/nest/recording.py (modified) (1 diff)
• src/neuron/recording.py (modified) (5 diffs)
• src/neuron/simulator.py (modified) (4 diffs)
• src/pcsim/recording.py (modified) (1 diff)
• src/recording/__init__.py (modified) (5 diffs)

branches/neo_output/examples/VAbenchmarks.py

@@ -27 +27 @@
 exec("from pyNN.%s import *" % simulator_name)
 from pyNN.random import NumpyRNG, RandomDistribution
+from neo.io import PyNNTextIO
 
 timer = Timer()
@@ -43 +44 @@
 
 dt       = 0.1   # (ms) simulation timestep
-tstop    = 1000  # (ms) simulaton duration
+tstop    = 200 #1000  # (ms) simulaton duration
 delay    = 0.2
 
@@ -148 +149 @@
 # === Setup recording ==========================================================
 print "%s Setting up recording..." % node_id
-exc_cells.record()
-inh_cells.record()
-exc_cells[[0, 1]].record_v()
+exc_cells.record('spikes')
+inh_cells.record('spikes')
+exc_cells[[0, 1]].record('v')
 
 buildCPUTime = timer.diff()
@@ -177 +178 @@
     os.mkdir('Results')
 
-exc_cells.printSpikes("Results/VAbenchmark_%s_exc_%s_np%d.ras" % (benchmark, simulator_name, np))
-inh_cells.printSpikes("Results/VAbenchmark_%s_inh_%s_np%d.ras" % (benchmark, simulator_name, np))
-exc_cells[[0, 1]].print_v("Results/VAbenchmark_%s_exc_%s_np%d.v" % (benchmark, simulator_name, np))
+exc_cells.write_data(PyNNTextIO("Results/VAbenchmark_%s_exc_%s_np%d.ras" % (benchmark, simulator_name, np)), 'spikes')
+inh_cells.write_data(PyNNTextIO("Results/VAbenchmark_%s_inh_%s_np%d.ras" % (benchmark, simulator_name, np)), 'spikes')
+exc_cells[[0, 1]].write_data(PyNNTextIO("Results/VAbenchmark_%s_exc_%s_np%d.v" % (benchmark, simulator_name, np)), 'v')
 writeCPUTime = timer.diff()
 

branches/neo_output/src/brian/recording.py

@@ -120 +120 @@
             N[id + padding] = len(self._devices[0].spiketimes[id])
         return N
-        
-
-simulator.Recorder = Recorder

branches/neo_output/src/common/populations.py

@@ -386 +386 @@
         raise NotImplementedError()
 
-    #@deprecated("initialize('v', rand_distr)")
+    @deprecated("initialize('v', rand_distr)")
     def randomInit(self, rand_distr):
         """
@@ -392 +392 @@
         random values.
         """
-        warn("The randomInit() method is deprecated, and will be removed in a future release. Use initialize('v', rand_distr) instead.")
         self.initialize('v', rand_distr)
 
@@ -426 +425 @@
         return (variable in self.celltype.recordable)
 
-    def _add_recorder(self, variable, to_file):
-        """Create a new Recorder for the supplied variable."""
-        assert variable not in self.recorders
-        if hasattr(self, "parent"):
-            population = self.grandparent
-        else:
-            population = self
-        logger.debug("Adding recorder for %s to %s" % (variable, self.label))
-        population.recorders[variable] = population.recorder_class(variable,
-                                                                   population=population, file=to_file)
-
-    def _record(self, variable, to_file=True):
-        """
-        Private method called by record() and record_v().
-        """
-        if variable is None: # reset the list of things to record
-                             # note that if _record(None) is called on a view of a population
-                             # recording will be reset for the entire population, not just the view
-            for recorder in self.recorders.values():
-                recorder.reset()
-            self.recorders = {}    
-        else:
-            if not self.can_record(variable):
-                raise errors.RecordingError(variable, self.celltype)        
-            logger.debug("%s.record('%s')", self.label, variable)
-            if variable not in self.recorders:
-                self._add_recorder(variable, to_file)
-            if self.record_filter is not None:
-                self.recorders[variable].record(self.record_filter)
+    def record(self, variables=None, to_file=None):
+        """
+        Record the specified variable or variables for all cells in the
+        Population or view.
+        
+        `variables` may be either a single variable name or a list of variable
+        names. For a given celltype class, `celltype.recordable` contains a list of
+        variables that can be recorded for that celltype.
+        
+        If specified, `to_file` should be a Neo IO instance and `write_data()`
+        will be automatically called when `end()` is called.
+        """
+        if variables is None: # reset the list of things to record
+                              # note that if record(None) is called on a view of a population
+                              # recording will be reset for the entire population, not just the view
+            self.recorder.reset()
+        elif variables in (True, False, None): # catch use of previous API
+            msg = "Use of the record() method has changed. Use record('spikes') instead."
+            warnings.warn(msg, category=DeprecationWarning)
+            if variables is not None:
+                to_file = variables
+            self.record('spikes', to_file)
+        else:        
+            logger.debug("%s.record('%s')", self.label, variables)
+            if self.record_filter is None:
+                self.recorder.record(variables, self.all_cells)
             else:
-                self.recorders[variable].record(self.all_cells)
-            #if isinstance(to_file, basestring):
-            #    self.recorders[variable].file = to_file
-
-    def record(self, to_file=True):
-        """
-        Record spikes from all cells in the Population.
-        """
-        self._record('spikes', to_file)
-
+                self.recorder.record(variables, self.record_filter)  
+        if isinstance(to_file, basestring):
+            self.recorder.file = to_file
+
+    @deprecated("record('v')")
     def record_v(self, to_file=True):
         """
         Record the membrane potential for all cells in the Population.
         """
-        self._record('v', to_file)
-
+        self.record('v', to_file)
+
+    @deprecated("record(['gsyn_exc', 'gsyn_inh'])")
     def record_gsyn(self, to_file=True):
         """
         Record synaptic conductances for all cells in the Population.
         """
-        self._record('gsyn', to_file)
-
+        self.record(['gsyn_exc', 'gsyn_inh'], to_file)
+
+    def write_data(self, io, variables='all', gather=True):
+        """
+        Write recorded data to file, using one of the file formats supported by
+        Neo.
+        
+        `ìo` - a Neo IO instance
+        `variables` - either a single variable name or a list of variable names
+                      Variables must have been previously recorded, otherwise an
+                      Exception will be raised.
+                      
+        For parallel simulators, if `gather` is True, all data will be gathered
+        to the master node and a single output file created there. Otherwise, a
+        file will be written on each node, containing only data from the cells
+        simulated on that node.
+        """
+        self.recorder.write(variables, io, gather, self.record_filter)
+
+    def get_data(self, variables='all', gather=True):
+        """
+        Return a Neo `Block` containing the data (spikes, state variables)
+        recorded from the Population.
+        
+        `variables` - either a single variable name or a list of variable names
+                      Variables must have been previously recorded, otherwise an
+                      Exception will be raised.
+        
+        For parallel simulators, if `gather` is True, all data will be gathered
+        to all nodes and the Neo `Block` will contain data from all nodes.
+        Otherwise, the Neo `Block` will contain only data from the cells
+        simulated on the local node.
+        """
+        self.recorder.get(variables, gather, self.record_filter)
+
+    @deprecated("write_data(file, 'spikes')")
     def printSpikes(self, file, gather=True, compatible_output=True):
-        """
-        Write spike times to file.
-
-        file should be either a filename or a PyNN File object.
-
-        If compatible_output is True, the format is "spiketime cell_id",
-        where cell_id is the index of the cell counting along rows and down
-        columns (and the extension of that for 3-D).
-        This allows easy plotting of a `raster' plot of spiketimes, with one
-        line for each cell.
-        The timestep, first id, last id, and number of data points per cell are
-        written in a header, indicated by a '#' at the beginning of the line.
-
-        If compatible_output is False, the raw format produced by the simulator
-        is used. This may be faster, since it avoids any post-processing of the
-        spike files.
-
-        For parallel simulators, if gather is True, all data will be gathered
-        to the master node and a single output file created there. Otherwise, a
-        file will be written on each node, containing only the cells simulated
-        on that node.
-        """
-        self.recorders['spikes'].write(file, gather, compatible_output, self.record_filter)
-
+        self.write_data(file, 'spikes', gather)
+
+    @deprecated("get_data('spikes')")
     def getSpikes(self, gather=True, compatible_output=True):
-        """
-        Return a 2-column numpy array containing cell ids and spike times for
-        recorded cells.
-
-        Useful for small populations, for example for single neuron Monte-Carlo.
-        """
-        return self.recorders['spikes'].get(gather, compatible_output, self.record_filter)
-        # if we haven't called record(), this will give a KeyError. A more
-        # informative error message would be nice.
-
+        return self.get_data('spikes', gather)
+
+    @deprecated("write_data(file, 'v')")
     def print_v(self, file, gather=True, compatible_output=True):
-        """
-        Write membrane potential traces to file.
-
-        file should be either a filename or a PyNN File object.
-
-        If compatible_output is True, the format is "v cell_id",
-        where cell_id is the index of the cell counting along rows and down
-        columns (and the extension of that for 3-D).
-        The timestep, first id, last id, and number of data points per cell are
-        written in a header, indicated by a '#' at the beginning of the line.
-
-        If compatible_output is False, the raw format produced by the simulator
-        is used. This may be faster, since it avoids any post-processing of the
-        voltage files.
-
-        For parallel simulators, if gather is True, all data will be gathered
-        to the master node and a single output file created there. Otherwise, a
-        file will be written on each node, containing only the cells simulated
-        on that node.
-        """
-        self.recorders['v'].write(file, gather, compatible_output, self.record_filter)
-
+        self.write_data(file, 'v', gather)
+
+    @deprecated("get_data('v')")
     def get_v(self, gather=True, compatible_output=True):
-        """
-        Return a 2-column numpy array containing cell ids and Vm for
-        recorded cells.
-        """
         return self.recorders['v'].get(gather, compatible_output, self.record_filter)
 
+    @deprecated("write_data(file, ['gsyn_exc', 'gsyn_inh'])")
     def print_gsyn(self, file, gather=True, compatible_output=True):
-        """
-        Write synaptic conductance traces to file.
-
-        file should be either a filename or a PyNN File object.
-
-        If compatible_output is True, the format is "t g cell_id",
-        where cell_id is the index of the cell counting along rows and down
-        columns (and the extension of that for 3-D).
-        The timestep, first id, last id, and number of data points per cell are
-        written in a header, indicated by a '#' at the beginning of the line.
-
-        If compatible_output is False, the raw format produced by the simulator
-        is used. This may be faster, since it avoids any post-processing of the
-        voltage files.
-        """
-        self.recorders['gsyn'].write(file, gather, compatible_output, self.record_filter)
-
+        self.write_data(file, ['gsyn_exc', 'gsyn_inh'], gather)
+
+    @deprecated("get_data(['gsyn_exc', 'gsyn_inh'])")
     def get_gsyn(self, gather=True, compatible_output=True):
-        """
-        Return a 3-column numpy array containing cell ids and synaptic
-        conductances for recorded cells.
-        """
-        return self.recorders['gsyn'].get(gather, compatible_output, self.record_filter)
+        return self.get_data(['gsyn_exc', 'gsyn_inh']), gather
 
     def get_spike_counts(self, gather=True):
@@ -573 +531 @@
         Returns the number of spikes for each neuron.
         """
-        return self.recorders['spikes'].count(gather, self.record_filter)
-
+        return self.recorder.count('spikes', gather, self.record_filter)
+
+    @deprecated("mean_spike_count()")
     def meanSpikeCount(self, gather=True):
+        return self.mean_spike_count(gather)
+
+    def mean_spike_count(self, gather=True):
         """
         Returns the mean number of spikes per neuron.
         """
-        spike_counts = self.recorders['spikes'].count(gather, self.record_filter)
+        spike_counts = self.get_spike_counts(gather)
         total_spikes = sum(spike_counts.values())
         if self._simulator.state.mpi_rank == 0 or not gather:  # should maybe use allgather, and get the numbers on all nodes
@@ -597 +559 @@
         current_source.inject_into(self)
 
+    # name should be consistent with saving/writing data, i.e. save_data() and save_positions() or write_data() and write_positions()
     def save_positions(self, file):
         """
@@ -668 +631 @@
         for variable, value in self.celltype.default_initial_values.items():
             self.initialize(variable, value)
-        self.recorders = {}
+        self.recorder = self.recorder_class(self)
         Population.nPop += 1
 
@@ -831 +794 @@
         self.first_id     = numpy.min(self.all_cells) # only works if we assume all_cells is sorted, otherwise could use min()
         self.last_id      = numpy.max(self.all_cells)
-        self.recorders    = self.parent.recorders
+        self.recorder    = self.parent.recorder
         self.record_filter= self.all_cells
 

branches/neo_output/src/core.py

@@ -283 +283 @@
     function is called and suggests a replacement.
     """
+    # can we also control what is returned by dir(obj), so that deprecated methods do not appear?
     
     def __init__(self, replacement=''):
@@ -295 +296 @@
             return func(*args, **kwargs)
         new_func.__name__ = func.__name__
-        new_func.__doc__ = func.__doc__
+        new_func.__doc__ = func.__doc__ # should modify docstring to explain the deprecation
         new_func.__dict__.update(func.__dict__)
         return new_func

branches/neo_output/src/moose/recording.py

@@ -75 +75 @@
             N[int(id)] = len(id._cell.spike_table)
         return N
-
-simulator.Recorder = Recorder

branches/neo_output/src/nemo/recording.py

@@ -75 +75 @@
             N[id] = len(self.data[id])
         return N
-        
-
-simulator.Recorder = Recorder

branches/neo_output/src/nest/recording.py

@@ -318 +318 @@
                 N[id] = r-l
         return N
-    
-simulator.Recorder = Recorder # very inelegant. Need to rethink the module structure

branches/neo_output/src/neuron/recording.py

@@ -6 +6 @@
 
 import numpy
+from datetime import datetime
 from pyNN import recording
 from pyNN.neuron import simulator
 import re
 from neuron import h
+import neo
+import quantities as pq
+from copy import copy
 
 recordable_pattern = re.compile(r'((?P<section>\w+)(\((?P<location>[-+]?[0-9]*\.?[0-9]+)\))?\.)?(?P<var>\w+)')
@@ -15 +19 @@
 # --- For implementation of record_X()/get_X()/print_X() -----------------------
 
+def filter_variables(segment, variables):
+    """
+    Return a new `Segment` containing only recordings of the variables given in
+    the list `variables`
+    """
+    if variables == 'all':
+        return segment
+    else:
+        new_segment = copy(segment) # shallow copy
+        if 'spikes' not in variables:
+            new_segment.spiketrains = []
+        new_segment.analogsignals = [sig for sig in segment.analogsignals if sig.name in variables]
+        # also need to handle Units, RecordingChannels
+        return new_segment
+
+
+class DataCache(object):
+    # primitive implementation for now, storing in memory - later can consider caching to disk
+    def __init__(self):
+        self._data = []
+
+    def __iter__(self):
+        return iter(self._data)
+    
+    def store(self, obj):
+        self._data.append(obj)
+        
+
+
 class Recorder(recording.Recorder):
     """Encapsulates data and functions related to recording model variables."""
     _simulator = simulator
     
-    def _record(self, new_ids):
+    def __init__(self, population, file=None):
+        __doc__ = super(Recorder, self).__init__.__doc__
+        super(Recorder, self).__init__(population, file)
+        self.cache = DataCache()
+    
+    def _record(self, variable, new_ids):
         """Add the cells in `new_ids` to the set of recorded cells."""
-        if self.variable == 'spikes':
+        if variable == 'spikes':
             for id in new_ids:
                 id._cell.record(1)
-        elif self.variable == 'v':
+        elif variable == 'v':
             for id in new_ids:
                 id._cell.record_v(1)
-        elif self.variable == 'gsyn':
+        elif variable == 'gsyn_exc':
             for id in new_ids:
                 id._cell.record_gsyn("excitatory", 1)
-                id._cell.record_gsyn("inhibitory", 1)
                 if id._cell.excitatory_TM is not None:
                     id._cell.record_gsyn("excitatory_TM", 1)
+        elif variable == 'gsyn_inh':
+             for id in new_ids:
+                id._cell.record_gsyn("inhibitory", 1)
+                if id._cell.inhibitory_TM is not None:
                     id._cell.record_gsyn("inhibitory_TM", 1)
         else:
             for id in new_ids:
-               self._native_record(id)
+               self._native_record(variable, id)
     
     def _reset(self):
@@ -46 +87 @@
                 id._cell.record_gsyn(syn_name, active=False)
     
-    def _native_record(self, id):
+    def _native_record(self, variable, id):
         match = recordable_pattern.match(self.variable)
         if match:
@@ -58 +99 @@
             else:
                 segment = id._cell.source
-            id._cell.traces[self.variable] = vec = h.Vector()
+            id._cell.traces[variable] = vec = h.Vector()
             vec.record(getattr(segment, "_ref_%s" % parts['var']))
             if not id._cell.recording_time:
@@ -65 +106 @@
                 id._cell.recording_time += 1
         else:
-            raise Exception("Recording of %s not implemented." % self.variable)
+            raise Exception("Recording of %s not implemented." % variable)
     
-    def _get(self, gather=False, compatible_output=True, filter=None):
-        """Return the recorded data as a Numpy array."""
-        # compatible_output is not used, but is needed for compatibility with the nest module.
-        # Does nest really need it?
-        if self.variable == 'spikes':
-            data = numpy.empty((0,2))
-            for id in self.filter_recorded(filter):
-                spikes = numpy.array(id._cell.spike_times)
-                spikes = spikes[spikes<=simulator.state.t+1e-9]
-                if len(spikes) > 0:    
-                    new_data = numpy.array([numpy.ones(spikes.shape)*id, spikes]).T
-                    data = numpy.concatenate((data, new_data))
-        elif self.variable == 'v':
-            data = numpy.empty((0,3))
-            for id in self.filter_recorded(filter):
-                v = numpy.array(id._cell.vtrace)  
-                t = numpy.array(id._cell.record_times)               
-                new_data = numpy.array([numpy.ones(v.shape)*id, t, v]).T
-                data = numpy.concatenate((data, new_data))
-        elif self.variable == 'gsyn':
-            data = numpy.empty((0,4))
-            for id in self.filter_recorded(filter):
-                ge = numpy.array(id._cell.gsyn_trace['excitatory'])
-                gi = numpy.array(id._cell.gsyn_trace['inhibitory'])
-                if 'excitatory_TM' in id._cell.gsyn_trace:
-                    ge_TM = numpy.array(id._cell.gsyn_trace['excitatory_TM'])
-                    gi_TM = numpy.array(id._cell.gsyn_trace['inhibitory_TM'])
-                    if ge.size == 0:
-                        ge = ge_TM
-                    elif ge.size == ge_TM.size:
-                        ge = ge + ge_TM
-                    else:
-                        raise Exception("Inconsistent conductance array sizes: ge.size=%d, ge_TM.size=%d", (ge.size, ge_TM.size))
-                    if gi.size == 0:
-                        gi = gi_TM
-                    elif gi.size == gi_TM.size:
-                        gi = gi + gi_TM
-                    else:
-                        raise Exception()
-                t = numpy.array(id._cell.record_times)             
-                new_data = numpy.array([numpy.ones(ge.shape)*id, t, ge, gi]).T
-                data = numpy.concatenate((data, new_data))
-        else:
-            data = numpy.empty((0,3))
-            for id in self.filter_recorded(filter):
-                var = numpy.array(id._cell.traces[self.variable])  
-                t = numpy.array(id._cell.record_times)               
-                new_data = numpy.array([numpy.ones(var.shape)*id, t, var]).T
-                data = numpy.concatenate((data, new_data))    
-            #raise Exception("Recording of %s not implemented." % self.variable)
+    def _get(self, variables, gather=False, filter_ids=None):
+        """Return the recorded data as a Neo `Block`."""
+        data = neo.Block()
+        data.segments = [filter_variables(segment, variables) for segment in self.cache]
+        data.segments.append(self._get_current_segment(filter_ids=filter_ids, variables=variables))
         if gather and simulator.state.num_processes > 1:
             data = recording.gather(data)
         return data
+    
+    def _get_current_segment(self, filter_ids=None, variables='all'):
+        segment = neo.Segment(name=self.population.label,
+                              description=self.population.describe(),
+                              rec_datetime=datetime.now()) # would be nice to get the time at the start of the recording, not the end
+        variables_to_include = set(self.recorded.keys())
+        if variables is not 'all':
+            variables_to_include = variables_to_include.intersection(set(variables))
+        def trim_spikes(spikes):
+            return spikes[spikes<=simulator.state.t+1e-9]
+        for variable in variables_to_include:
+            if variable == 'spikes':
+                segment.spiketrains = [
+                    neo.SpikeTrain(trim_spikes(numpy.array(id._cell.spike_times)),
+                                   t_stop=simulator.state.t*pq.ms,
+                                   units='ms',
+                                   source_population=self.population.label,
+                                   source_id=int(id)) # index?
+                    for id in self.filter_recorded('spikes', filter_ids)]
+            else:
+                if variable == 'v':
+                    get_signal = lambda id: id._cell.vtrace
+                elif variable == 'gsyn_exc':
+                    get_signal = lambda id: id._cell.gsyn_trace['excitatory']
+                elif variable == 'gsyn_inh':
+                    get_signal = lambda id: id._cell.gsyn_trace['inhibitory']
+                else:
+                    signal = lambda id: id._cell.traces[variable]
+                segment.analogsignals = [
+                    neo.AnalogSignal(get_signal(id), # assuming not using cvode, otherwise need to use IrregularlySampledAnalogSignal
+                                     units=recording.UNITS_MAP.get(variable, 'dimensionless'),
+                                     t_start=simulator.state.t_start*pq.ms,
+                                     sampling_period=simulator.state.dt*pq.ms,
+                                     name=variable,
+                                     source_population=self.population.label,
+                                     source_id=int(id))
+                    for id in self.filter_recorded(variable, filter_ids)
+                ]
+                assert segment.analogsignals[0].t_stop - simulator.state.t*pq.ms < simulator.state.dt*pq.ms
+                # need to add `Unit` and `RecordingChannel` objects
+        return segment
         
-    def _local_count(self, filter=None):
+    def _local_count(self, variable, filter_ids=None):
         N = {}
-        for id in self.filter_recorded(filter):
-            N[int(id)] = id._cell.spike_times.size()
+        if variable == 'spikes':
+            for id in self.filter_recorded(variable, filter_ids):
+                N[int(id)] = id._cell.spike_times.size()
+        else:
+            raise Exception("Only implemented for spikes")
         return N
-
-simulator.Recorder = Recorder

branches/neo_output/src/neuron/simulator.py

@@ -13 +13 @@
 Classes:
     ID
-    Recorder
     Connection
     
@@ -152 +151 @@
         self.clear()
         self.default_maxstep=10.0
+        self.t_start = 0.0
     
     t = h_property('t')
@@ -176 +176 @@
     state.t = 0
     state.tstop = 0
+    state.t_start = 0
     h.finitialize()
 
@@ -190 +191 @@
             assert local_minimum_delay >= state.min_delay, \
                    "There are connections with delays (%g) shorter than the minimum delay (%g)" % (local_minimum_delay, state.min_delay)
+    state.t_start = state.t
     state.tstop += simtime
     logger.info("Running the simulation for %g ms" % simtime)

branches/neo_output/src/pcsim/recording.py

@@ -108 +108 @@
             N = recording.gather_dict(N)
         return N
-    
-simulator.Recorder = Recorder

branches/neo_output/src/recording/__init__.py

@@ -17 +17 @@
 import numpy
 import os
+from collections import defaultdict
+from pyNN import errors
 from pyNN.recording import files
 try:
@@ -35 +37 @@
     mpi_comm = MPI.COMM_WORLD
 MPI_ROOT = 0
+
+UNITS_MAP = {
+    'spikes': 'ms',
+    'v': 'mV',
+    'gsyn_exc': 'uS',
+    'gsyn_inh': 'uS'
+}
 
 def rename_existing(filename):
@@ -79 +88 @@
 
 
+def normalize_variables_arg(variables):
+    """If variables is a single string, encapsulate it in a list."""
+    if isinstance(variables, basestring):
+        return [variables]
+    else:
+        return variables
+
+
 class Recorder(object):
     """Encapsulates data and functions related to recording model variables."""
     
-
-    formats = {'spikes': 'id t',
-               'v': 'id t v',
-               'gsyn': 'id t ge gi',
-               'generic': 'id t variable'}
-    
-    def __init__(self, variable, population=None, file=None):
+    def __init__(self, population, file=None):
         """
         Create a recorder.
         
-        `variable` -- "spikes", "v" or "gsyn"
         `population` -- the Population instance which is being recorded by the
-                        recorder (optional)
+                        recorder
         `file` -- one of:
             - a file-name,
@@ -100 +110 @@
             - `False` (write to memory).
         """
-        self.variable = variable
         self.file = file
         self.population = population # needed for writing header information
-        if population:
-            assert population.can_record(variable)
-        self.recorded = set([])
+        self.recorded = defaultdict(set)
         
-    def record(self, ids):
-        """Add the cells in `ids` to the set of recorded cells."""
+    def record(self, variables, ids):
+        """
+        Add the cells in `ids` to the sets of recorded cells for the given variables.
+        """
         logger.debug('Recorder.record(<%d cells>)' % len(ids))
         ids = set([id for id in ids if id.local])
-        new_ids = ids.difference(self.recorded)
-        self.recorded = self.recorded.union(ids)
-        logger.debug('Recorder.recorded contains %d ids' % len(self.recorded))
-        self._record(new_ids)
+        for variable in normalize_variables_arg(variables):
+            if not self.population.can_record(variable):
+                raise errors.RecordingError(variable, self.population.celltype)     
+            new_ids = ids.difference(self.recorded[variable])
+            self.recorded[variable] = self.recorded[variable].union(ids)
+            self._record(variable, new_ids)
     
     def reset(self):
         """Reset the list of things to be recorded."""
         self._reset()
-        self.recorded = set([])
+        self.recorded = defaultdict(set)
     
-    def filter_recorded(self, filter):
-        if filter is not None:
-            return set(filter).intersection(self.recorded)
+    def filter_recorded(self, variable, filter_ids):
+        if filter_ids is not None:
+            return set(filter_ids).intersection(self.recorded[variable])
         else:
-            return self.recorded
+            return self.recorded[variable]
     
-    def get(self, gather=False, compatible_output=True, filter=None):
-        """Return the recorded data as a Numpy array."""
-        data_array = self._get(gather, compatible_output, filter)
-        if self.population is not None:
-            try:
-                data_array[:,0] = self.population.id_to_index(data_array[:, 0]) # id is always first column            
-            except Exception:
-                pass
-        self._data_size = data_array.shape[0]
-        return data_array
+    def get(self, variables, gather=False, filter_ids=None):
+        """Return the recorded data as a Neo `Block`."""
+        variables = normalize_variables_arg(variables)
+        data = self._get(variables, gather, filter_ids)
+        data.name = self.population.label
+        data.description = self.population.describe()
+        data.rec_datetime = data.segments[0].rec_datetime
+        data.annotate(**self.metadata)
+        return data
     
-    def write(self, file=None, gather=False, compatible_output=True, filter=None):
+    def write(self, variables, file=None, gather=False, filter_ids=None):
         """Write recorded data to file."""
         file = file or self.file
-        if isinstance(file, basestring):
-            filename = file
-            #rename_existing(filename)
-            if gather==False and self._simulator.state.num_processes > 1:
-                filename += '.%d' % self._simulator.state.mpi_rank
-        else:
-            filename = file.name
-        logger.debug("Recorder is writing '%s' to file '%s' with gather=%s and compatible_output=%s" % (self.variable,
-                                                                                                        filename,
-                                                                                                        gather,
-                                                                                                        compatible_output))
-        data = self.get(gather, compatible_output, filter)
-        metadata = self.metadata
-        logger.debug("data has size %s" % str(data.size))
+        if gather==False and self._simulator.state.num_processes > 1:
+            file.name += '.%d' % self._simulator.state.mpi_rank
+        logger.debug("Recorder is writing '%s' to file '%s' with gather=%s" % (
+                                               variables, file.name, gather))
+        data = self.get(variables, gather, filter_ids)
         if self._simulator.state.mpi_rank == 0 or gather == False:
-            if compatible_output:
-                data = self._make_compatible(data)
             # Open the output file, if necessary and write the data
             logger.debug("Writing data to file %s" % file)
-            if isinstance(file, basestring):
-                file = files.StandardTextFile(filename, mode='w')
-            file.write(data, metadata)
-            file.close()
+            file.write(data)
     
     @property
     def metadata(self):
         metadata = {}
-        metadata['variable'] = self.variable
         if self.population is not None:
             metadata.update({
@@ -179 +174 @@
             })
         metadata['dt'] = self._simulator.state.dt # note that this has to run on all nodes (at least for NEST)
-        if not hasattr(self, '_data_size'):
-            self.get()
-        metadata['n'] = self._data_size
         return metadata
     
-    def _make_compatible(self, data_source):
-        """
-        Rewrite simulation data in a standard format:
-            spiketime (in ms) cell_id-min(cell_id)
-        """
-        assert isinstance(data_source, numpy.ndarray)
-        logger.debug("Converting data from memory into compatible format")
-        N = len(data_source)
-        
-        logger.debug("Number of data elements = %d" % N)
-        if N > 0:
-            # Shuffle columns if necessary
-            input_format = self.formats.get(self.variable,
-                                            self.formats["generic"]).split()
-            time_column = input_format.index('t')
-            id_column = input_format.index('id')
-            
-            if self.variable == 'gsyn':
-                ge_column = input_format.index('ge')
-                gi_column = input_format.index('gi')
-                column_map = [ge_column, gi_column, id_column]
-            elif self.variable == 'v': # voltage files
-                v_column = input_format.index('v')
-                column_map = [v_column, id_column]
-            elif self.variable == 'spikes': # spike files
-                column_map = [time_column, id_column]
-            else:
-                variable_column = input_format.index('variable')
-                column_map = [variable_column, id_column]
-            
-            data_array = data_source[:, column_map]
-        else:
-            logger.warning("%s is empty or does not exist" % data_source)
-            data_array = numpy.array([])
-        return data_array
-    
-    def count(self, gather=True, filter=None):
+    def count(self, variable, gather=True, filter_ids=None):
         """
         Return the number of data points for each cell, as a dict. This is mainly
         useful for spike counts or for variable-time-step integration methods.
         """
-        if self.variable == 'spikes':
-            N = self._local_count(filter)
+        if variable == 'spikes':
+            N = self._local_count(variable, filter_ids)
         else:
             raise Exception("Only implemented for spikes.")