Changeset 1032

Timestamp:

12/14/11 09:58:04 (5 months ago)

Author:

apdavison

Message:

In neo_output branch, refactoring to move shared code to pyNN.recording, and support for multiple Segments (each reset() creates a new Segment

Location:

branches/neo_output

Files:

• examples/reset_example.py (added)
• src/common/control.py (modified) (2 diffs)
• src/common/populations.py (modified) (3 diffs)
• src/nest/recording.py (modified) (1 diff)
• src/nest/simulator.py (modified) (1 diff)
• src/neuron/electrodes.py (modified) (4 diffs)
• src/neuron/recording.py (modified) (2 diffs)
• src/neuron/simulator.py (modified) (1 diff)
• src/recording/__init__.py (modified) (5 diffs)

branches/neo_output/src/common/control.py

@@ -41 +41 @@
 
 def build_reset(simulator):
-    def reset():
+    def reset(annotations={}):
         """
         Reset the time to zero, neuron membrane potentials and synaptic weights to
@@ -47 +47 @@
         is not changed, nor is the specification of which neurons to record from.
         """
+        for recorder in simulator.recorders:
+            recorder.store_to_cache(annotations)
         simulator.reset()
     return reset

branches/neo_output/src/common/populations.py

@@ -622 +622 @@
         self._positions = None
         self._is_sorted = True
+        self.annotations = {}
         # Build the arrays of cell ids
         # Cells on the local node are represented as ID objects, other cells by integers
@@ -713 +714 @@
                          case of non-point models).""")
 
+    def annotate(self, **annotations):
+        self.annotations.update(annotations)
+
     def describe(self, template='population_default.txt', engine='default'):
         """
@@ -732 +736 @@
             "last_id": self.last_id,
         }
+        context.update(self.annotations)
         if len(self.local_cells) > 0:
             first_id = self.local_cells[0]

branches/neo_output/src/nest/recording.py

@@ -394 +394 @@
     #    self._create_device()
 
-    def _get(self, variables, gather=False, filter_ids=None):
-        """Return the recorded data as a Neo `Block`."""
-        always_local = (hasattr(self.population.celltype, 'always_local') and self.population.celltype.always_local)
-        data = neo.Block()
-        # TODO: add cached data from previous runs
-        data.segments.append(self._get_current_segment(filter_ids=filter_ids, variables=variables))
-        return data
-        
     def _get_current_segment(self, filter_ids=None, variables='all'):
         segment = neo.Segment(name=self.population.label,

branches/neo_output/src/nest/simulator.py

@@ -36 +36 @@
 write_on_end = [] # a list of (population, variable, filename) combinations that should be written to file on end()
 recording_devices = []
+recorders = set([])
 
 global net

branches/neo_output/src/neuron/electrodes.py

@@ -13 +13 @@
 
 from neuron import h
+
+def _iclamp_property(local_name, hoc_name):
+    """
+    Returns a new property for getting/setting iclamp attributes
+    """
+    def get(self):
+        return getattr(self, local_name)
+    def set(self, value):
+        setattr(self, local_name, value)
+        for iclamp in self._devices:
+            setattr(iclamp, hoc_name, value)
+    return property(fget=get, fset=set)
 
 
@@ -31 +43 @@
             amplitude -- pulse amplitude in nA
         """
-        self.amplitude = amplitude
-        self.start = start
-        self.stop = stop or 1e12
+        self._amplitude = amplitude
+        self._start = start
+        self._stop = stop or 1e12
         self._devices = []
     
@@ -41 +53 @@
             if id.local:
                 iclamp = h.IClamp(0.5, sec=id._cell.source_section)
-                iclamp.delay = self.start
-                iclamp.dur = self.stop-self.start
-                iclamp.amp = self.amplitude
+                iclamp.delay = self._start
+                iclamp.dur = self._stop-self._start
+                iclamp.amp = self._amplitude
                 self._devices.append(iclamp)
+
+    amplitude = _iclamp_property("_amplitude", "amp")
+    
+    def _set_start(self, value):
+        self._start = value
+        for iclamp in self._devices:
+            iclamp.delay = value
+            iclamp.dur = self._stop - value
+    start = property(fget=lambda self: self._start,
+                     fset=_set_start)
+    
+    def _set_stop(self, value):
+        self._stop = value
+        for iclamp in self._devices:
+            iclamp.dur = value - self._start
+    stop = property(fget=lambda self: self._start,
+                    fset=_set_stop)
 
 
@@ -79 +108 @@
                 self.amplitudes.play(iclamp._ref_amp, self.times)
                 
+    # need to make times and amplitudes properties so they can be modified
+    

branches/neo_output/src/neuron/recording.py

@@ -19 +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 __init__(self, population, file=None):
-        __doc__ = super(Recorder, self).__init__.__doc__
-        super(Recorder, self).__init__(population, file)
-        self.cache = DataCache()
+    _simulator = simulator 
     
     def _record(self, variable, new_ids):
@@ -107 +74 @@
         else:
             raise Exception("Recording of %s not implemented." % 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'):

branches/neo_output/src/neuron/simulator.py

@@ -39 +39 @@
 write_on_end = []
 gid_sources = []
+recorders = set([])
 logger = logging.getLogger("PyNN")
 

branches/neo_output/src/recording/__init__.py

@@ -107 +107 @@
         raise Exception("file extension %s not supported" % extension)
 
+def filter_by_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):
+        if obj not in self._data:
+            self._data.append(obj)
+
 
 class Recorder(object):
@@ -125 +153 @@
         self.population = population # needed for writing header information
         self.recorded = defaultdict(set)
+        self.cache = DataCache()
+        self._simulator.recorders.add(self)
         
     def record(self, variables, ids):
@@ -153 +183 @@
         """Return the recorded data as a Neo `Block`."""
         variables = normalize_variables_arg(variables)
-        data = self._get(variables, gather, filter_ids)
+        data = neo.Block()
+        data.segments = [filter_by_variables(segment, variables)
+                         for segment in self.cache]
+        if self._simulator.state.running: # reset() has not been called, so current segment is not in cache
+            data.segments.append(self._get_current_segment(filter_ids=filter_ids, variables=variables))
         data.name = self.population.label
         data.description = self.population.describe()
         data.rec_datetime = data.segments[0].rec_datetime
         data.annotate(**self.metadata)
+        if gather and self._simulator.state.num_processes > 1:
+            data = recording.gather(data)
         return data
     
@@ -183 +219 @@
                 'label': self.population.label,
             }
+        metadata.update(self.population.annotations)
         metadata['dt'] = self._simulator.state.dt # note that this has to run on all nodes (at least for NEST)
         return metadata
@@ -199 +236 @@
         return N
     
+    def store_to_cache(self, annotations={}):
+        segment = self._get_current_segment()
+        segment.annotate(**annotations)
+        self.cache.store(segment)