Changeset 887 for branches

Timestamp:

01/04/11 15:03:24 (17 months ago)

Author:

apdavison

Message:

In reorganization branch, added support for recording from native cells in NEURON.

Location:

branches/reorganization

Files:

• doc/nonstandardmodels.txt (added)
• src/nest/cells.py (modified) (2 diffs)
• src/neuron/cells.py (modified) (2 diffs)
• src/neuron/electrodes.py (modified) (1 diff)
• src/neuron/recording.py (modified) (3 diffs)
• test/system/test_nest.py (modified) (1 diff)
• test/system/test_neuron.py (modified) (2 diffs)
• test/unittests/test_neuron.py (modified) (1 diff)

branches/reorganization/src/nest/cells.py

@@ -23 +23 @@
 
 def get_receptor_types(model_name):
-    return nest.GetDefaults(model_name).get("receptor_types", [])
+    return nest.GetDefaults(model_name).get("receptor_types", ('excitatory', 'inhibitory'))
 
 def get_recordables(model_name):
@@ -43 +43 @@
         cls.injectable = ("V_m" in cls.default_initial_values)
         cls.recordable = get_recordables(cls.nest_model) + ['spikes']
-        cls.standard_receptor_type = (len(cls.synapse_types) == 0)
+        cls.standard_receptor_type = (cls.synapse_types == ('excitatory', 'inhibitory'))
         cls.nest_name  = {"on_grid": cls.nest_model, "off_grid": cls.nest_model}
         cls.conductance_based = ("g" in (s[0] for s in cls.recordable))

branches/reorganization/src/neuron/cells.py

@@ -7 +7 @@
 
 from pyNN.standardmodels import cells, build_translations
+from pyNN.models import BaseCellType
 from pyNN import errors
 from neuron import h, nrn, hclass
@@ -30 +31 @@
         return getattr(obj, attr_name)
     return property(fset=set, fget=get)
+
+
+class NativeCellType(BaseCellType):
+    pass
 
 

branches/reorganization/src/neuron/electrodes.py

@@ -67 +67 @@
         for id in cell_list:
             if id.local:
-                if 'v' not in id.celltype.recordable:
+                if not id.celltype.injectable:
                     raise TypeError("Can't inject current into a spike source.")
                 iclamp = h.IClamp(0.5, sec=id._cell.source_section)

branches/reorganization/src/neuron/recording.py

@@ -2 +2 @@
 from pyNN import recording
 from pyNN.neuron import simulator
+import re
+from neuron import h
+
+recordable_pattern = re.compile(r'(?P<section>\w+)(\((?P<location>[-+]?[0-9]*\.?[0-9]+)\))?\.(?P<var>\w+)')
 
 # --- For implementation of record_X()/get_X()/print_X() -----------------------
@@ -24 +28 @@
                     id._cell.record_gsyn("inhibitory_TM", 1)
         else:
+            for id in new_ids:
+               self._native_record(id)
+        
+    def _native_record(self, id):
+        match = recordable_pattern.match(self.variable)
+        if match:
+            parts = match.groupdict()
+            section = getattr(id._cell, parts['section'])
+            if parts['location']:
+                segment = section(float(parts['location']))
+            else:
+                segment = section
+            id._cell.traces[self.variable] = vec = h.Vector()
+            vec.record(getattr(segment, "_ref_%s" % parts['var']))
+            if not id._cell.recording_time:
+                id._cell.record_times = h.Vector()
+                id._cell.record_times.record(h._ref_t)
+                id._cell.recording_time += 1
+        else:
             raise Exception("Recording of %s not implemented." % self.variable)
-        
+    
     def _get(self, gather=False, compatible_output=True, filter=None):
         """Return the recorded data as a Numpy array."""
@@ -69 +92 @@
                 data = numpy.concatenate((data, new_data))
         else:
-            raise Exception("Recording of %s not implemented." % self.variable)
+            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)
         if gather and simulator.state.num_processes > 1:
             data = recording.gather(data)

branches/reorganization/test/system/test_nest.py

@@ -56 +56 @@
     id, t, v = p1.recorders['V_m'].get().T
     assert v.max() > 0.0 # should have some spikes
-    
+
+ 
 def test_native_stdp_model():
     nest = pyNN.nest

branches/reorganization/test/system/test_neuron.py

@@ -2 +2 @@
 from scenarios import scenarios
 from nose.tools import assert_equal, assert_almost_equal
+from pyNN.random import RandomDistribution
+from pyNN.utility import init_logging
 
 try:
     import pyNN.neuron
+    from pyNN.neuron.cells import _new_property, NativeCellType
+    from nrnutils import Mechanism, Section
     have_neuron = True
 except ImportError:
     have_neuron = False
+
+   
 
 def test_scenarios():
@@ -32 +38 @@
     assert_almost_equal(pynn.get_current_time(), 10.0, places=11)
     assert_equal(cell[0]._cell.interval, 1000.0/12.0)
+
+
+class SimpleNeuron(object):
     
+    def __init__(self, **parameters):
+        # define ion channel parameters
+        leak = Mechanism('pas', e=-65, g=parameters['g_leak'])
+        hh = Mechanism('hh', gl=parameters['g_leak'], el=-65,
+                       gnabar=parameters['gnabar'], gkbar=parameters['gkbar'])
+        # create cable sections
+        self.soma = Section(L=30, diam=30, mechanisms=[hh])
+        self.apical = Section(L=600, diam=2, nseg=5, mechanisms=[leak], parent=self.soma,
+                              connect_to=1)
+        self.basilar = Section(L=600, diam=2, nseg=5, mechanisms=[leak], parent=self.soma)
+        self.axon = Section(L=1000, diam=1, nseg=37, mechanisms=[hh])
+        # synaptic input
+        self.apical.add_synapse('ampa', 'Exp2Syn', e=0.0, tau1=0.1, tau2=5.0)
+
+        # needed for PyNN
+        self.source_section = self.soma
+        self.source = self.soma(0.5)._ref_v
+        self.parameter_names = ('g_leak', 'gnabar', 'gkbar')
+        self.traces = {}
+        self.recording_time = False
+        
+    def _set_g_leak(self, value):
+        for sec in (self.apical, self.basilar):
+            for seg in sec:
+               seg.pas.g = value
+        for sec in (self.soma, self.axon):
+            for seg in sec:
+                seg.hh.gl = value
+    def _get_g_leak(self):
+        return self.apical(0.5).pas.g
+    g_leak = property(fget=_get_g_leak, fset=_set_g_leak)
+
+    def _set_gnabar(self, value):
+        for sec in (self.soma, self.axon):
+            for seg in sec:
+                seg.hh.gnabar = value
+    def _get_gnabar(self):
+        return self.soma(0.5).hh.gnabar
+    gnabar = property(fget=_get_gnabar, fset=_set_gnabar)
+
+    def _set_gkbar(self, value):
+        for sec in (self.soma, self.axon):
+            for seg in sec:
+                seg.hh.gkbar = value
+    def _get_gkbar(self):
+        return self.soma(0.5).hh.gkbar
+    gkbar = property(fget=_get_gkbar, fset=_set_gkbar)
+
+    def memb_init(self):
+        """needed for PyNN"""
+        for sec in (self.soma, self.axon, self.apical, self.basilar):
+            for seg in sec:
+                seg.v = self.v_init
+
+
+class SimpleNeuronType(NativeCellType):
+    default_parameters = {'g_leak': 0.0002, 'gkbar': 0.036, 'gnabar': 0.12}
+    default_initial_values = {'v': -65.0}
+    recordable = ['apical(1.0).v', 'soma(0.5).ina'] # this is not good - over-ride Population.can_record()?
+    model = SimpleNeuron
+
+
+def test_record_native_model():
+    nrn = pyNN.neuron
+    
+    init_logging(logfile=None, debug=True)
+    nrn.setup()
+
+    parameters = {'g_leak': 0.0003}
+    p1 = nrn.Population(10, SimpleNeuronType, parameters)
+    print p1.get('g_leak')
+    p1.rset('gnabar', RandomDistribution('uniform', [0.10, 0.14]))
+    print p1.get('gnabar')
+    p1.initialize('v', -63.0)
+
+    current_source = nrn.StepCurrentSource([50.0, 110.0, 150.0, 210.0],
+                                           [0.4, 0.6, -0.2, 0.2])
+    p1.inject(current_source)
+
+    p2 = nrn.Population(1, nrn.SpikeSourcePoisson, {'rate': 100.0})
+
+    p1._record('apical(1.0).v')
+    p1._record('soma(0.5).ina')
+
+    connector = nrn.AllToAllConnector(weights=0.1)
+    prj_alpha = nrn.Projection(p2, p1, connector, target='apical.ampa')
+    
+    nrn.run(250.0)
+    
+    assert_equal(p1.recorders['apical(1.0).v'].get().shape, (25010, 3))
+    id, t, v = p1.recorders['apical(1.0).v'].get().T
+    return id, t, v

branches/reorganization/test/unittests/test_neuron.py

@@ -9 +9 @@
     recordable = ['v']
     parameters = ['romans', 'judeans']
+    injectable = True
     @classmethod
     def has_parameter(cls, name):