Changeset 998 for trunk

Timestamp:

10/12/11 10:20:32 (7 months ago)

Author:

apdavison

Message:

Removed ConnectionManager. Now that connect() returns a Projection, ConnectionManager is no longer needed so its functionality has been returned to Projection for the sake of simplicity.

Location:

trunk

Files:

• examples/VAbenchmarks2-csa.py (modified) (1 diff)
• examples/iaf_sfa_relref/iaf_sfa_network_INH_GAMMA.py (modified) (1 diff)
• examples/iaf_sfa_relref/iaf_sfa_network_STATIC.py (modified) (1 diff)
• src/brian/__init__.py (modified) (5 diffs)
• src/brian/connectors.py (modified) (2 diffs)
• src/brian/simulator.py (modified) (4 diffs)
• src/common.py (modified) (14 diffs)
• src/connectors.py (modified) (8 diffs)
• src/connectors2.py (modified) (6 diffs)
• src/core.py (modified) (2 diffs)
• src/moose/__init__.py (modified) (2 diffs)
• src/moose/simulator.py (modified) (1 diff)
• src/nemo/__init__.py (modified) (2 diffs)
• src/nemo/simulator.py (modified) (1 diff)
• src/nest/__init__.py (modified) (4 diffs)
• src/nest/connectors.py (modified) (1 diff)
• src/nest/simulator.py (modified) (4 diffs)
• src/neuron/__init__.py (modified) (4 diffs)
• src/neuron/simulator.py (modified) (6 diffs)
• src/pcsim/__init__.py (modified) (5 diffs)
• src/pcsim/simulator.py (modified) (4 diffs)
• test/system/scenarios.py (modified) (2 diffs)
• test/unittests/test_connectors.py (modified) (15 diffs)
• test/unittests/test_projection.py (modified) (11 diffs)

trunk/examples/VAbenchmarks2-csa.py

@@ -131 +131 @@
 
 print "%s Initialising membrane potential to random values..." % node_id
-rng = NumpyRNG(seed=rngseed, parallel_safe=parallel_safe, rank=node_id, num_processes=np)
+rng = NumpyRNG(seed=rngseed, parallel_safe=parallel_safes)
 uniformDistr = RandomDistribution('uniform', [v_reset,v_thresh], rng=rng)
 all_cells.initialize('v', uniformDistr)

trunk/examples/iaf_sfa_relref/iaf_sfa_network_INH_GAMMA.py

@@ -140 +140 @@
             # Connect everything up
             yTimer = time.time()
-            projection.connection_manager.convergent_connect(chosenPresIDs, currentPostID, weights, delaysClipped)
+            projection._convergent_connect(chosenPresIDs, currentPostID, weights, delaysClipped)
             timer4 += time.time() - myTimer
             

trunk/examples/iaf_sfa_relref/iaf_sfa_network_STATIC.py

@@ -142 +142 @@
             # Connect everything up
             yTimer = time.time()
-            projection.connection_manager.convergent_connect(chosenPresIDs, currentPostID, weights, delaysClipped)
+            projection._convergent_connect(chosenPresIDs, currentPostID, weights, delaysClipped)
             timer4 += time.time() - myTimer
             

trunk/src/brian/__init__.py

@@ -131 +131 @@
 #                                            threshold=v_thresh,
 #                                            reset=v_reset,
-#                                            clock=state.simclock,
+#                                            clock=simulator.state.simclock,
 #                                            compile=True,
-#                                            max_delay=state.max_delay)
+#                                            max_delay=simulator.state.max_delay)
 #            cell_parameters = cellparams or {}
 #        elif isinstance(cellclass, type) and issubclass(cellclass, standardmodels.StandardCellType):
@@ -238 +238 @@
         else:        
             self._plasticity_model = "static_synapse"
-                                        
-        self.connection_manager = simulator.ConnectionManager(self.synapse_type, self._plasticity_model, parent=self)
-        self.connections = self.connection_manager        
+        
+        self._n                 = {}
+        self._brian_connections = {}
+        self._indices           = {}
+        self._populations      = [{}, {}]
+              
         method.connect(self)
-        self.connection_manager._finalize()
+        self._finalize()
+        
         if self._plasticity_model != "static_synapse":
-            for key in self.connections.keys:
-                synapses = self.connections.brian_connections[key]
+            for key in self._brian_connections.keys:
+                synapses = self._brian_connections[key]
                 if self._plasticity_model is "stdp_synapse": 
                     parameters   = self.synapse_dynamics.slow.all_parameters
@@ -268 +272 @@
                                             parameters['U'])
                     simulator.state.add(stp)
-                    
+    
+    def __len__(self):
+        """Return the total number of connections in this Projection."""
+        result = 0
+        for key in self._brian_connections.keys():
+            result += self._n[key]
+        return result
+    
+    def _get_indices(self):
+        sources = numpy.array([], int)
+        targets = numpy.array([], int)
+        for key in self._brian_connections.keys():
+            paddings = self._populations[0][key[0]], self._populations[1][key[1]] 
+            sources  = numpy.concatenate((sources, self._indices[key][0] + paddings[0]))
+            targets  = numpy.concatenate((targets, self._indices[key][1] + paddings[1]))
+        return sources.astype(int), targets.astype(int)    
+    
+    def __getitem__(self, i):
+        """Return the `i`th connection as a Connection object."""
+        cumsum_idx     = numpy.cumsum(self._n.values())
+        if isinstance(i, slice):
+            idx  = numpy.searchsorted(cumsum_idx, numpy.arange(*i.indices(i.stop)), 'left')
+            keys = [self._brian_connections.keys()[j] for j in idx]
+        else:
+            idx  = numpy.searchsorted(cumsum_idx, i, 'left')
+            keys = self._brian_connections.keys()[idx]
+        global_indices = self._get_indices()
+        if isinstance(i, int):
+            if i < len(self):
+                pad        = i - cumsum_idx[idx]
+                local_idx  = self._indices[keys][0][pad], self._indices[keys][1][pad]
+                local_addr = global_indices[0][i], global_indices[1][i]
+                return Connection(self._brian_connections[keys], local_idx, local_addr)
+            else:
+                raise IndexError("%d > %d" % (i, len(self)-1))
+        elif isinstance(i, slice):
+            if i.stop < len(self):
+                res = []
+                for count, j in enumerate(xrange(*i.indices(i.stop))):
+                    key = keys[count]
+                    pad = j - cumsum_idx[idx[count]]
+                    local_idx  = self._indices[key][0][pad], self._indices[key][1][pad]
+                    local_addr = global_indices[0][j], global_indices[1][j]
+                    res.append(simulator.Connection(self._brian_connections[key], local_idx, local_addr))
+                return res
+            else:
+                raise IndexError("%d > %d" % (i.stop, len(self)-1))
+    
+    def __connection_generator(self):
+        """Yield each connection in turn."""
+        global_indices = self._get_indices()
+        count = 0
+        for key in self._brian_connections.keys():
+            bc = self._brian_connections[key]
+            for i in xrange(bc.W.getnnz()):
+                local_idx  = self._indices[key][0][i], self._indices[key][0][i] 
+                local_addr = global_indices[0][count], global_indices[1][count]
+                yield simulator.Connection(bc, self._indices[key])
+                count += 1                
+                
+    def __iter__(self):
+        """Return an iterator over all connections in this Projection."""
+        return self.__connection_generator()
+    
+    def _finalize(self):
+        for key in self._brian_connections.keys():
+            self._indices[key]  = self._brian_connections[key].W.nonzero()
+            self._brian_connections[key].compress()     
+    
+    def _get_brian_connection(self, source_group, target_group, synapse_obj, weight_units, homogeneous=False):
+        """
+        Return the Brian Connection object that connects two NeuronGroups with a
+        given synapse model.
+        
+        source_group -- presynaptic Brian NeuronGroup.
+        target_group -- postsynaptic Brian NeuronGroup
+        synapse_obj  -- name of the variable that will be modified by synaptic
+                        input.
+        weight_units -- Brian Units object: nA for current-based synapses,
+                        uS for conductance-based synapses.
+        """
+        key = (source_group, target_group, synapse_obj)
+        if not self._brian_connections.has_key(key):
+            assert isinstance(source_group, brian.NeuronGroup)
+            assert isinstance(target_group, brian.NeuronGroup), type(target_group)
+            assert isinstance(synapse_obj, basestring), "%s (%s)" % (synapse_obj, type(synapse_obj))
+            try:
+                max_delay = simulator.state.max_delay*ms
+            except Exception:
+                raise Exception("Simulation timestep not yet set. Need to call setup()")
+            if not homogeneous:
+                self._brian_connections[key] = brian.DelayConnection(source_group,
+                                                               target_group,
+                                                               synapse_obj,
+                                                               max_delay=max_delay)
+            else:
+                self._brian_connections[key] = brian.Connection(source_group,
+                                                          target_group,
+                                                          synapse_obj,
+                                                          max_delay=simulator.state.max_delay*ms)
+            self._brian_connections[key].weight_units = weight_units
+            simulator.state.add(self._brian_connections[key])
+            self._n[key] = 0
+        return self._brian_connections[key]
+    
+    def _detect_parent_groups(self, cells):
+        groups = {}
+        for index, cell in enumerate(cells):
+            group = cell.parent_group
+            if not groups.has_key(group):
+                groups[group] = [index]
+            else:
+                groups[group] += [index]
+        return groups
+    
+    def _divergent_connect(self, source, targets, weights, delays, homogeneous=False):
+        """
+        Connect a neuron to one or more other neurons with a static connection.
+        
+        `source`  -- the ID of the pre-synaptic cell.
+        `targets` -- a list/1D array of post-synaptic cell IDs, or a single ID.
+        `weight`  -- a list/1D array of connection weights, or a single weight.
+                     Must have the same length as `targets`.
+        `delays`  -- a list/1D array of connection delays, or a single delay.
+                     Must have the same length as `targets`.
+        """
+        #print "connecting", source, "to", targets, "with weights", weights, "and delays", delays
+        if not core.is_listlike(targets):
+            targets = [targets]
+        if isinstance(weights, float):
+            weights = [weights]
+        if isinstance(delays, float):
+            delays = [delays]
+        assert len(targets) > 0
+        if not isinstance(source, common.IDMixin):
+            raise errors.ConnectionError("source should be an ID object, actually %s" % type(source))
+        for target in targets:
+            if not isinstance(target, common.IDMixin):
+                raise errors.ConnectionError("Invalid target ID: %s" % target)
+        assert len(targets) == len(weights) == len(delays), "%s %s %s" % (len(targets),len(weights),len(delays))
+        if common.is_conductance(targets[0]):
+            units = uS
+        else:
+            units = nA
+        synapse_type = self.synapse_type or "excitatory"
+        try:
+            source_group = source.parent_group
+        except AttributeError, errmsg:
+            raise errors.ConnectionError("%s. Maybe trying to connect from non-existing cell (ID=%s)." % (errmsg, source))
+        groups = self._detect_parent_groups(targets) # we assume here all the targets belong to the same NeuronGroup
+        
+        weights = numpy.array(weights) * units
+        delays  = numpy.array(delays) * ms
+        weights[weights == 0] = simulator.ZERO_WEIGHT            
+        
+        for target_group, indices in groups.items():
+            synapse_obj = targets[indices[0]].parent.celltype.synapses[synapse_type]        
+            bc          = self._get_brian_connection(source_group, target_group, synapse_obj, units, homogeneous)       
+            padding     = (int(source.parent.first_id), int(targets[indices[0]].parent.first_id))
+            src         = int(source) - padding[0]
+            mytargets   = numpy.array(targets, int)[indices] - padding[1]            
+            bc.W.rows[src] = mytargets
+            bc.W.data[src] = weights[indices]        
+            if not homogeneous:
+                bc.delayvec.rows[src] = mytargets
+                bc.delayvec.data[src] = delays[indices]
+            else:
+                bc.delay = int(delays[0] / bc.source.clock.dt)
+            key = (source_group, target_group, synapse_obj)
+            self._n[key] += len(mytargets)
+            
+            pop_sources = self._populations[0]
+            if len(pop_sources) is 0:
+                pop_sources[source_group] = 0
+            elif not pop_sources.has_key(source_group):
+                pop_sources[source_group] = numpy.sum([len(item) for item in pop_sources.keys()])
+            pop_targets = self._populations[1]
+            if len(pop_targets) is 0:
+                pop_targets[target_group] = 0
+            elif not pop_targets.has_key(target_group):
+                pop_targets[target_group] = numpy.sum([len(item) for item in pop_targets.keys()])  
+
     def saveConnections(self, file, gather=True, compatible_output=True):
         """
@@ -275 +460 @@
         """
         import operator
-        lines   = numpy.empty((len(self.connection_manager), 4))
+        lines   = numpy.empty((len(self), 4))
         padding = 0
-        for key in self.connection_manager.keys:
-            bc   = self.connection_manager.brian_connections[key]
+        for key in self._brian_connections.keys():
+            bc   = self._brian_connections[key]
             size = bc.W.getnnz()
-            lines[padding:padding+size,0], lines[padding:padding+size,1] = self.connection_manager.indices[key]
+            lines[padding:padding+size,0], lines[padding:padding+size,1] = self._indices[key]
             lines[padding:padding+size,2] = bc.W.alldata / bc.weight_units
             if isinstance(bc, brian.DelayConnection):
@@ -296 +481 @@
         file.close()
 
+    def set(self, name, value):
+        """
+        Set connection attributes for all connections in this Projection.
+        
+        `name`  -- attribute name
+        `value` -- the attribute numeric value, or a list/1D array of such
+                   values of the same length as the number of local connections,
+                   or a 2D array with the same dimensions as the connectivity
+                   matrix (as returned by `get(format='array')`).
+        """
+        for key in self._brian_connections.keys():
+            bc = self._brian_connections[key]
+            padding = 0
+            if name == 'weight':
+                M = bc.W
+                units = bc.weight_units
+            elif name == 'delay':
+                M = bc.delay
+                units = ms
+            else:
+                raise Exception("Setting parameters other than weight and delay not yet supported.")
+            value = value*units
+            if numpy.isscalar(value):
+                if (name == 'weight') or (name == 'delay' and isinstance(bc, brian.DelayConnection)):
+                    for row in xrange(M.shape[0]):
+                        M.set_row(row, value)
+                elif (name == 'delay' and isinstance(bc, brian.Connection)):
+                    bc.delay = int(value / bc.source.clock.dt)
+                else:
+                    raise Exception("Setting a non appropriate parameter")
+            elif isinstance(value, numpy.ndarray) and len(value.shape) == 2:
+                if (name == 'delay') and not isinstance(bc, brian.DelayConnection):
+                    raise Exception("FastConnector have been used, and only fixed homogeneous delays are allowed")
+                address_gen = ((i, j) for i,row in enumerate(bc.W.rows) for j in row)
+                for (i,j) in address_gen:
+                    M[i,j] = value[i,j]
+            elif core.is_listlike(value):
+                N = M.getnnz()
+                assert len(value[padding:padding+N]) == N
+                if (name == 'delay') and not isinstance(bc, brian.DelayConnection):
+                    raise Exception("FastConnector have been used: only fixed homogeneous delays are allowed")
+                M.alldata = value
+            else:
+                raise Exception("Values must be scalars or lists/arrays")
+            padding += M.getnnz()
+
+    def get(self, parameter_name, format, gather=True):
+        """
+        Get the values of a given attribute (weight or delay) for all
+        connections in this Projection.
+        
+        `parameter_name` -- name of the attribute whose values are wanted.
+        `format` -- "list" or "array". Array format implicitly assumes that all
+                    connections belong to a single Projection.
+        
+        Return a list or a 2D Numpy array. The array element X_ij contains the
+        attribute value for the connection from the ith neuron in the pre-
+        synaptic Population to the jth neuron in the post-synaptic Population,
+        if such a connection exists. If there are no such connections, X_ij will
+        be NaN.
+        """
+        values = numpy.array([])
+        for key in self._brian_connections.keys():
+            bc = self._brian_connections[key]
+            if parameter_name == "weight":
+                values = numpy.concatenate((values, bc.W.alldata / bc.weight_units))            
+            elif parameter_name == 'delay':
+                if isinstance(bc, brian.DelayConnection):
+                    values = numpy.concatenate((values, bc.delay.alldata / ms))
+                else:
+                    data   = bc.delay * bc.source.clock.dt * numpy.ones(bc.W.getnnz()) /ms
+                    values = numpy.concatenate((values, data))
+            else:
+                raise Exception("Getting parameters other than weight and delay not yet supported.")
+        
+        if format == 'list':
+            values = values.tolist()
+        elif format == 'array':
+            values_arr = numpy.nan * numpy.ones((self.parent.pre.size, self.parent.post.size))
+            sources, targets = self._indices
+            values_arr[sources, targets] = values
+            values = values_arr
+        else:
+            raise Exception("format must be 'list' or 'array', actually '%s'" % format)
+        return values
+
 Space = space.Space
 

trunk/src/brian/connectors.py

@@ -69 +69 @@
         homogeneous = numpy.isscalar(self.delays_generator.source)
         if len(targets) > 0:
-            self.projection.connection_manager.connect(src, targets.tolist(), weights, delays, homogeneous)
+            self.projection._divergent_connect(src, targets.tolist(), weights, delays, homogeneous)
 
 
@@ -136 +136 @@
             for tgt, src, w, d in zip(projection.post.local_cells, sources, weights, delays):
                 # the float is in case the values are of type numpy.float64, which NEST chokes on
-                projection.connection_manager.connect(src, [tgt], float(w), float(d), homogeneous)
+                projection._divergent_connect(src, [tgt], float(w), float(d), homogeneous)
                 self.progression(count)
                 count += 1

trunk/src/brian/simulator.py

@@ -4 +4 @@
 implementation of the API.
 
-Functions and classes useable by the common implementation:
+Functions and classes usable by the common implementation:
 
 Functions:
-    create_cells()
     reset()
     run()
@@ -14 +13 @@
     ID
     Recorder
-    ConnectionManager
     Connection
     
@@ -397 +395 @@
                    in the weight array.
         `indices` -- the mapping of the x, y coordinates of the established
-                     connections, stored by the connection_manager handling those
+                     connections, stored by the Projection handling those
                      connections.
         """
@@ -425 +423 @@
     weight = property(_get_weight, _set_weight)
     delay = property(_get_delay, _set_delay)
-    
-
-class ConnectionManager(object):
-    """
-    Manage synaptic connections, providing methods for creating, listing,
-    accessing individual connections.
-    """
-
-    def __init__(self, synapse_type, synapse_model=None, parent=None):
-        """
-        Create a new ConnectionManager.
-        
-        `synapse_type` -- the 'physiological type' of the synapse, e.g.
-                          'excitatory' or 'inhibitory',or any other key in the
-                          `synapses` attibute of the celltype class.
-        `synapse_model` -- not used. Present for consistency with other simulators.
-        `parent` -- the parent `Projection`, if any.
-        """
-        self.synapse_type      = synapse_type
-        self.synapse_model     = synapse_model
-        self.parent            = parent
-        self.n                 = {}
-        self.brian_connections = {}
-        self.indices           = {}
-        self._populations      = [{}, {}]
-        
-    def __getitem__(self, i):
-        """Return the `i`th connection as a Connection object."""
-        cumsum_idx     = numpy.cumsum(self.n.values())
-        if isinstance(i, slice):
-            idx  = numpy.searchsorted(cumsum_idx, numpy.arange(*i.indices(i.stop)), 'left')
-            keys = [self.keys[j] for j in idx]
-        else:
-            idx  = numpy.searchsorted(cumsum_idx, i, 'left')
-            keys = self.keys[idx]
-        global_indices = self._indices
-        if isinstance(i, int):
-            if i < len(self):
-                pad        = i - cumsum_idx[idx]
-                local_idx  = self.indices[keys][0][pad], self.indices[keys][1][pad]
-                local_addr = global_indices[0][i], global_indices[1][i]
-                return Connection(self.brian_connections[keys], local_idx, local_addr)
-            else:
-                raise IndexError("%d > %d" % (i, len(self)-1))
-        elif isinstance(i, slice):
-            if i.stop < len(self):
-                res = []
-                for count, j in enumerate(xrange(*i.indices(i.stop))):
-                    key = keys[count]
-                    pad = j - cumsum_idx[idx[count]]
-                    local_idx  = self.indices[key][0][pad], self.indices[key][1][pad]
-                    local_addr = global_indices[0][j], global_indices[1][j]
-                    res.append(Connection(self.brian_connections[key], local_idx, local_addr))
-                return res
-            else:
-                raise IndexError("%d > %d" % (i.stop, len(self)-1))
-    
-    def __len__(self):
-        """Return the total number of connections in this manager."""
-        result = 0
-        for key in self.keys:
-          result += self.n[key]
-        return result 
-    
-    def __connection_generator(self):
-        """Yield each connection in turn."""
-        global_indices = self._indices
-        count          = 0
-        for key in self.keys:
-            bc = self.brian_connections[key]
-            for i in xrange(bc.W.getnnz()):
-                local_idx  = self.indices[key][0][i], self.indices[key][0][i] 
-                local_addr = global_indices[0][count], global_indices[1][count]
-                yield Connection(bc, self.indices[key])
-                count     += 1                
-                
-    @property
-    def keys(self):
-        return self.brian_connections.keys()
-                
-    def __iter__(self):
-        """Return an iterator over all connections in this manager."""
-        return self.__connection_generator()
-    
-    def _finalize(self):
-        for key in self.keys:
-            self.indices[key]  = self.brian_connections[key].W.nonzero()
-            self.brian_connections[key].compress()            
-    
-    @property
-    def _indices(self):
-        sources = numpy.array([], int)
-        targets = numpy.array([], int)
-        for key in self.keys:
-            paddings = self._populations[0][key[0]], self._populations[1][key[1]] 
-            sources  = numpy.concatenate((sources, self.indices[key][0] + paddings[0]))
-            targets  = numpy.concatenate((targets, self.indices[key][1] + paddings[1]))
-        return sources.astype(int), targets.astype(int)    
-    
-    def _get_brian_connection(self, source_group, target_group, synapse_obj, weight_units, homogeneous=False):
-        """
-        Return the Brian Connection object that connects two NeuronGroups with a
-        given synapse model.
-        
-        source_group -- presynaptic Brian NeuronGroup.
-        target_group -- postsynaptic Brian NeuronGroup
-        synapse_obj  -- name of the variable that will be modified by synaptic
-                        input.
-        weight_units -- Brian Units object: nA for current-based synapses,
-                        uS for conductance-based synapses.
-        """
-        key = (source_group, target_group, synapse_obj)
-        if not self.brian_connections.has_key(key):
-            assert isinstance(source_group, brian.NeuronGroup)
-            assert isinstance(target_group, brian.NeuronGroup), type(target_group)
-            assert isinstance(synapse_obj, basestring), "%s (%s)" % (synapse_obj, type(synapse_obj))
-            try:
-                max_delay = state.max_delay*ms
-            except Exception:
-                raise Exception("Simulation timestep not yet set. Need to call setup()")
-            if not homogeneous:
-                self.brian_connections[key] = brian.DelayConnection(source_group,
-                                                               target_group,
-                                                               synapse_obj,
-                                                               max_delay=max_delay)
-            else:
-                self.brian_connections[key] = brian.Connection(source_group,
-                                                          target_group,
-                                                          synapse_obj,
-                                                          max_delay=state.max_delay*ms)
-            self.brian_connections[key].weight_units = weight_units
-            state.add(self.brian_connections[key])
-            self.n[key] = 0
-        return self.brian_connections[key]
-    
-    def _detect_parent_groups(self, cells):
-        groups = {}
-        for index, cell in enumerate(cells):
-            group = cell.parent_group
-            if not groups.has_key(group):
-                groups[group] = [index]
-            else:
-                groups[group] += [index]
-        return groups
-    
-    def connect(self, source, targets, weights, delays, homogeneous=False):
-        """
-        Connect a neuron to one or more other neurons with a static connection.
-        
-        `source`  -- the ID of the pre-synaptic cell.
-        `targets` -- a list/1D array of post-synaptic cell IDs, or a single ID.
-        `weight`  -- a list/1D array of connection weights, or a single weight.
-                     Must have the same length as `targets`.
-        `delays`  -- a list/1D array of connection delays, or a single delay.
-                     Must have the same length as `targets`.
-        """
-        #print "connecting", source, "to", targets, "with weights", weights, "and delays", delays
-        if not core.is_listlike(targets):
-            targets = [targets]
-        if isinstance(weights, float):
-            weights = [weights]
-        if isinstance(delays, float):
-            delays = [delays]
-        assert len(targets) > 0
-        if not isinstance(source, common.IDMixin):
-            raise errors.ConnectionError("source should be an ID object, actually %s" % type(source))
-        for target in targets:
-            if not isinstance(target, common.IDMixin):
-                raise errors.ConnectionError("Invalid target ID: %s" % target)
-        assert len(targets) == len(weights) == len(delays), "%s %s %s" % (len(targets),len(weights),len(delays))
-        if common.is_conductance(targets[0]):
-            units = uS
-        else:
-            units = nA
-        synapse_type = self.synapse_type or "excitatory"
-        try:
-            source_group = source.parent_group
-        except AttributeError, errmsg:
-            raise errors.ConnectionError("%s. Maybe trying to connect from non-existing cell (ID=%s)." % (errmsg, source))
-        groups = self._detect_parent_groups(targets) # we assume here all the targets belong to the same NeuronGroup
-        
-        weights = numpy.array(weights) * units
-        delays  = numpy.array(delays) * ms
-        weights[weights == 0] = ZERO_WEIGHT            
-        
-        for target_group, indices in groups.items():
-            synapse_obj = targets[indices[0]].parent.celltype.synapses[synapse_type]        
-            bc          = self._get_brian_connection(source_group, target_group, synapse_obj, units, homogeneous)       
-            padding     = (int(source.parent.first_id), int(targets[indices[0]].parent.first_id))
-            src         = int(source) - padding[0]
-            mytargets   = numpy.array(targets, int)[indices] - padding[1]            
-            bc.W.rows[src] = mytargets
-            bc.W.data[src] = weights[indices]        
-            if not homogeneous:
-                bc.delayvec.rows[src] = mytargets
-                bc.delayvec.data[src] = delays[indices]
-            else:
-                bc.delay = int(delays[0] / bc.source.clock.dt)
-            key = (source_group, target_group, synapse_obj)
-            self.n[key] += len(mytargets)
-            
-            pop_sources = self._populations[0]
-            if len(pop_sources) is 0:
-                pop_sources[source_group] = 0
-            elif not pop_sources.has_key(source_group):
-                pop_sources[source_group] = numpy.sum([len(item) for item in pop_sources.keys()])
-            pop_targets = self._populations[1]
-            if len(pop_targets) is 0:
-                pop_targets[target_group] = 0
-            elif not pop_targets.has_key(target_group):
-                pop_targets[target_group] = numpy.sum([len(item) for item in pop_targets.keys()])  
-                
-        
-    def get(self, parameter_name, format):
-        """
-        Get the values of a given attribute (weight or delay) for all
-        connections in this manager.
-        
-        `parameter_name` -- name of the attribute whose values are wanted.
-        `format` -- "list" or "array". Array format implicitly assumes that all
-                    connections belong to a single Projection.
-        
-        Return a list or a 2D Numpy array. The array element X_ij contains the
-        attribute value for the connection from the ith neuron in the pre-
-        synaptic Population to the jth neuron in the post-synaptic Population,
-        if such a connection exists. If there are no such connections, X_ij will
-        be NaN.
-        """
-        if self.parent is None:
-            raise Exception("Only implemented for connections created via a Projection object, not using connect()")
-        values = numpy.array([])
-        for key in self.keys:
-            bc = self.brian_connections[key]
-            if parameter_name == "weight":
-                values = numpy.concatenate((values, bc.W.alldata / bc.weight_units))            
-            elif parameter_name == 'delay':
-                if isinstance(bc, brian.DelayConnection):
-                    values = numpy.concatenate((values, bc.delay.alldata / ms))
-                else:
-                    data   = bc.delay * bc.source.clock.dt * numpy.ones(bc.W.getnnz()) /ms
-                    values = numpy.concatenate((values, data))
-            else:
-                raise Exception("Getting parameters other than weight and delay not yet supported.")
-        
-        if format == 'list':
-            values = values.tolist()
-        elif format == 'array':
-            values_arr = numpy.nan * numpy.ones((self.parent.pre.size, self.parent.post.size))
-            sources, targets = self._indices
-            values_arr[sources, targets] = values
-            values = values_arr
-        else:
-            raise Exception("format must be 'list' or 'array', actually '%s'" % format)
-        return values
-        
-    def set(self, name, value):
-        """
-        Set connection attributes for all connections in this manager.
-        
-        `name`  -- attribute name
-        `value` -- the attribute numeric value, or a list/1D array of such
-                   values of the same length as the number of local connections,
-                   or a 2D array with the same dimensions as the connectivity
-                   matrix (as returned by `get(format='array')`).
-        """
-        if self.parent is None:
-            raise Exception("Only implemented for connections created via a Projection object, not using connect()")
-        for key in self.keys:
-            bc = self.brian_connections[key]
-            padding = 0
-            if name == 'weight':
-                M = bc.W
-                units = bc.weight_units
-            elif name == 'delay':
-                M = bc.delay
-                units = ms
-            else:
-                raise Exception("Setting parameters other than weight and delay not yet supported.")
-            value = value*units
-            if numpy.isscalar(value):
-                if (name == 'weight') or (name == 'delay' and isinstance(bc, brian.DelayConnection)):
-                    for row in xrange(M.shape[0]):
-                        M.set_row(row, value)
-                elif (name == 'delay' and isinstance(bc, brian.Connection)):
-                    bc.delay = int(value / bc.source.clock.dt)
-                else:
-                    raise Exception("Setting a non appropriate parameter")
-            elif isinstance(value, numpy.ndarray) and len(value.shape) == 2:
-                if (name == 'delay') and not isinstance(bc, brian.DelayConnection):
-                    raise Exception("FastConnector have been used, and only fixed homogeneous delays are allowed")
-                address_gen = ((i, j) for i,row in enumerate(bc.W.rows) for j in row)
-                for (i,j) in address_gen:
-                    M[i,j] = value[i,j]
-            elif core.is_listlike(value):
-                N = M.getnnz()
-                assert len(value[padding:padding+N]) == N
-                if (name == 'delay') and not isinstance(bc, brian.DelayConnection):
-                    raise Exception("FastConnector have been used: only fixed homogeneous delays are allowed")
-                M.alldata = value
-            else:
-                raise Exception("Values must be scalars or lists/arrays")
-            padding += M.getnnz()
-                    
+  
 
 # --- Initialization, and module attributes ------------------------------------

trunk/src/common.py

@@ -64 +64 @@
 DEFAULT_TIMESTEP = 0.1
 DEFAULT_MIN_DELAY = DEFAULT_TIMESTEP
+
+deprecated = core.deprecated
 
 logger = logging.getLogger("PyNN")
@@ -1719 +1721 @@
     def __len__(self):
         """Return the total number of local connections."""
-        return len(self.connection_manager)
+        raise NotImplementedError
 
     def size(self, gather=True):
@@ -1738 +1740 @@
     def __getitem__(self, i):
         """Return the `i`th connection within the Projection."""
-        return self.connection_manager[i]
+        raise NotImplementedError
+
+    def __iter__(self):
+        """Return an iterator over all connections on the local MPI node."""
+        for i in range(len(self)):
+            yield self[i]
 
     # --- Methods for setting connection parameters ---------------------------
 
+    def set(self, name, value):
+        """
+        Set connection attributes for all connections on the local MPI node.
+        
+        `name`  -- attribute name
+        
+        `value` -- the attribute numeric value, or a list/1D array of such
+                   values of the same length as the number of local connections,
+                   or a 2D array with the same dimensions as the connectivity
+                   matrix (as returned by `get(format='array')`).
+        """
+        raise NotImplementedError
+
+    @deprecated("set('weight', w)")
     def setWeights(self, w):
         """
@@ -1754 +1775 @@
         # if post is an Assembly, some components might have cond-synapses, others curr, so need a more sophisticated check here
         w = check_weight(w, self.synapse_type, is_conductance(self.post.local_cells[0]))
-        self.connection_manager.set('weight', w)
-
+        self.set('weight', w)
+
+    @deprecated("set('weight', rand_distr)")
     def randomizeWeights(self, rand_distr):
         """
@@ -1763 +1785 @@
         # argument type. It could make for easier-to-read simulation code to
         # give it a separate name, though. Comments?
-        self.setWeights(rand_distr.next(len(self)))
-
+        self.set('weight', rand_distr.next(len(self)))
+
+    @deprecated("set('delay', d)")
     def setDelays(self, d):
         """
@@ -1772 +1795 @@
         connectivity matrix (as returned by `getDelays(format='array')`).
         """
-        self.connection_manager.set('delay', d)
-
+        self.set('delay', d)
+
+    @deprecated("set('delay', rand_distr)")
     def randomizeDelays(self, rand_distr):
         """
         Set delays to random values taken from rand_distr.
         """
-        self.setDelays(rand_distr.next(len(self)))
-
+        self.set('delay', rand_distr.next(len(self)))
+
+    @deprecated("set(param, value)")
     def setSynapseDynamics(self, param, value):
         """
@@ -1785 +1810 @@
         projection.
         """
-        self.connection_manager.set(param, value)
-
+        self.set(param, value)
+
+    @deprecated("set(param, value)")
     def randomizeSynapseDynamics(self, param, rand_distr):
         """
         Set parameters of the synapse dynamics to values taken from rand_distr
         """
-        self.setSynapseDynamics(param, rand_distr.next(len(self)))
+        self.set(param, rand_distr.next(len(self)))
 
     # --- Methods for writing/reading information to/from file. ---------------
 
+    def get(self, parameter_name, format, gather=True):
+        """
+        Get the values of a given attribute (weight or delay) for all
+        connections in this Projection.
+        
+        `parameter_name` -- name of the attribute whose values are wanted.
+        
+        `format` -- "list" or "array". Array format implicitly assumes that all
+                    connections belong to a single Projection.
+        
+        Return a list or a 2D Numpy array. The array element X_ij contains the
+        attribute value for the connection from the ith neuron in the pre-
+        synaptic Population to the jth neuron in the post-synaptic Population,
+        if a single such connection exists. If there are no such connections,
+        X_ij will be NaN. If there are multiple such connections, the summed
+        value will be given, which makes some sense for weights, but is
+        pretty meaningless for delays. 
+        """
+        raise NotImplementedError
+
+    @deprecated("get('weight', format, gather)")
     def getWeights(self, format='list', gather=True):
         """
@@ -1806 +1853 @@
         if gather:
             logger.error("getWeights() with gather=True not yet implemented")
-        return self.connection_manager.get('weight', format)
-
+        return self.get('weight', format)
+
+    @deprecated("get('weight', format, gather)")
     def getDelays(self, format='list', gather=True):
         """
@@ -1818 +1866 @@
         if gather:
             logger.error("getDelays() with gather=True not yet implemented")
-        return self.connection_manager.get('delay', format)
-
+        return self.get('delay', format)
+
+    @deprecated("get(parameter_name, format, gather)")
     def getSynapseDynamics(self, parameter_name, format='list', gather=True):
         """
@@ -1827 +1876 @@
         if gather:
             logger.error("getstandardmodels.SynapseDynamics() with gather=True not yet implemented")
-        return self.connection_manager.get(parameter_name, format)
-
+        return self.get(parameter_name, format)
+
+    @deprecated("save('all', file, format, gather)")
     def saveConnections(self, file, gather=True, compatible_output=True):
         """
@@ -1860 +1910 @@
             file.close()
 
+    @deprecated("save('weight', file, format, gather)")
     def printWeights(self, file, format='list', gather=True):
         """
@@ -1865 +1916 @@
         for non-existent connections.
         """
-        weights = self.getWeights(format=format, gather=gather)
+        weights = self.get('weight', format=format, gather=gather)
         
         if isinstance(file, basestring):
@@ -1875 +1926 @@
         file.close()    
 
+    @deprecated("save('delay', file, format, gather)")
     def printDelays(self, file, format='list', gather=True):
         """
@@ -1890 +1942 @@
         file.close()  
 
+    @deprecated("numpy.histogram()")
     def weightHistogram(self, min=None, max=None, nbins=10):
         """

trunk/src/connectors.py

@@ -346 +346 @@
         
         if len(targets) > 0:
-            self.projection.connection_manager.connect(src, targets.tolist(), weights, delays)
+            self.projection._divergent_connect(src, targets.tolist(), weights, delays)
 
     
@@ -526 +526 @@
             ## to use a convergent_connect method, instead of a divergent_connect one
             #idx     = eval(tests)
-            #projection.connection_manager.connect(src, tgts[idx].tolist(), weights[idx], delays[idx])
-            projection.connection_manager.connect(src, tgts.tolist(), weights, delays)
+            #projection._divergent_connect(src, tgts[idx].tolist(), weights[idx], delays[idx])
+            projection._divergent_connect(src, tgts.tolist(), weights, delays)
             self.progression(count)
             count += 1
@@ -646 +646 @@
                
             if len(targets) > 0:
-                projection.connection_manager.connect(src, targets.tolist(), weights, delays)
+                projection._divergent_connect(src, targets.tolist(), weights, delays)
             
             self.progression(count)
@@ -731 +731 @@
                                             
             for src, w, d in zip(sources, weights, delays):
-                projection.connection_manager.connect(src, tgt, w, d)
+                projection._divergent_connect(src, tgt, w, d)
             
             self.progression(count)
@@ -776 +776 @@
             for tgt, src, w, d in zip(projection.post.local_cells, sources, weights, delays):
                 # the float is in case the values are of type numpy.float64, which NEST chokes on
-                projection.connection_manager.connect(src, [tgt], [float(w)], [float(d)])
+                projection._divergent_connect(src, [tgt], [float(w)], [float(d)])
                 self.progression(count)
                 count += 1
@@ -859 +859 @@
                     
         if len(targets) > 0:
-            self.projection.connection_manager.connect(src, targets.tolist(), weights, delays)
+            self.projection._divergent_connect(src, targets.tolist(), weights, delays)
     
     def connect(self, projection):
@@ -934 +934 @@
             # Connection-set with arity 2
             for (i, j, weight, delay) in c:
-                projection.connection_manager.connect (i, [j], weight, delay)
+                projection._divergent_connect (i, [j], weight, delay)
         elif CSAConnector.isConstant (self.weights) \
              and CSAConnector.isConstant (self.delays):
             # Mask with constant weights and delays
             for (i, j) in c:
-                projection.connection_manager.connect (i, [j], self.weights, self.delays)
+                projection._divergent_connect (i, [j], self.weights, self.delays)
         else:
             # Mask with weights and/or delays iterable
@@ -949 +949 @@
                 delays = CSAConnector.constantIterator (delays)
             for (i, j), weight, delay in zip (c, weights, delays):
-                projection.connection_manager.connect (i, [j], weight, delay)
+                projection._divergent_connect (i, [j], weight, delay)

trunk/src/connectors2.py

@@ -217 +217 @@
         
         if len(sources) > 0:
-            self.projection.connection_manager.convergent_connect(sources.tolist(), tgt, weights, delays)
+            self.projection._convergent_connect(sources.tolist(), tgt, weights, delays)
     
     
@@ -364 +364 @@
             src = projection.pre[tuple(src)]           
             tgt = projection.post[tuple(tgt)]
-            projection.connection_manager.connect(src, [tgt], weight, delay)
+            projection._divergent_connect(src, [tgt], weight, delay)
             self.progression(count)
             
@@ -487 +487 @@
                
             if len(targets) > 0:
-                projection.connection_manager.connect(src, targets.tolist(), weights, delays)
+                projection._divergent_connect(src, targets.tolist(), weights, delays)
             
             self.progression(count)
@@ -568 +568 @@
             delays  = delays_generator.get(n, distance_matrix, create)                                            
             if len(sources) > 0:
-                projection.connection_manager.convergent_connect(sources, tgt, weights, delays)
+                projection._convergent_connect(sources, tgt, weights, delays)
             self.progression(count)
             
@@ -616 +616 @@
                 
                 # the float is in case the values are of type numpy.float64, which NEST chokes on
-                projection.connection_manager.connect(src, [tgt], float(w), float(d))
+                projection._divergent_connect(src, [tgt], float(w), float(d))
                 self.progression(count)
                 count += 1
@@ -682 +682 @@
                     
         if len(targets) > 0:
-            self.projection.connection_manager.connect(src, targets.tolist(), weights, delays)
+            self.projection._divergent_connect(src, targets.tolist(), weights, delays)
     
     def connect(self, projection):

trunk/src/core.py

@@ -11 +11 @@
 from copy import copy, deepcopy
 import functools
+import warnings
 
 def is_listlike(obj):
@@ -275 +276 @@
         """Support instance methods."""
         return functools.partial(self.__call__, obj)
+
+class deprecated(object):
+    """
+    Decorator to mark functions/methods as deprecated. Emits a warning when
+    function is called and suggests a replacement.
+    """
+    
+    def __init__(self, replacement=''):
+        self.replacement = replacement
+        
+    def __call__(self, func):
+        def new_func(*args, **kwargs):
+            msg = "%s() is deprecated, and will be removed in a future release." % func.__name__
+            if self.replacement:
+                msg += " Use %s instead." % self.replacement
+            warnings.warn(msg, category=DeprecationWarning)
+            return func(*args, **kwargs)
+        new_func.__name__ = func.__name__
+        new_func.__doc__ = func.__doc__
+        new_func.__dict__.update(func.__dict__)
+        return new_func

trunk/src/moose/__init__.py

@@ -16 +16 @@
 import os.path
 from pyNN.moose import simulator
-from pyNN import common, recording
+from pyNN import common, recording, core
 common.simulator = simulator
 recording.simulator = simulator
@@ -149 +149 @@
         assert synapse_dynamics is None, "don't yet handle synapse dynamics"
         self.synapse_model = None
-        self.connection_manager = simulator.ConnectionManager(self.synapse_type,
-                                                              self.synapse_model,
-                                                              parent=self)
+        self.connections = []        
+        
         # Create connections
         method.connect(self)
-        self.connections = self.connection_manager
         Projection.nProj += 1
         
-        
+    def _divergent_connect(self, source, targets, weights, delays):
+        """
+        Connect a neuron to one or more other neurons with a static connection.
+        
+        `source`  -- the ID of the pre-synaptic cell.
+        `targets` -- a list/1D array of post-synaptic cell IDs, or a single ID.
+        `weight`  -- a list/1D array of connection weights, or a single weight.
+                     Must have the same length as `targets`.
+        `delays`  -- a list/1D array of connection delays, or a single delay.
+                     Must have the same length as `targets`.
+        """
+        if not isinstance(source, int) or source > simulator.state.gid_counter or source < 0:
+            errmsg = "Invalid source ID: %s (gid_counter=%d)" % (source, simulator.state.gid_counter)
+            raise errors.ConnectionError(errmsg)
+        if not core.is_listlike(targets):
+            targets = [targets]
+            
+        weights = weights*1000.0 # scale units
+        if isinstance(weights, float):
+            weights = [weights]
+        if isinstance(delays, float):
+            delays = [delays]
+        assert len(targets) > 0
+        # need to scale weights for appropriate units
+        for target, weight, delay in zip(targets, weights, delays):
+            if target.local:
+                if not isinstance(target, common.IDMixin):
+                    raise errors.ConnectionError("Invalid target ID: %s" % target)
+                if self.synapse_type == "excitatory":
+                    synapse_object = target._cell.esyn
+                elif self.synapse_type == "inhibitory":
+                    synapse_object = target._cell.isyn
+                else:
+                    synapse_object = getattr(target._cell, self.synapse_type)
+                source._cell.source.connect('event', synapse_object, 'synapse')
+                synapse_object.n_incoming_connections += 1
+                index = synapse_object.n_incoming_connections - 1
+                synapse_object.setWeight(index, weight)
+                synapse_object.setDelay(index, delay)
+                self.connections.append((source, target, index))
+                
 # ==============================================================================
 #   Low-level API for creating, connecting and recording from individual neurons

trunk/src/moose/simulator.py

@@ -96 +96 @@
             setattr(self._cell, name, val)
 
-
-class ConnectionManager(object):
-    """
-    Manage synaptic connections, providing methods for creating, listing,
-    accessing individual connections.
-    """
-
-    def __init__(self, synapse_type, synapse_model=None, parent=None):
-        """
-        Create a new ConnectionManager.
-        
-        `synapse_model` -- either None or 'Tsodyks-Markram'.
-        `parent` -- the parent `Projection`
-        """
-        assert parent is not None
-        self.connections = []
-        self.parent = parent
-        self.synapse_type = synapse_type
-        self.synapse_model = synapse_model
-    
-    def connect(self, source, targets, weights, delays):
-        """
-        Connect a neuron to one or more other neurons with a static connection.
-        
-        `source`  -- the ID of the pre-synaptic cell.
-        `targets` -- a list/1D array of post-synaptic cell IDs, or a single ID.
-        `weight`  -- a list/1D array of connection weights, or a single weight.
-                     Must have the same length as `targets`.
-        `delays`  -- a list/1D array of connection delays, or a single delay.
-                     Must have the same length as `targets`.
-        """
-        if not isinstance(source, int) or source > state.gid_counter or source < 0:
-            errmsg = "Invalid source ID: %s (gid_counter=%d)" % (source, state.gid_counter)
-            raise errors.ConnectionError(errmsg)
-        if not core.is_listlike(targets):
-            targets = [targets]
-            
-        weights = weights*1000.0 # scale units
-        if isinstance(weights, float):
-            weights = [weights]
-        if isinstance(delays, float):
-            delays = [delays]
-        assert len(targets) > 0
-        # need to scale weights for appropriate units
-        for target, weight, delay in zip(targets, weights, delays):
-            if target.local:
-                if not isinstance(target, common.IDMixin):
-                    raise errors.ConnectionError("Invalid target ID: %s" % target)
-                if self.synapse_type == "excitatory":
-                    synapse_object = target._cell.esyn
-                elif self.synapse_type == "inhibitory":
-                    synapse_object = target._cell.isyn
-                else:
-                    synapse_object = getattr(target._cell, self.synapse_type)
-                source._cell.source.connect('event', synapse_object, 'synapse')
-                synapse_object.n_incoming_connections += 1
-                index = synapse_object.n_incoming_connections - 1
-                synapse_object.setWeight(index, weight)
-                synapse_object.setDelay(index, delay)
-                self.connections.append((source, target, index))
-
 state = _State()  # a Singleton, so only a single instance ever exists
 del _State

trunk/src/nemo/__init__.py

@@ -191 +191 @@
         else:        
             self._plasticity_model = "static_synapse"
-                                        
-        self.connection_manager = simulator.ConnectionManager(self.synapse_type, self._plasticity_model, parent=self)
-        self.connections = self.connection_manager        
+     
+        self.synapse_model = self._plasticity_model
+        self._sources      = []
+        self._is_plastic   = False
+        if self.synapse_model is "stdp_synapse":
+            self._is_plastic = True
+        self._connections = None
+        
         method.connect(self)
+        
+    def __getitem__(self, i):
+        if isinstance(i, int):
+            if i < len(self):
+                return simulator.Connection(self.connections[i])
+            else:
+                raise IndexError("%d > %d" % (i, len(self)-1))
+        elif isinstance(i, slice):
+            if i.stop < len(self):
+                return [simulator.Connection(self.connections[j]) for j in range(i.start, i.stop, i.step or 1)]
+            else:
+                raise IndexError("%d > %d" % (i.stop, len(self)-1))
+    
+    def __len__(self):
+        """Return the number of connections on the local MPI node."""
+        return len(self.connections)
+
+    @property
+    def connections(self):
+        if self._connections is None:
+            self._connections = []
+            for source in numpy.unique(self.sources):
+                self._connections += list(simulator.state.net.get_synapses_from(source))
+        return self._connections
+
+    def _divergent_connect(self, source, targets, weights, delays):
+        """
+        Connect a neuron to one or more other neurons with a static connection.
+        
+        `source`  -- the ID of the pre-synaptic cell.
+        `targets` -- a list/1D array of post-synaptic cell IDs, or a single ID.
+        `weight`  -- a list/1D array of connection weights, or a single weight.
+                     Must have the same length as `targets`.
+        `delays`  -- a list/1D array of connection delays, or a single delay.
+                     Must have the same length as `targets`.
+        """
+        #print "connecting", source, "to", targets, "with weights", weights, "and delays", delays
+        if not core.is_listlike(targets):
+            targets = [targets]
+        if isinstance(weights, float):
+            weights = [weights]
+        if isinstance(delays, float):
+            delays = [delays]
+        assert len(targets) > 0
+        if not isinstance(source, common.IDMixin):
+            raise errors.ConnectionError("source should be an ID object, actually %s" % type(source))
+        for target in targets:
+            if not isinstance(target, common.IDMixin):
+                raise errors.ConnectionError("Invalid target ID: %s" % target)
+        assert len(targets) == len(weights) == len(delays), "%s %s %s" % (len(targets),len(weights),len(delays))
+        synapse_type = self.synapse_type or "excitatory"
+        delays = numpy.array(delays).astype(int).tolist()
+        if isinstance(weights, numpy.ndarray):
+            weights = weights.tolist()    
+        source   = int(source)        
+        synapses = simulator.state.net.add_synapse(source, targets, delays, weights, self.is_plastic)
+        self._sources.append(source)
+
+    def get(self, parameter_name, format, gather=True):
+        """
+        Get the values of a given attribute (weight or delay) for all
+        connections in this Projection.
+        
+        `parameter_name` -- name of the attribute whose values are wanted.
+        `format` -- "list" or "array". Array format implicitly assumes that all
+                    connections belong to a single Projection.
+        
+        Return a list or a 2D Numpy array. The array element X_ij contains the
+        attribute value for the connection from the ith neuron in the pre-
+        synaptic Population to the jth neuron in the post-synaptic Population,
+        if such a connection exists. If there are no such connections, X_ij will
+        be NaN.
+        """
+        if parameter_name not in ('weight', 'delay'):
+            raise Exception("Only weights and delays can be accessed by Nemo")
+
+        if format == 'list':
+            if parameter_name is "weight":
+                values = list(simulator.state.sim.get_synapse_weight(self.connections))
+            if parameter_name is "delay":
+                values = list(simulator.state.sim.get_synapse_delay(self.connections))
+        elif format == 'array':
+            value_arr = numpy.nan * numpy.ones((self.pre.size, self.post.size))
+            sources  = [i.source for i in self]
+            synapses = [i.synapse for i in self]
+            targets  = list(simulator.state.sim.get_targets(synapses))
+            addr     = self.pre.id_to_index(sources), self.post.id_to_index(targets)      
+            if parameter_name is "weight":
+                data = list(simulator.state.sim.get_weights(synapses))
+            if parameter_name is "delay":
+                data = list(simulator.state.sim.get_delays(synapses))          
+            for idx in xrange(len(data)):
+                address = addr[0][idx], addr[1][idx]
+                if numpy.isnan(value_arr[address]):
+                    value_arr[address] = data[idx]
+                else:
+                    value_arr[address] += data[idx]
+            values = value_arr
+        else:
+            raise Exception("format must be 'list' or 'array', actually '%s'" % format)
+        return values
 
     def saveConnections(self, file, gather=True, compatible_output=True):
@@ -205 +311 @@
             file = files.StandardTextFile(file, mode='w')
         
-        lines = numpy.empty((len(self.connection_manager), 4))        
-        lines[:,0] = [i.source for i in self.connection_manager]
-        lines[:,1] = [i.target for i in self.connection_manager]            
+        lines = numpy.empty((len(self), 4))        
+        lines[:,0] = [i.source for i in self]
+        lines[:,1] = [i.target for i in self]            
         if compatible_output:
             lines[:,0] = self.pre.id_to_index(lines[:, 0]) 
             lines[:,1] = self.post.id_to_index(lines[:, 1])    
-        synapses   = [i.synapse for i in self.connection_manager]  
+        synapses   = [i.synapse for i in self]  
         lines[:,2] = list(simulator.state.sim.get_weights(synapses))
         lines[:,3] = list(simulator.state.sim.get_delays(synapses))         

trunk/src/nemo/simulator.py

@@ -225 +225 @@
     weight = property(_get_weight, _set_weight)
     delay = property(_get_delay, _set_delay)
-    
-
-class ConnectionManager(object):
-    """
-    Manage synaptic connections, providing methods for creating, listing,
-    accessing individual connections.
-    """
-
-    def __init__(self, synapse_type, synapse_model=None, parent=None):
-        """
-        Create a new ConnectionManager.
-        
-        `synapse_type` -- the 'physiological type' of the synapse, e.g.
-                          'excitatory' or 'inhibitory',or any other key in the
-                          `synapses` attibute of the celltype class.
-        `synapse_model` -- not used. Present for consistency with other simulators.
-        `parent` -- the parent `Projection`, if any.
-        """
-        self.synapse_type      = synapse_type
-        self.synapse_model     = synapse_model
-        self.parent            = parent
-        self.sources           = []
-        self.is_plastic        = False
-        if self.synapse_model is "stdp_synapse":
-            self.is_plastic = True
-        self._connections = None
-        
-    def __getitem__(self, i):
-        if isinstance(i, int):
-            if i < len(self):
-                return Connection(self.connections[i])
-            else:
-                raise IndexError("%d > %d" % (i, len(self)-1))
-        elif isinstance(i, slice):
-            if i.stop < len(self):
-                return [Connection(self.connections[j]) for j in range(i.start, i.stop, i.step or 1)]
-            else:
-                raise IndexError("%d > %d" % (i.stop, len(self)-1))
-    
-    def __len__(self):
-        """Return the number of connections on the local MPI node."""
-        return len(self.connections)
-    
-    def __iter__(self):
-        """Return an iterator over all connections on the local MPI node."""
-        for i in range(len(self)):
-            yield self[i]
-    
-    @property
-    def connections(self):
-        if self._connections is None:
-            self._connections = []
-            for source in numpy.unique(self.sources):
-                self._connections += list(state.net.get_synapses_from(source))
-        return self._connections
-    
-    def connect(self, source, targets, weights, delays):
-        """
-        Connect a neuron to one or more other neurons with a static connection.
-        
-        `source`  -- the ID of the pre-synaptic cell.
-        `targets` -- a list/1D array of post-synaptic cell IDs, or a single ID.
-        `weight`  -- a list/1D array of connection weights, or a single weight.
-                     Must have the same length as `targets`.
-        `delays`  -- a list/1D array of connection delays, or a single delay.
-                     Must have the same length as `targets`.
-        """
-        #print "connecting", source, "to", targets, "with weights", weights, "and delays", delays
-        if not core.is_listlike(targets):
-            targets = [targets]
-        if isinstance(weights, float):
-            weights = [weights]
-        if isinstance(delays, float):
-            delays = [delays]
-        assert len(targets) > 0
-        if not isinstance(source, common.IDMixin):
-            raise errors.ConnectionError("source should be an ID object, actually %s" % type(source))
-        for target in targets:
-            if not isinstance(target, common.IDMixin):
-                raise errors.ConnectionError("Invalid target ID: %s" % target)
-        assert len(targets) == len(weights) == len(delays), "%s %s %s" % (len(targets),len(weights),len(delays))
-        synapse_type = self.synapse_type or "excitatory"
-        delays = numpy.array(delays).astype(int).tolist()
-        if isinstance(weights, numpy.ndarray):
-            weights = weights.tolist()    
-        source   = int(source)        
-        synapses = state.net.add_synapse(source, targets, delays, weights, self.is_plastic)
-        self.sources.append(source)
-        
-    def get(self, parameter_name, format):
-        """
-        Get the values of a given attribute (weight or delay) for all
-        connections in this manager.
-        
-        `parameter_name` -- name of the attribute whose values are wanted.
-        `format` -- "list" or "array". Array format implicitly assumes that all
-                    connections belong to a single Projection.
-        
-        Return a list or a 2D Numpy array. The array element X_ij contains the
-        attribute value for the connection from the ith neuron in the pre-
-        synaptic Population to the jth neuron in the post-synaptic Population,
-        if such a connection exists. If there are no such connections, X_ij will
-        be NaN.
-        """
-        if parameter_name not in ('weight', 'delay'):
-            raise Exception("Only weights and delays can be accessed by Nemo")
-
-        if format == 'list':
-            if parameter_name is "weight":
-                values = list(state.sim.get_synapse_weight(self.connections))
-            if parameter_name is "delay":
-                values = list(state.sim.get_synapse_delay(self.connections))
-        elif format == 'array':
-            value_arr = numpy.nan * numpy.ones((self.parent.pre.size, self.parent.post.size))
-            sources  = [i.source for i in self]
-            synapses = [i.synapse for i in self]
-            targets  = list(state.sim.get_targets(synapses))
-            addr     = self.parent.pre.id_to_index(sources), self.parent.post.id_to_index(targets)      
-            if parameter_name is "weight":
-                data = list(state.sim.get_weights(synapses))
-            if parameter_name is "delay":
-                data = list(state.sim.get_delays(synapses))          
-            for idx in xrange(len(data)):
-                address = addr[0][idx], addr[1][idx]
-                if numpy.isnan(value_arr[address]):
-                    value_arr[address] = data[idx]
-                else:
-                    value_arr[address] += data[idx]
-            values = value_arr
-        else:
-            raise Exception("format must be 'list' or 'array', actually '%s'" % format)
-        return values
-
-    def set(self, name, value):
-        """
-        Set connection attributes for all connections in this manager.
-        
-        `name`  -- attribute name
-        `value` -- the attribute numeric value, or a list/1D array of such
-                   values of the same length as the number of local connections,
-                   or a 2D array with the same dimensions as the connectivity
-                   matrix (as returned by `get(format='array')`).
-        """
-        if self.parent is None:
-            raise Exception("Only implemented for connections created via a Projection object, not using connect()")
-        pass         
+       
 
 # --- Initialization, and module attributes ------------------------------------

trunk/src/nest/__init__.py

@@ -133 +133 @@
                                          'min_delay': min_delay,
                                          'max_delay': max_delay})
-    simulator.connection_managers = []
     simulator.reset()
     
@@ -325 +324 @@
         else:        
             synapse_dynamics = NativeSynapseDynamics("static_synapse")
-        self.synapse_model = synapse_dynamics._get_nest_synapse_model("projection_%d" % Projection.nProj)
+        synapse_model = synapse_dynamics._get_nest_synapse_model("projection_%d" % Projection.nProj)
+        if synapse_model is None:
+            self.synapse_model = 'static_synapse_%s' % id(self)
+            nest.CopyModel('static_synapse', self.synapse_model)
+        else:
+            self.synapse_model = synapse_model
+        self._sources = []
+        self._connections = None
         Projection.nProj += 1
-        
-        self.connection_manager = simulator.ConnectionManager(self.synapse_type,
-                                                              self.synapse_model,
-                                                              parent=self)
-        
+               
         # Create connections
         method.connect(self)
-        self.connection_manager._set_tsodyks_params()
-        self.connections = self.connection_manager
-        
+    
+    def __getitem__(self, i):
+        """Return the `i`th connection on the local MPI node."""
+        if isinstance(i, int):
+            if i < len(self):
+                return simulator.Connection(self, i)
+            else:
+                raise IndexError("%d > %d" % (i, len(self)-1))
+        elif isinstance(i, slice):
+            if i.stop < len(self):
+                return [simulator.Connection(self, j) for j in range(i.start, i.stop, i.step or 1)]
+            else:
+                raise IndexError("%d > %d" % (i.stop, len(self)-1))
+
+    def __len__(self):
+        """Return the number of connections on the local MPI node."""
+        return nest.GetDefaults(self.synapse_model)['num_connections']
+
+    @property
+    def connections(self):
+        if self._connections is None:
+            self._sources = numpy.unique(self._sources)
+            self._connections = nest.FindConnections(self._sources, synapse_type=self.synapse_model)
+        return self._connections
+
+    def _set_tsodyks_params(self):
+        if 'tsodyks' in self.synapse_model: # there should be a better way to do this. In particular, if the synaptic time constant is changed
+                                            # after creating the Projection, tau_psc ought to be changed as well.
+            assert self.synapse_type in ('excitatory', 'inhibitory'), "only basic synapse types support Tsodyks-Markram connections"
+            logger.debug("setting tau_psc")
+            targets = nest.GetStatus(self.connections, 'target')            
+            if self.synapse_type == 'inhibitory':
+                param_name = self.post.local_cells[0].celltype.translations['tau_syn_I']['translated_name']
+            if self.synapse_type == 'excitatory':
+                param_name = self.post.local_cells[0].celltype.translations['tau_syn_E']['translated_name']
+            tau_syn = nest.GetStatus(targets, (param_name))
+            nest.SetStatus(self.connections, 'tau_psc', tau_syn) 
+
+    def _divergent_connect(self, source, targets, weights, delays):
+        """
+        Connect a neuron to one or more other neurons.
+        
+        `source`  -- the ID of the pre-synaptic cell.
+        `targets` -- a list/1D array of post-synaptic cell IDs, or a single ID.
+        `weight`  -- a list/1D array of connection weights, or a single weight.
+                     Must have the same length as `targets`.
+        `delays`  -- a list/1D array of connection delays, or a single delay.
+                     Must have the same length as `targets`.
+        """
+        # are we sure the targets are all on the current node?
+        if core.is_listlike(source):
+            assert len(source) == 1
+            source = source[0]
+        if not core.is_listlike(targets):
+            targets = [targets]
+        assert len(targets) > 0
+        
+        if self.synapse_type not in targets[0].celltype.synapse_types:
+            raise errors.ConnectionError("User gave synapse_type=%s, synapse_type must be one of: %s" % ( self.synapse_type, "'"+"', '".join(st for st in targets[0].celltype.synapse_types or ['*No connections supported*']))+"'" )
+        weights = numpy.array(weights)*1000.0 # weights should be in nA or uS, but iaf_neuron uses pA and iaf_cond_neuron uses nS.
+                                 # Using convention in this way is not ideal. We should
+                                 # be able to look up the units used by each model somewhere.
+        if self.synapse_type == 'inhibitory' and common.is_conductance(targets[0]):
+            weights = -1*weights # NEST wants negative values for inhibitory weights, even if these are conductances
+        if isinstance(weights, numpy.ndarray):
+            weights = weights.tolist()
+        elif isinstance(weights, float):
+            weights = [weights]
+        if isinstance(delays, numpy.ndarray):
+            delays = delays.tolist()
+        elif isinstance(delays, float):
+            delays = [delays]
+        
+        if targets[0].celltype.standard_receptor_type:
+            try:
+                nest.DivergentConnect([source], targets, weights, delays, self.synapse_model)            
+            except nest.NESTError, e:
+                raise errors.ConnectionError("%s. source=%s, targets=%s, weights=%s, delays=%s, synapse model='%s'" % (
+                                             e, source, targets, weights, delays, self.synapse_model))
+        else:
+            for target, w, d in zip(targets, weights, delays):
+                nest.Connect([source], [target], {'weight': w, 'delay': d, 'receptor_type': target.celltype.get_receptor_type(self.synapse_type)})
+        self._connections = None # reset the caching of the connection list, since this will have to be recalculated
+        self._sources.append(source)  
+
+    def _convergent_connect(self, sources, target, weights, delays):
+        """
+        Connect one or more neurons to a single post-synaptic neuron.
+        `sources` -- a list/1D array of pre-synaptic cell IDs, or a single ID.
+        `target`  -- the ID of the post-synaptic cell.
+        `weight`  -- a list/1D array of connection weights, or a single weight.
+                     Must have the same length as `targets`.
+        `delays`  -- a list/1D array of connection delays, or a single delay.
+                     Must have the same length as `targets`.
+        """
+        # are we sure the targets are all on the current node?
+        if core.is_listlike(target):
+            assert len(target) == 1
+            target = target[0]
+        if not core.is_listlike(sources):
+            sources = [sources]
+        assert len(sources) > 0, sources
+        if self.synapse_type not in ('excitatory', 'inhibitory', None):
+            raise errors.ConnectionError("synapse_type must be 'excitatory', 'inhibitory', or None (equivalent to 'excitatory')")
+        weights = numpy.array(weights)*1000.0# weights should be in nA or uS, but iaf_neuron uses pA and iaf_cond_neuron uses nS.
+                                 # Using convention in this way is not ideal. We should
+                                 # be able to look up the units used by each model somewhere.
+        if self.synapse_type == 'inhibitory' and common.is_conductance(target):
+            weights = -1*weights # NEST wants negative values for inhibitory weights, even if these are conductances
+        if isinstance(weights, numpy.ndarray):
+            weights = weights.tolist()
+        elif isinstance(weights, float):
+            weights = [weights]
+        if isinstance(delays, numpy.ndarray):
+            delays = delays.tolist()
+        elif isinstance(delays, float):
+            delays = [delays]
+               
+        try:
+            nest.ConvergentConnect(sources, [target], weights, delays, self.synapse_model)            
+        except nest.NESTError, e:
+            raise errors.ConnectionError("%s. sources=%s, target=%s, weights=%s, delays=%s, synapse model='%s'" % (
+                                         e, sources, target, weights, delays, self.synapse_model))
+        self._connections = None # reset the caching of the connection list, since this will have to be recalculated
+        self._sources.extend(sources)
+
+    def set(self, name, value):
+        """
+        Set connection attributes for all connections on the local MPI node.
+        
+        `name`  -- attribute name
+        
+        `value` -- the attribute numeric value, or a list/1D array of such
+                   values of the same length as the number of local connections,
+                   or a 2D array with the same dimensions as the connectivity
+                   matrix (as returned by `get(format='array')`).
+        """
+        if not (numpy.isscalar(value) or core.is_listlike(value)):
+            raise TypeError("Argument should be a numeric type (int, float...), a list, or a numpy array.")   
+        
+        if isinstance(value, numpy.ndarray) and len(value.shape) == 2:
+            value_list = []
+            connection_parameters = nest.GetStatus(self.connections, ('source', 'target'))
+            for conn in connection_parameters: 
+                addr = self.pre.id_to_index(conn['source']), self.post.id_to_index(conn['target'])
+                try:
+                    val = value[addr]
+                except IndexError, e:
+                    raise IndexError("%s. addr=%s" % (e, addr))
+                if numpy.isnan(val):
+                    raise Exception("Array contains no value for synapse from %d to %d" % (c.source, c.target))
+                else:
+                    value_list.append(val)
+            value = value_list
+        if core.is_listlike(value):
+            value = numpy.array(value)
+        else:
+            value = float(value)
+
+        if name == 'weight':
+            value *= 1000.0
+            if self.synapse_type == 'inhibitory' and common.is_conductance(self[0].target):
+                value *= -1 # NEST wants negative values for inhibitory weights, even if these are conductances
+        elif name == 'delay':
+            pass
+        else:
+            #translation = self.synapse_dynamics.reverse_translate({name: value})
+            #name, value = translation.items()[0]
+            translated_name = None
+            if self.synapse_dynamics.fast:
+                if name in self.synapse_dynamics.fast.translations:
+                    translated_name = self.synapse_dynamics.fast.translations[name]["translated_name"] # a hack
+            if translated_name is None:
+                if self.synapse_dynamics.slow:
+                    for component_name in "timing_dependence", "weight_dependence", "voltage_dependence":
+                        component = getattr(self.synapse_dynamics.slow, component_name)
+                        if component and name in component.translations:
+                            translated_name = component.translations[name]["translated_name"]
+                            break
+            if translated_name:
+                name = translated_name
+        
+        i = 0
+        try:
+            nest.SetStatus(self.connections, name, value)
+        except nest.NESTError, e:
+            n = 1
+            if hasattr(value, '__len__'):
+                n = len(value)
+            raise Exception("%s. Trying to set %d values." % (e, n))
 
     def saveConnections(self, file, gather=True, compatible_output=True):
@@ -348 +537 @@
             file = files.StandardTextFile(file, mode='w')
         
-        lines   = nest.GetStatus(self.connection_manager.connections, ('source', 'target', 'weight', 'delay'))  
+        lines   = nest.GetStatus(self.connections, ('source', 'target', 'weight', 'delay'))  
         
         if gather == True and num_processes() > 1:
@@ -386 +575 @@
         self.setDelays(rand_distr.next(len(self), mask_local=False))
 
+    def get(self, parameter_name, format, gather=True):
+        """
+        Get the values of a given attribute (weight or delay) for all
+        connections in this Projection.
+        
+        `parameter_name` -- name of the attribute whose values are wanted.
+        
+        `format` -- "list" or "array". Array format implicitly assumes that all
+                    connections belong to a single Projection.
+        
+        Return a list or a 2D Numpy array. The array element X_ij contains the
+        attribute value for the connection from the ith neuron in the pre-
+        synaptic Population to the jth neuron in the post-synaptic Population,
+        if a single such connection exists. If there are no such connections,
+        X_ij will be NaN. If there are multiple such connections, the summed
+        value will be given, which makes some sense for weights, but is
+        pretty meaningless for delays. 
+        """
+        
+        if parameter_name not in ('weight', 'delay'):
+            translated_name = None
+            if self.synapse_dynamics.fast and parameter_name in self.synapse_dynamics.fast.translations:
+                translated_name = self.synapse_dynamics.fast.translations[parameter_name]["translated_name"] # this is a hack that works because there are no units conversions
+            elif self.synapse_dynamics.slow:
+                for component_name in "timing_dependence", "weight_dependence", "voltage_dependence":
+                    component = getattr(self.synapse_dynamics.slow, component_name)
+                    if component and parameter_name in component.translations:
+                        translated_name = component.translations[parameter_name]["translated_name"]
+                        break
+            if translated_name:
+                parameter_name = translated_name
+            else:
+                raise Exception("synapse type does not have an attribute '%s', or else this attribute is not accessible." % parameter_name)
+        if format == 'list':
+            values = nest.GetStatus(self.connections, parameter_name)
+            if parameter_name == "weight":
+                values = [0.001*val for val in values]
+        elif format == 'array':
+            value_arr = numpy.nan * numpy.ones((self.pre.size, self.post.size))
+            connection_parameters = nest.GetStatus(self.connections, ('source', 'target', parameter_name))
+            for conn in connection_parameters: 
+                # (offset is always 0,0 for connections created with connect())
+                src, tgt, value = conn
+                addr = self.pre.id_to_index(src), self.post.id_to_index(tgt)
+                if numpy.isnan(value_arr[addr]):
+                    value_arr[addr] = value
+                else:
+                    value_arr[addr] += value
+            if parameter_name == 'weight':
+                value_arr *= 0.001
+                if self.synapse_type == 'inhibitory' and common.is_conductance(self[0].target):
+                    value_arr *= -1 # NEST uses negative values for inhibitory weights, even if these are conductances
+            values = value_arr
+        else:
+            raise Exception("format must be 'list' or 'array', actually '%s'" % format)
+        return values
+
 Space = space.Space
 

trunk/src/nest/connectors.py

@@ -92 +92 @@
         
         if len(sources) > 0:
-            self.projection.connection_manager.convergent_connect(sources.tolist(), tgt, weights, delays)
+            self.projection._convergent_connect(sources.tolist(), tgt, weights, delays)
     
     

trunk/src/nest/simulator.py

@@ -4 +4 @@
 implementation of the API.
 
-Functions and classes useable by the common implementation:
+Functions and classes usable by the common implementation:
 
 Functions:
-    create_cells()
     run()
 
@@ -13 +12 @@
     ID
     Recorder
-    ConnectionManager
     Connection
     
@@ -39 +37 @@
 recorder_list = []
 recording_devices = []
-connection_managers = []
 
 global net
@@ -211 +208 @@
     
 
-class ConnectionManager:
-    """
-    Manage synaptic connections, providing methods for creating, listing,
-    accessing individual connections.
-    """
-
-    def __init__(self, synapse_type, synapse_model=None, parent=None):
-        """
-        Create a new ConnectionManager.
-        
-        `synapse_type` -- the 'physiological type' of the synapse, e.g.
-                          'excitatory' or 'inhibitory'
-        `synapse_model` -- the NEST synapse model to be used for all connections
-                           created with this manager.
-        `parent` -- the parent `Projection`, if any.
-        """
-        global connection_managers
-        self.sources = []
-        if synapse_model is None:
-            self.synapse_model = 'static_synapse_%s' % id(self)
-            nest.CopyModel('static_synapse', self.synapse_model)
-        else:
-            self.synapse_model = synapse_model
-        self.synapse_type = synapse_type
-        self.parent = parent
-        if parent is not None:
-            assert parent.synapse_model == self.synapse_model
-        self._connections = None
-        connection_managers.append(self)
-
-    def __getitem__(self, i):
-        """Return the `i`th connection on the local MPI node."""
-        if isinstance(i, int):
-            if i < len(self):
-                return Connection(self, i)
-            else:
-                raise IndexError("%d > %d" % (i, len(self)-1))
-        elif isinstance(i, slice):
-            if i.stop < len(self):
-                return [Connection(self, j) for j in range(i.start, i.stop, i.step or 1)]
-            else:
-                raise IndexError("%d > %d" % (i.stop, len(self)-1))
-    
-    def __len__(self):
-        """Return the number of connections on the local MPI node."""
-        return nest.GetDefaults(self.synapse_model)['num_connections']
-    
-    def __iter__(self):
-        """Return an iterator over all connections on the local MPI node."""
-        for i in range(len(self)):
-            yield self[i]
-
-    @property
-    def connections(self):
-        if self._connections is None:
-            self.sources = numpy.unique(self.sources)
-            self._connections = nest.FindConnections(self.sources, synapse_type=self.synapse_model)
-        return self._connections
-    
-    def _set_tsodyks_params(self):
-        if 'tsodyks' in self.synapse_model: # there should be a better way to do this. In particular, if the synaptic time constant is changed
-                                            # after creating the Projection, tau_psc ought to be changed as well.
-            assert self.synapse_type in ('excitatory', 'inhibitory'), "only basic synapse types support Tsodyks-Markram connections"
-            logger.debug("setting tau_psc")
-            targets = nest.GetStatus(self.connections, 'target')            
-            if self.synapse_type == 'inhibitory':
-                param_name = self.parent.post.local_cells[0].celltype.translations['tau_syn_I']['translated_name']
-            if self.synapse_type == 'excitatory':
-                param_name = self.parent.post.local_cells[0].celltype.translations['tau_syn_E']['translated_name']
-            tau_syn = nest.GetStatus(targets, (param_name))
-            nest.SetStatus(self.connections, 'tau_psc', tau_syn)    
-
-    def connect(self, source, targets, weights, delays):
-        """
-        Connect a neuron to one or more other neurons.
-        
-        `source`  -- the ID of the pre-synaptic cell.
-        `targets` -- a list/1D array of post-synaptic cell IDs, or a single ID.
-        `weight`  -- a list/1D array of connection weights, or a single weight.
-                     Must have the same length as `targets`.
-        `delays`  -- a list/1D array of connection delays, or a single delay.
-                     Must have the same length as `targets`.
-        """
-        # are we sure the targets are all on the current node?
-        if core.is_listlike(source):
-            assert len(source) == 1
-            source = source[0]
-        if not core.is_listlike(targets):
-            targets = [targets]
-        assert len(targets) > 0
-        
-        if self.synapse_type not in targets[0].celltype.synapse_types:
-            raise errors.ConnectionError("User gave synapse_type=%s, synapse_type must be one of: %s" % ( self.synapse_type, "'"+"', '".join(st for st in targets[0].celltype.synapse_types or ['*No connections supported*']))+"'" )
-        weights = numpy.array(weights)*1000.0 # weights should be in nA or uS, but iaf_neuron uses pA and iaf_cond_neuron uses nS.
-                                 # Using convention in this way is not ideal. We should
-                                 # be able to look up the units used by each model somewhere.
-        if self.synapse_type == 'inhibitory' and common.is_conductance(targets[0]):
-            weights = -1*weights # NEST wants negative values for inhibitory weights, even if these are conductances
-        if isinstance(weights, numpy.ndarray):
-            weights = weights.tolist()
-        elif isinstance(weights, float):
-            weights = [weights]
-        if isinstance(delays, numpy.ndarray):
-            delays = delays.tolist()
-        elif isinstance(delays, float):
-            delays = [delays]
-        
-        if targets[0].celltype.standard_receptor_type:
-            try:
-                nest.DivergentConnect([source], targets, weights, delays, self.synapse_model)            
-            except nest.NESTError, e:
-                raise errors.ConnectionError("%s. source=%s, targets=%s, weights=%s, delays=%s, synapse model='%s'" % (
-                                             e, source, targets, weights, delays, self.synapse_model))
-        else:
-            for target, w, d in zip(targets, weights, delays):
-                nest.Connect([source], [target], {'weight': w, 'delay': d, 'receptor_type': target.celltype.get_receptor_type(self.synapse_type)})
-        self._connections = None # reset the caching of the connection list, since this will have to be recalculated
-        self.sources.append(source)
-
-    def convergent_connect(self, sources, target, weights, delays):
-        """
-        Connect one or more neurons to a single post-synaptic neuron.
-        `sources` -- a list/1D array of pre-synaptic cell IDs, or a single ID.
-        `target`  -- the ID of the post-synaptic cell.
-        `weight`  -- a list/1D array of connection weights, or a single weight.
-                     Must have the same length as `targets`.
-        `delays`  -- a list/1D array of connection delays, or a single delay.
-                     Must have the same length as `targets`.
-        """
-        # are we sure the targets are all on the current node?
-        if core.is_listlike(target):
-            assert len(target) == 1
-            target = target[0]
-        if not core.is_listlike(sources):
-            sources = [sources]
-        assert len(sources) > 0, sources
-        if self.synapse_type not in ('excitatory', 'inhibitory', None):
-            raise errors.ConnectionError("synapse_type must be 'excitatory', 'inhibitory', or None (equivalent to 'excitatory')")
-        weights = numpy.array(weights)*1000.0# weights should be in nA or uS, but iaf_neuron uses pA and iaf_cond_neuron uses nS.
-                                 # Using convention in this way is not ideal. We should
-                                 # be able to look up the units used by each model somewhere.
-        if self.synapse_type == 'inhibitory' and common.is_conductance(target):
-            weights = -1*weights # NEST wants negative values for inhibitory weights, even if these are conductances
-        if isinstance(weights, numpy.ndarray):
-            weights = weights.tolist()
-        elif isinstance(weights, float):
-            weights = [weights]
-        if isinstance(delays, numpy.ndarray):
-            delays = delays.tolist()
-        elif isinstance(delays, float):
-            delays = [delays]
-               
-        try:
-            nest.ConvergentConnect(sources, [target], weights, delays, self.synapse_model)            
-        except nest.NESTError, e:
-            raise errors.ConnectionError("%s. sources=%s, target=%s, weights=%s, delays=%s, synapse model='%s'" % (
-                                         e, sources, target, weights, delays, self.synapse_model))
-        self._connections = None # reset the caching of the connection list, since this will have to be recalculated
-        self.sources.extend(sources)
-    
-    def get(self, parameter_name, format):
-        """
-        Get the values of a given attribute (weight or delay) for all
-        connections in this manager.
-        
-        `parameter_name` -- name of the attribute whose values are wanted.
-        
-        `format` -- "list" or "array". Array format implicitly assumes that all
-                    connections belong to a single Projection.
-        
-        Return a list or a 2D Numpy array. The array element X_ij contains the
-        attribute value for the connection from the ith neuron in the pre-
-        synaptic Population to the jth neuron in the post-synaptic Population,
-        if a single such connection exists. If there are no such connections,
-        X_ij will be NaN. If there are multiple such connections, the summed
-        value will be given, which makes some sense for weights, but is
-        pretty meaningless for delays. 
-        """
-        
-        if parameter_name not in ('weight', 'delay'):
-            translated_name = None
-            if self.parent.synapse_dynamics.fast and parameter_name in self.parent.synapse_dynamics.fast.translations:
-                translated_name = self.parent.synapse_dynamics.fast.translations[parameter_name]["translated_name"] # this is a hack that works because there are no units conversions
-            elif self.parent.synapse_dynamics.slow:
-                for component_name in "timing_dependence", "weight_dependence", "voltage_dependence":
-                    component = getattr(self.parent.synapse_dynamics.slow, component_name)
-                    if component and parameter_name in component.translations:
-                        translated_name = component.translations[parameter_name]["translated_name"]
-                        break
-            if translated_name:
-                parameter_name = translated_name
-            else:
-                raise Exception("synapse type does not have an attribute '%s', or else this attribute is not accessible." % parameter_name)
-        if format == 'list':
-            values = nest.GetStatus(self.connections, parameter_name)
-            if parameter_name == "weight":
-                values = [0.001*val for val in values]
-        elif format == 'array':
-            value_arr = numpy.nan * numpy.ones((self.parent.pre.size, self.parent.post.size))
-            connection_parameters = nest.GetStatus(self.connections, ('source', 'target', parameter_name))
-            for conn in connection_parameters: 
-                # don't need to pass offset as arg, now we store the parent projection
-                # (offset is always 0,0 for connections created with connect())
-                src, tgt, value = conn
-                addr = self.parent.pre.id_to_index(src), self.parent.post.id_to_index(tgt)
-                if numpy.isnan(value_arr[addr]):
-                    value_arr[addr] = value
-                else:
-                    value_arr[addr] += value
-            if parameter_name == 'weight':
-                value_arr *= 0.001
-                if self.synapse_type == 'inhibitory' and common.is_conductance(self[0].target):
-                    value_arr *= -1 # NEST uses negative values for inhibitory weights, even if these are conductances
-            values = value_arr
-        else:
-            raise Exception("format must be 'list' or 'array', actually '%s'" % format)
-        return values
-    
-    def set(self, name, value):
-        """
-        Set connection attributes for all connections on the local MPI node.
-        
-        `name`  -- attribute name
-        
-        `value` -- the attribute numeric value, or a list/1D array of such
-                   values of the same length as the number of local connections,
-                   or a 2D array with the same dimensions as the connectivity
-                   matrix (as returned by `get(format='array')`).
-        """
-        if not (numpy.isscalar(value) or core.is_listlike(value)):
-            raise TypeError("Argument should be a numeric type (int, float...), a list, or a numpy array.")   
-        
-        if isinstance(value, numpy.ndarray) and len(value.shape) == 2:
-            value_list = []
-            connection_parameters = nest.GetStatus(self.connections, ('source', 'target'))
-            for conn in connection_parameters: 
-                addr = self.parent.pre.id_to_index(conn['source']), self.parent.post.id_to_index(conn['target'])
-                try:
-                    val = value[addr]
-                except IndexError, e:
-                    raise IndexError("%s. addr=%s" % (e, addr))
-                if numpy.isnan(val):
-                    raise Exception("Array contains no value for synapse from %d to %d" % (c.source, c.target))
-                else:
-                    value_list.append(val)
-            value = value_list
-        if core.is_listlike(value):
-            value = numpy.array(value)
-        else:
-            value = float(value)
-
-        if name == 'weight':
-            value *= 1000.0
-            if self.synapse_type == 'inhibitory' and common.is_conductance(self[0].target):
-                value *= -1 # NEST wants negative values for inhibitory weights, even if these are conductances
-        elif name == 'delay':
-            pass
-        else:
-            #translation = self.parent.synapse_dynamics.reverse_translate({name: value})
-            #name, value = translation.items()[0]
-            translated_name = None
-            if self.parent.synapse_dynamics.fast:
-                if name in self.parent.synapse_dynamics.fast.translations:
-                    translated_name = self.parent.synapse_dynamics.fast.translations[name]["translated_name"] # a hack
-            if translated_name is None:
-                if self.parent.synapse_dynamics.slow:
-                    for component_name in "timing_dependence", "weight_dependence", "voltage_dependence":
-                        component = getattr(self.parent.synapse_dynamics.slow, component_name)
-                        if component and name in component.translations:
-                            translated_name = component.translations[name]["translated_name"]
-                            break
-            if translated_name:
-                name = translated_name
-        
-        i = 0
-        try:
-            nest.SetStatus(self.connections, name, value)
-        except nest.NESTError, e:
-            n = 1
-            if hasattr(value, '__len__'):
-                n = len(value)
-            raise Exception("%s. Trying to set %d values." % (e, n))        
-
 # --- Initialization, and module attributes ------------------------------------
 

trunk/src/neuron/__init__.py

@@ -12 +12 @@
 from pyNN.random import *
 from pyNN.neuron import simulator
-from pyNN import common, recording as base_recording, space, __doc__
+from pyNN import common, core, recording as base_recording, space, __doc__
 common.simulator = simulator
 base_recording.simulator = simulator
@@ -205 +205 @@
             for cell in self.post:
                 cell._cell.set_Tsodyks_Markram_synapses(self.synapse_type, U, tau_rec, tau_facil, u0)
-            synapse_model = 'Tsodyks-Markram'
+            self.synapse_model = 'Tsodyks-Markram'
         else:
-            synapse_model = None
-                
-        self.connection_manager = simulator.ConnectionManager(self.synapse_type,
-                                                              synapse_model=synapse_model,
-                                                              parent=self)
-        self.connections = self.connection_manager        
+            self.synapse_model = None
+        self.connections = []
+        
         ## Create connections
         method.connect(self)
@@ -243 +240 @@
         Projection.nProj += 1           
     
+    def __getitem__(self, i):
+        """Return the `i`th connection on the local MPI node."""
+        if isinstance(i, int):
+            if i < len(self):
+                return self.connections[i]
+            else:
+                raise IndexError("%d > %d" % (i, len(self)-1))
+        elif isinstance(i, slice):
+            if i.stop < len(self):
+                return [self.connections[j] for j in range(*i.indices(i.stop))]
+            else:
+                raise IndexError("%d > %d" % (i.stop, len(self)-1))
+    
+    def __len__(self):
+        """Return the number of connections on the local MPI node."""
+        return len(self.connections)
+    
+    def _resolve_synapse_type(self):
+        if self.synapse_type is None:
+            self.synapse_type = weight>=0 and 'excitatory' or 'inhibitory'
+        if self.synapse_model == 'Tsodyks-Markram' and 'TM' not in self.synapse_type:
+            self.synapse_type += '_TM' 
+    
+    def _divergent_connect(self, source, targets, weights, delays):
+        """
+        Connect a neuron to one or more other neurons with a static connection.
+        
+        `source`  -- the ID of the pre-synaptic cell.
+        `targets` -- a list/1D array of post-synaptic cell IDs, or a single ID.
+        `weight`  -- a list/1D array of connection weights, or a single weight.
+                     Must have the same length as `targets`.
+        `delays`  -- a list/1D array of connection delays, or a single delay.
+                     Must have the same length as `targets`.
+        """
+        if not isinstance(source, int) or source > simulator.state.gid_counter or source < 0:
+            errmsg = "Invalid source ID: %s (gid_counter=%d)" % (source, simulator.state.gid_counter)
+            raise errors.ConnectionError(errmsg)
+        if not core.is_listlike(targets):
+            targets = [targets]
+        if isinstance(weights, float):
+            weights = [weights]
+        if isinstance(delays, float):
+            delays = [delays]
+        assert len(targets) > 0
+        for target in targets:
+            if not isinstance(target, common.IDMixin):
+                raise errors.ConnectionError("Invalid target ID: %s" % target)
+              
+        assert len(targets) == len(weights) == len(delays), "%s %s %s" % (len(targets), len(weights), len(delays))
+        self._resolve_synapse_type()
+        for target, weight, delay in zip(targets, weights, delays):
+            if target.local:
+                if "." in self.synapse_type: 
+                    section, synapse_type = self.synapse_type.split(".") 
+                    synapse_object = getattr(getattr(target._cell, section), synapse_type) 
+                else: 
+                    synapse_object = getattr(target._cell, self.synapse_type) 
+                nc = simulator.state.parallel_context.gid_connect(int(source), synapse_object)
+                nc.weight[0] = weight
+                
+                # if we have a mechanism (e.g. from 9ML) that includes multiple
+                # synaptic channels, need to set nc.weight[1] here
+                if nc.wcnt() > 1 and hasattr(target._cell, "type"):
+                    nc.weight[1] = target._cell.type.synapse_types.index(self.synapse_type)
+                nc.delay  = delay
+                # nc.threshold is supposed to be set by ParallelContext.threshold, called in _build_cell(), above, but this hasn't been tested
+                self.connections.append(simulator.Connection(source, target, nc))
+
+    def _convergent_connect(self, sources, target, weights, delays):
+        """
+        Connect a neuron to one or more other neurons with a static connection.
+        
+        `sources`  -- a list/1D array of pre-synaptic cell IDs, or a single ID.
+        `target` -- the ID of the post-synaptic cell.
+        `weight`  -- a list/1D array of connection weights, or a single weight.
+                     Must have the same length as `targets`.
+        `delays`  -- a list/1D array of connection delays, or a single delay.
+                     Must have the same length as `targets`.
+        """
+        if not isinstance(target, int) or target > simulator.state.gid_counter or target < 0:
+            errmsg = "Invalid target ID: %s (gid_counter=%d)" % (target, simulator.state.gid_counter)
+            raise errors.ConnectionError(errmsg)
+        if not core.is_listlike(sources):
+            sources = [sources]
+        if isinstance(weights, float):
+            weights = [weights]
+        if isinstance(delays, float):
+            delays = [delays]
+        assert len(sources) > 0
+        for source in sources:
+            if not isinstance(source, common.IDMixin):
+                raise errors.ConnectionError("Invalid source ID: %s" % source)
+              
+        assert len(sources) == len(weights) == len(delays), "%s %s %s" % (len(sources),len(weights),len(delays))
+                
+        if target.local:
+            for source, weight, delay in zip(sources, weights, delays):
+                if self.synapse_type is None:
+                    self.synapse_type = weight >= 0 and 'excitatory' or 'inhibitory'
+                if self.synapse_model == 'Tsodyks-Markram' and 'TM' not in self.synapse_type:
+                    self.synapse_type += '_TM'
+                synapse_object = getattr(target._cell, self.synapse_type)  
+                nc = simulator.state.parallel_context.gid_connect(int(source), synapse_object)
+                nc.weight[0] = weight
+                nc.delay  = delay
+                # nc.threshold is supposed to be set by ParallelContext.threshold, called in _build_cell(), above, but this hasn't been tested
+                self.connections.append(Connection(source, target, nc))
+
+    
     # --- Methods for setting connection parameters ----------------------------
     
+    def set(self, name, value):
+        """
+        Set connection attributes for all connections on the local MPI node.
+        
+        `name`  -- attribute name
+        `value` -- the attribute numeric value, or a list/1D array of such
+                   values of the same length as the number of local connections,
+                   or a 2D array with the same dimensions as the connectivity
+                   matrix (as returned by `get(format='array')`).
+        """
+        if numpy.isscalar(value):
+            for c in self:
+                setattr(c, name, value)
+        elif isinstance(value, numpy.ndarray) and len(value.shape) == 2:
+            for c in self.connections:
+                addr = (self.pre.id_to_index(c.source), self.post.id_to_index(c.target))
+                try:
+                    val = value[addr]
+                except IndexError, e:
+                    raise IndexError("%s. addr=%s" % (e, addr))
+                if numpy.isnan(val):
+                    raise Exception("Array contains no value for synapse from %d to %d" % (c.source, c.target))
+                else:
+                    setattr(c, name, val)
+        elif core.is_listlike(value):
+            for c,val in zip(self.connections, value):
+                setattr(c, name, val)
+        else:
+            raise TypeError("Argument should be a numeric type (int, float...), a list, or a numpy array.")
+
     def randomizeWeights(self, rand_distr):
         """
@@ -277 +413 @@
         self.setDelays(rarr)
 
+    def get(self, parameter_name, format, gather=True):
+        """
+        Get the values of a given attribute (weight, delay, etc) for all
+        connections on the local MPI node.
+        
+        `parameter_name` -- name of the attribute whose values are wanted.
+        `format` -- "list" or "array". Array format implicitly assumes that all
+                    connections belong to a single Projection.
+        
+        Return a list or a 2D Numpy array. The array element X_ij contains the
+        attribute value for the connection from the ith neuron in the pre-
+        synaptic Population to the jth neuron in the post-synaptic Population,
+        if a single such connection exists. If there are no such connections,
+        X_ij will be NaN. If there are multiple such connections, the summed
+        value will be given, which makes some sense for weights, but is
+        pretty meaningless for delays. 
+        """
+        if format == 'list':
+            values = [getattr(c, parameter_name) for c in self.connections]
+        elif format == 'array':
+            values = numpy.nan * numpy.ones((self.pre.size, self.post.size))
+            for c in self.connections:
+                value = getattr(c, parameter_name)
+                addr = (self.pre.id_to_index(c.source), self.post.id_to_index(c.target))
+                if numpy.isnan(values[addr]):
+                    values[addr] = value
+                else:
+                    values[addr] += value
+        else:
+            raise Exception("format must be 'list' or 'array'")
+        return values
+    
 
 Space = space.Space

trunk/src/neuron/simulator.py

@@ -7 +7 @@
 
 Functions:
-    create_cells()
     reset()
     run()
@@ -15 +14 @@
     ID
     Recorder
-    ConnectionManager
     Connection
     
@@ -42 +40 @@
 nrn_dll_loaded = []
 recorder_list = []
-connection_managers = []
 gid_sources = []
 logger = logging.getLogger("PyNN")
@@ -167 +164 @@
 
     def clear(self):
-        global connection_managers, gid_sources
+        global gid_sources
         self.parallel_context.gid_clear()
         gid_sources = []
@@ -173 +170 @@
         self.running = False
         h.plastic_connections = []
-        connection_managers = []
 
 def reset():
@@ -366 +362 @@
 
 
-
-class ConnectionManager(object):
-    """
-    Manage synaptic connections, providing methods for creating, listing,
-    accessing individual connections.
-    """
-
-    def __init__(self, synapse_type, synapse_model=None, parent=None):
-        """
-        Create a new ConnectionManager.
-        
-        `synapse_model` -- either None or 'Tsodyks-Markram'.
-        `parent` -- the parent `Projection`
-        """
-        global connection_managers
-        assert parent is not None
-        self.connections = []
-        self.parent = parent
-        self.synapse_type = synapse_type
-        self.synapse_model = synapse_model
-        connection_managers.append(self)
-        
-    def __getitem__(self, i):
-        """Return the `i`th connection on the local MPI node."""
-        if isinstance(i, int):
-            if i < len(self):
-                return self.connections[i]
-            else:
-                raise IndexError("%d > %d" % (i, len(self)-1))
-        elif isinstance(i, slice):
-            if i.stop < len(self):
-                return [self.connections[j] for j in range(*i.indices(i.stop))]
-            else:
-                raise IndexError("%d > %d" % (i.stop, len(self)-1))
-    
-    def __len__(self):
-        """Return the number of connections on the local MPI node."""
-        return len(self.connections)
-    
-    def __iter__(self):
-        """Return an iterator over all connections on the local MPI node."""
-        return iter(self.connections)
-    
-    def _resolve_synapse_type(self):
-        if self.synapse_type is None:
-            self.synapse_type = weight>=0 and 'excitatory' or 'inhibitory'
-        if self.synapse_model == 'Tsodyks-Markram' and 'TM' not in self.synapse_type:
-            self.synapse_type += '_TM'  
-    
-    def connect(self, source, targets, weights, delays):
-        """
-        Connect a neuron to one or more other neurons with a static connection.
-        
-        `source`  -- the ID of the pre-synaptic cell.
-        `targets` -- a list/1D array of post-synaptic cell IDs, or a single ID.
-        `weight`  -- a list/1D array of connection weights, or a single weight.
-                     Must have the same length as `targets`.
-        `delays`  -- a list/1D array of connection delays, or a single delay.
-                     Must have the same length as `targets`.
-        """
-        if not isinstance(source, int) or source > state.gid_counter or source < 0:
-            errmsg = "Invalid source ID: %s (gid_counter=%d)" % (source, state.gid_counter)
-            raise errors.ConnectionError(errmsg)
-        if not core.is_listlike(targets):
-            targets = [targets]
-        if isinstance(weights, float):
-            weights = [weights]
-        if isinstance(delays, float):
-            delays = [delays]
-        assert len(targets) > 0
-        for target in targets:
-            if not isinstance(target, common.IDMixin):
-                raise errors.ConnectionError("Invalid target ID: %s" % target)
-              
-        assert len(targets) == len(weights) == len(delays), "%s %s %s" % (len(targets), len(weights), len(delays))
-        self._resolve_synapse_type()
-        for target, weight, delay in zip(targets, weights, delays):
-            if target.local:
-                if "." in self.synapse_type: 
-                    section, synapse_type = self.synapse_type.split(".") 
-                    synapse_object = getattr(getattr(target._cell, section), synapse_type) 
-                else: 
-                    synapse_object = getattr(target._cell, self.synapse_type) 
-                nc = state.parallel_context.gid_connect(int(source), synapse_object)
-                nc.weight[0] = weight
-                
-                # if we have a mechanism (e.g. from 9ML) that includes multiple
-                # synaptic channels, need to set nc.weight[1] here
-                if nc.wcnt() > 1 and hasattr(target._cell, "type"):
-                    nc.weight[1] = target._cell.type.synapse_types.index(self.synapse_type)
-                nc.delay  = delay
-                # nc.threshold is supposed to be set by ParallelContext.threshold, called in _build_cell(), above, but this hasn't been tested
-                self.connections.append(Connection(source, target, nc))
-
-    def convergent_connect(self, sources, target, weights, delays):
-        """
-        Connect a neuron to one or more other neurons with a static connection.
-        
-        `sources`  -- a list/1D array of pre-synaptic cell IDs, or a single ID.
-        `target` -- the ID of the post-synaptic cell.
-        `weight`  -- a list/1D array of connection weights, or a single weight.
-                     Must have the same length as `targets`.
-        `delays`  -- a list/1D array of connection delays, or a single delay.
-                     Must have the same length as `targets`.
-        """
-        if not isinstance(target, int) or target > state.gid_counter or target < 0:
-            errmsg = "Invalid target ID: %s (gid_counter=%d)" % (target, state.gid_counter)
-            raise errors.ConnectionError(errmsg)
-        if not core.is_listlike(sources):
-            sources = [sources]
-        if isinstance(weights, float):
-            weights = [weights]
-        if isinstance(delays, float):
-            delays = [delays]
-        assert len(sources) > 0
-        for source in sources:
-            if not isinstance(source, common.IDMixin):
-                raise errors.ConnectionError("Invalid source ID: %s" % source)
-              
-        assert len(sources) == len(weights) == len(delays), "%s %s %s" % (len(sources),len(weights),len(delays))
-                
-        if target.local:
-            for source, weight, delay in zip(sources, weights, delays):
-                if self.synapse_type is None:
-                    self.synapse_type = weight >= 0 and 'excitatory' or 'inhibitory'
-                if self.synapse_model == 'Tsodyks-Markram' and 'TM' not in self.synapse_type:
-                    self.synapse_type += '_TM'
-                synapse_object = getattr(target._cell, self.synapse_type)  
-                nc = state.parallel_context.gid_connect(int(source), synapse_object)
-                nc.weight[0] = weight
-                nc.delay  = delay
-                # nc.threshold is supposed to be set by ParallelContext.threshold, called in _build_cell(), above, but this hasn't been tested
-                self.connections.append(Connection(source, target, nc))
-
-    def get(self, parameter_name, format):
-        """
-        Get the values of a given attribute (weight, delay, etc) for all
-        connections on the local MPI node.
-        
-        `parameter_name` -- name of the attribute whose values are wanted.
-        `format` -- "list" or "array". Array format implicitly assumes that all
-                    connections belong to a single Projection.
-        
-        Return a list or a 2D Numpy array. The array element X_ij contains the
-        attribute value for the connection from the ith neuron in the pre-
-        synaptic Population to the jth neuron in the post-synaptic Population,
-        if a single such connection exists. If there are no such connections,
-        X_ij will be NaN. If there are multiple such connections, the summed
-        value will be given, which makes some sense for weights, but is
-        pretty meaningless for delays. 
-        """
-        if format == 'list':
-            values = [getattr(c, parameter_name) for c in self.connections]
-        elif format == 'array':
-            values = numpy.nan * numpy.ones((self.parent.pre.size, self.parent.post.size))
-            for c in self.connections:
-                value = getattr(c, parameter_name)
-                addr = (self.parent.pre.id_to_index(c.source), self.parent.post.id_to_index(c.target))
-                if numpy.isnan(values[addr]):
-                    values[addr] = value
-                else:
-                    values[addr] += value
-        else:
-            raise Exception("format must be 'list' or 'array'")
-        return values
-
-    def set(self, name, value):
-        """
-        Set connection attributes for all connections on the local MPI node.
-        
-        `name`  -- attribute name
-        `value` -- the attribute numeric value, or a list/1D array of such
-                   values of the same length as the number of local connections,
-                   or a 2D array with the same dimensions as the connectivity
-                   matrix (as returned by `get(format='array')`).
-        """
-        if numpy.isscalar(value):
-            for c in self:
-                setattr(c, name, value)
-        elif isinstance(value, numpy.ndarray) and len(value.shape) == 2:
-            for c in self.connections:
-                addr = (self.parent.pre.id_to_index(c.source), self.parent.post.id_to_index(c.target))
-                try:
-                    val = value[addr]
-                except IndexError, e:
-                    raise IndexError("%s. addr=%s" % (e, addr))
-                if numpy.isnan(val):
-                    raise Exception("Array contains no value for synapse from %d to %d" % (c.source, c.target))
-                else:
-                    setattr(c, name, val)
-        elif core.is_listlike(value):
-            for c,val in zip(self.connections, value):
-                setattr(c, name, val)
-        else:
-            raise TypeError("Argument should be a numeric type (int, float...), a list, or a numpy array.")
-
-
 # --- Initialization, and module attributes ------------------------------------
 

trunk/src/pcsim/__init__.py

@@ -254 +254 @@
             - the ID of the last cell created
         """
-        global net
         assert n > 0, 'n must be a positive integer'
         
@@ -419 +418 @@
     
     nProj = 0
+    synapse_target_ids = { 'excitatory': 1, 'inhibitory': 2 }
     
     def __init__(self, presynaptic_population, postsynaptic_population,
@@ -614 +614 @@
         ##self.synapse_type = self.syn_factory #target or 'excitatory'
         self.synapse_type = target or 'excitatory'
-        self.connection_manager = simulator.ConnectionManager(self.syn_factory, parent=self)
-        self.connections = self.connection_manager
+        self.connections = []
         method.connect(self)
         Projection.nProj += 1        
@@ -622 +621 @@
     # useful when we start (re-)optimizing the implementation
 
-    ##def __len__(self):
-    ##    """Return the total number of connections."""
-    ##    return self.pcsim_projection.size()
+    def __len__(self):
+        """Return the total number of connections."""
+        ###return self.pcsim_projection.size()
+        return len(self.connections)
     
     #def __getitem__(self, n):
     #    return self.pcsim_projection[n]
-
-     
+    def __getitem__(self, i):
+        """Return the `i`th connection on the local MPI node."""
+        #if self.parent:
+        #    if self.parent.is_conductance:
+        #        A = 1e6 # S --> uS
+        #    else:
+        #        A = 1e9 # A --> nA
+        #    return Connection(self.parent.pcsim_projection.object(i), A)
+        #else:
+        return self.connections[i]
+    
+    def _divergent_connect(self, source, targets, weights, delays):
+        """
+        Connect a neuron to one or more other neurons with a static connection.
+        
+        `source`  -- the ID of the pre-synaptic cell.
+        `targets` -- a list/1D array of post-synaptic cell IDs, or a single ID.
+        `weight`  -- a list/1D array of connection weights, or a single weight.
+                     Must have the same length as `targets`.
+        `delays`  -- a list/1D array of connection delays, or a single delay.
+                     Must have the same length as `targets`.
+        """
+        if not isinstance(source, (int, long)) or source < 0:
+            errmsg = "Invalid source ID: %s" % source
+            raise errors.ConnectionError(errmsg)
+        if not core.is_listlike(targets):
+            targets = [targets]
+        if isinstance(weights, float):
+            weights = [weights]
+        if isinstance(delays, float):
+            delays = [delays]
+        assert len(targets) > 0
+        for target in targets:
+            if not isinstance(target, common.IDMixin):
+                raise errors.ConnectionError("Invalid target ID: %s" % target)
+        assert len(targets) == len(weights) == len(delays), "%s %s %s" % (len(targets),len(weights),len(delays))
+        if common.is_conductance(targets[0]):
+            weight_scale_factor = 1e-6 # Convert from µS to S  
+        else:
+            weight_scale_factor = 1e-9 # Convert from nA to A
+        
+        synapse_type = self.syn_factory or "excitatory"
+        if isinstance(synapse_type, basestring):
+            syn_target_id = Projection.synapse_target_ids[synapse_type]
+            syn_factory = pypcsim.SimpleScalingSpikingSynapse(
+                              syn_target_id, weights[0], delays[0])
+        elif isinstance(synapse_type, pypcsim.SimObject):
+            syn_factory = synapse_type
+        else:
+            raise errors.ConnectionError("synapse_type must be a string or a PCSIM synapse factory. Actual type is %s" % type(synapse_type))
+        for target, weight, delay in zip(targets, weights, delays):
+            syn_factory.W = weight*weight_scale_factor
+            syn_factory.delay = delay*0.001 # ms --> s
+            try:
+                c = simulator.net.connect(source, target, syn_factory)
+            except RuntimeError, e:
+                raise errors.ConnectionError(e)
+            if target.local:
+                self.connections.append(simulator.Connection(source, target, simulator.net.object(c), 1.0/weight_scale_factor))
+    
+    def _convergent_connect(self, sources, target, weights, delays):
+        """
+        Connect a neuron to one or more other neurons with a static connection.
+        
+        `sources`  -- a list/1D array of pre-synaptic cell IDs, or a single ID.
+        `target` -- the ID of the post-synaptic cell.
+        `weight`  -- a list/1D array of connection weights, or a single weight.
+                     Must have the same length as `targets`.
+        `delays`  -- a list/1D array of connection delays, or a single delay.
+                     Must have the same length as `targets`.
+        """
+        if not isinstance(target, (int, long)) or target < 0:
+            errmsg = "Invalid target ID: %s" % target
+            raise errors.ConnectionError(errmsg)
+        if not core.is_listlike(sources):
+            sources = [sources]
+        if isinstance(weights, float):
+            weights = [weights]
+        if isinstance(delays, float):
+            delays = [delays]
+        assert len(sources) > 0
+        for source in sources:
+            if not isinstance(source, common.IDMixin):
+                raise errors.ConnectionError("Invalid source ID: %s" % source)
+        assert len(sources) == len(weights) == len(delays), "%s %s %s" % (len(sources),len(weights),len(delays))
+        if common.is_conductance(target):
+            weight_scale_factor = 1e-6 # Convert from µS to S  
+        else:
+            weight_scale_factor = 1e-9 # Convert from nA to A
+        
+        synapse_type = self.syn_factory or "excitatory"
+        if isinstance(synapse_type, basestring):
+            syn_target_id = Projection.synapse_target_ids[synapse_type]
+            syn_factory = pypcsim.SimpleScalingSpikingSynapse(
+                              syn_target_id, weights[0], delays[0])
+        elif isinstance(synapse_type, pypcsim.SimObject):
+            syn_factory = synapse_type
+        else:
+            raise errors.ConnectionError("synapse_type must be a string or a PCSIM synapse factory. Actual type is %s" % type(synapse_type))
+        for source, weight, delay in zip(sources, weights, delays):
+            syn_factory.W = weight*weight_scale_factor
+            syn_factory.delay = delay*0.001 # ms --> s
+            try:
+                c = simulator.net.connect(source, target, syn_factory)
+            except RuntimeError, e:
+                raise errors.ConnectionError(e)
+            if target.local:
+                self.connections.append(simulator.Connection(source, target, simulator.net.object(c), 1.0/weight_scale_factor))  
+    
     # --- Methods for setting connection parameters ----------------------------
-    
+
+    def set(self, name, value):
+        """
+        Set connection attributes for all connections on the local MPI node.
+        
+        `name`  -- attribute name
+        `value` -- the attribute numeric value, or a list/1D array of such
+                   values of the same length as the number of local connections,
+                   or a 2D array with the same dimensions as the connectivity
+                   matrix (as returned by `get(format='array')`)
+        """
+        if numpy.isscalar(value):
+            for c in self:
+                setattr(c, name, value)
+        elif isinstance(value, numpy.ndarray) and len(value.shape) == 2:
+            for c in self.connections:
+                addr = (self.pre.id_to_index(c.source), self.post.id_to_index(c.target))
+                try:
+                    val = value[addr]
+                except IndexError, e:
+                    raise IndexError("%s. addr=%s" % (e, addr))
+                if numpy.isnan(val):
+                    raise Exception("Array contains no value for synapse from %d to %d" % (c.source, c.target))
+                else:
+                    setattr(c, name, val)
+        elif core.is_listlike(value):
+            for c,val in zip(self.connections, value):
+                setattr(c, name, val)
+        else:
+            raise TypeError("Argument should be a numeric type (int, float...), a list, or a numpy array.")
+
     ##def setWeights(self, w):
     ##    """
@@ -684 +821 @@
     ##    for i in range(len(self)):
     ##        simulator.net.object(self.pcsim_projection[i]).delay = delays[i]
-    ##
+    
+    def get(self, parameter_name, format, gather=True):
+        """
+        Get the values of a given attribute (weight, delay, etc) for all
+        connections on the local MPI node.
+        
+        `parameter_name` -- name of the attribute whose values are wanted.
+        `format` -- "list" or "array". Array format implicitly assumes that all
+                    connections belong to a single Projection.
+        
+        Return a list or a 2D Numpy array. The array element X_ij contains the
+        attribute value for the connection from the ith neuron in the pre-
+        synaptic Population to the jth neuron in the post-synaptic Population,
+        if such a connection exists. If there are no such connections, X_ij will
+        be NaN.
+        """
+        if format == 'list':
+            values = [getattr(c, parameter_name) for c in self]
+        elif format == 'array':
+            values = numpy.nan * numpy.ones((self.pre.size, self.post.size))
+            for c in self:
+                addr = (self.pre.id_to_index(c.source), self.post.id_to_index(c.target))
+                values[addr] = getattr(c, parameter_name)
+        else:
+            raise Exception("format must be 'list' or 'array'")
+        return values        
+    
+    
     ##def getWeights(self, format='list', gather=True):
     ##    """

trunk/src/pcsim/simulator.py

@@ -7 +7 @@
 
 Functions:
-    create_cells()
     reset()
 
@@ -13 +12 @@
     ID
     Recorder
-    ConnectionManager
     Connection
     
@@ -36 +34 @@
 
 recorder_list = []
-connection_managers = []
 STATE_VARIABLE_MAP = {"v": ("Vinit", 1e-3)}
 
@@ -197 +194 @@
     
 
-class ConnectionManager(object):
-    """
-    Manage synaptic connections, providing methods for creating, listing,
-    accessing individual connections.
-    """
-
-    synapse_target_ids = { 'excitatory': 1, 'inhibitory': 2 }
-
-    def __init__(self, synapse_type, synapse_model=None, parent=None):
-        """
-        Create a new ConnectionManager.
-        
-        `synapse_type` -- the 'physiological type' of the synapse, e.g.
-                          'excitatory' or 'inhibitory', or a PCSIM synapse
-                          factory.
-        `synapse_model` -- not used. Present for consistency with other simulators.
-        `parent` -- the parent `Projection`, if any.
-        """
-        global connection_managers
-        self.synapse_type = synapse_type
-        self.connections = []
-        self.parent = parent
-        connection_managers.append(self)
-        self.parent = parent
-        #if parent is None:
-        self.connections = []
-
-    def __getitem__(self, i):
-        """Return the `i`th connection on the local MPI node."""
-        #if self.parent:
-        #    if self.parent.is_conductance:
-        #        A = 1e6 # S --> uS
-        #    else:
-        #        A = 1e9 # A --> nA
-        #    return Connection(self.parent.pcsim_projection.object(i), A)
-        #else:
-        return self.connections[i]
-    
-    def __len__(self):
-        """Return the number of connections on the local MPI node."""
-        #if self.parent:
-        #    return self.parent.pcsim_projection.size()
-        #else:
-        return len(self.connections)
-    
-    def __iter__(self):
-        """Return an iterator over all connections on the local MPI node."""
-        for i in range(len(self)):
-            yield self[i]
-    
-    def connect(self, source, targets, weights, delays):
-        """
-        Connect a neuron to one or more other neurons with a static connection.
-        
-        `source`  -- the ID of the pre-synaptic cell.
-        `targets` -- a list/1D array of post-synaptic cell IDs, or a single ID.
-        `weight`  -- a list/1D array of connection weights, or a single weight.
-                     Must have the same length as `targets`.
-        `delays`  -- a list/1D array of connection delays, or a single delay.
-                     Must have the same length as `targets`.
-        """
-        if not isinstance(source, (int, long)) or source < 0:
-            errmsg = "Invalid source ID: %s" % source
-            raise errors.ConnectionError(errmsg)
-        if not core.is_listlike(targets):
-            targets = [targets]
-        if isinstance(weights, float):
-            weights = [weights]
-        if isinstance(delays, float):
-            delays = [delays]
-        assert len(targets) > 0
-        for target in targets:
-            if not isinstance(target, common.IDMixin):
-                raise errors.ConnectionError("Invalid target ID: %s" % target)
-        assert len(targets) == len(weights) == len(delays), "%s %s %s" % (len(targets),len(weights),len(delays))
-        if common.is_conductance(targets[0]):
-            weight_scale_factor = 1e-6 # Convert from µS to S  
-        else:
-            weight_scale_factor = 1e-9 # Convert from nA to A
-        
-        synapse_type = self.synapse_type or "excitatory"
-        if isinstance(synapse_type, basestring):
-            syn_target_id = ConnectionManager.synapse_target_ids[synapse_type]
-            syn_factory = pypcsim.SimpleScalingSpikingSynapse(
-                              syn_target_id, weights[0], delays[0])
-        elif isinstance(synapse_type, pypcsim.SimObject):
-            syn_factory = synapse_type
-        else:
-            raise errors.ConnectionError("synapse_type must be a string or a PCSIM synapse factory. Actual type is %s" % type(synapse_type))
-        for target, weight, delay in zip(targets, weights, delays):
-            syn_factory.W = weight*weight_scale_factor
-            syn_factory.delay = delay*0.001 # ms --> s
-            try:
-                c = net.connect(source, target, syn_factory)
-            except RuntimeError, e:
-                raise errors.ConnectionError(e)
-            if target.local:
-                self.connections.append(Connection(source, target, net.object(c), 1.0/weight_scale_factor))
-    
-    def convergent_connect(self, sources, target, weights, delays):
-        """
-        Connect a neuron to one or more other neurons with a static connection.
-        
-        `sources`  -- a list/1D array of pre-synaptic cell IDs, or a single ID.
-        `target` -- the ID of the post-synaptic cell.
-        `weight`  -- a list/1D array of connection weights, or a single weight.
-                     Must have the same length as `targets`.
-        `delays`  -- a list/1D array of connection delays, or a single delay.
-                     Must have the same length as `targets`.
-        """
-        if not isinstance(target, (int, long)) or target < 0:
-            errmsg = "Invalid target ID: %s" % target
-            raise errors.ConnectionError(errmsg)
-        if not core.is_listlike(sources):
-            sources = [sources]
-        if isinstance(weights, float):
-            weights = [weights]
-        if isinstance(delays, float):
-            delays = [delays]
-        assert len(sources) > 0
-        for source in sources:
-            if not isinstance(source, common.IDMixin):
-                raise errors.ConnectionError("Invalid source ID: %s" % source)
-        assert len(sources) == len(weights) == len(delays), "%s %s %s" % (len(sources),len(weights),len(delays))
-        if common.is_conductance(target):
-            weight_scale_factor = 1e-6 # Convert from µS to S  
-        else:
-            weight_scale_factor = 1e-9 # Convert from nA to A
-        
-        synapse_type = self.synapse_type or "excitatory"
-        if isinstance(synapse_type, basestring):
-            syn_target_id = ConnectionManager.synapse_target_ids[synapse_type]
-            syn_factory = pypcsim.SimpleScalingSpikingSynapse(
-                              syn_target_id, weights[0], delays[0])
-        elif isinstance(synapse_type, pypcsim.SimObject):
-            syn_factory = synapse_type
-        else:
-            raise errors.ConnectionError("synapse_type must be a string or a PCSIM synapse factory. Actual type is %s" % type(synapse_type))
-        for source, weight, delay in zip(sources, weights, delays):
-            syn_factory.W = weight*weight_scale_factor
-            syn_factory.delay = delay*0.001 # ms --> s
-            try:
-                c = net.connect(source, target, syn_factory)
-            except RuntimeError, e:
-                raise errors.ConnectionError(e)
-            if target.local:
-                self.connections.append(Connection(source, target, net.object(c), 1.0/weight_scale_factor))
-        
-    def get(self, parameter_name, format):
-        """
-        Get the values of a given attribute (weight, delay, etc) for all
-        connections on the local MPI node.
-        
-        `parameter_name` -- name of the attribute whose values are wanted.
-        `format` -- "list" or "array". Array format implicitly assumes that all
-                    connections belong to a single Projection.
-        
-        Return a list or a 2D Numpy array. The array element X_ij contains the
-        attribute value for the connection from the ith neuron in the pre-
-        synaptic Population to the jth neuron in the post-synaptic Population,
-        if such a connection exists. If there are no such connections, X_ij will
-        be NaN.
-        """
-        if format == 'list':
-            values = [getattr(c, parameter_name) for c in self]
-        elif format == 'array':
-            values = numpy.nan * numpy.ones((self.parent.pre.size, self.parent.post.size))
-            for c in self:
-                addr = (self.parent.pre.id_to_index(c.source), self.parent.post.id_to_index(c.target))
-                values[addr] = getattr(c, parameter_name)
-        else:
-            raise Exception("format must be 'list' or 'array'")
-        return values        
-    
-    def set(self, name, value):
-        """
-        Set connection attributes for all connections on the local MPI node.
-        
-        `name`  -- attribute name
-        `value` -- the attribute numeric value, or a list/1D array of such
-                   values of the same length as the number of local connections,
-                   or a 2D array with the same dimensions as the connectivity
-                   matrix (as returned by `get(format='array')`)
-        """
-        if numpy.isscalar(value):
-            for c in self:
-                setattr(c, name, value)
-        elif isinstance(value, numpy.ndarray) and len(value.shape) == 2:
-            for c in self.connections:
-                addr = (self.parent.pre.id_to_index(c.source), self.parent.post.id_to_index(c.target))
-                try:
-                    val = value[addr]
-                except IndexError, e:
-                    raise IndexError("%s. addr=%s" % (e, addr))
-                if numpy.isnan(val):
-                    raise Exception("Array contains no value for synapse from %d to %d" % (c.source, c.target))
-                else:
-                    setattr(c, name, val)
-        elif core.is_listlike(value):
-            for c,val in zip(self.connections, value):
-                setattr(c, name, val)
-        else:
-            raise TypeError("Argument should be a numeric type (int, float...), a list, or a numpy array.")
-
-
 # --- Initialization, and module attributes ------------------------------------
           

trunk/test/system/scenarios.py

@@ -408 +408 @@
         assert_arrays_equal(rec, data[0])
 
-@register(exclude=['pcsim'])
+@register(exclude=['pcsim', 'moose'])
 def test_EIF_cond_alpha_isfa_ista(sim):
     set_simulator(sim)
@@ -448 +448 @@
     
 
-@register(exclude=['pcsim'])
+@register(exclude=['pcsim', 'moose'])
 def test_record_vm_and_gsyn_from_assembly(sim):
     from pyNN.utility import init_logging

trunk/test/unittests/test_connectors.py

@@ -53 +53 @@
 
 
-class MockConnectionManager(object):
-    
-    def __init__(self):
+class MockRNG(random.WrappedRNG):
+    rng = None
+    
+    def __init__(self, num_processes, delta=1):
+        random.num_processes = num_processes
+        random.WrappedRNG.__init__(self)
+        self.start = 0.0
+        self.delta = delta
+    
+    def _next(self, distribution, n, parameters):
+        s = self.start
+        self.start += n*self.delta
+        return numpy.arange(s, s+n*self.delta, self.delta)
+
+
+class MockProjection(object):
+    
+    def __init__(self, pre, post):
+        self.pre = pre
+        self.post = post
         self.connections = []
-    
-    def connect(self, src, targets, weights, delays):
+        self.rng = MockRNG(num_processes=2, delta=0.1)
+        self.synapse_type = 'inhibitory'
+
+    def _divergent_connect(self, src, targets, weights, delays):
         #if src in self.connections:
         #    raise Exception("connect already called with source %s" % src) # no reason why this shouldn't happen, but it doesn't in the current implementation, so I'm being lazy
@@ -74 +93 @@
             self.connections.append((src, tgt, w, d))
 
-    def convergent_connect(self, sources, tgt, weights, delays):
+    def _convergent_connect(self, sources, tgt, weights, delays):
         if isinstance(weights, float):
             weights = repeat(weights)
@@ -81 +100 @@
         for src, w, d in zip(sources, weights, delays):
             self.connections.append((src, tgt, w, d))
-        
-
-class MockRNG(random.WrappedRNG):
-    rng = None
-    
-    def __init__(self, num_processes, delta=1):
-        random.num_processes = num_processes
-        random.WrappedRNG.__init__(self)
-        self.start = 0.0
-        self.delta = delta
-    
-    def _next(self, distribution, n, parameters):
-        s = self.start
-        self.start += n*self.delta
-        return numpy.arange(s, s+n*self.delta, self.delta)
-
-
-class MockProjection(object):
-    
-    def __init__(self, pre, post):
-        self.pre = pre
-        self.post = post
-        self.connection_manager = MockConnectionManager()
-        self.rng = MockRNG(num_processes=2, delta=0.1)
-        self.synapse_type = 'inhibitory'
 
 
@@ -119 +113 @@
         C.progression = Mock()
         C.connect(self.prj)
-        assert_equal(self.prj.connection_manager.connections,
+        assert_equal(self.prj.connections,
                      [(18, 80, 5.0, 0.5), (20, 82, 5, 0.5)])
 
@@ -128 +122 @@
         C.progression = Mock()
         C.connect(self.prj)
-        assert_equal(self.prj.connection_manager.connections,
+        assert_equal(self.prj.connections,
                      [(18, 80, 1.0, 0.5), (20, 82, 3.0, 0.5)])
 
@@ -143 +137 @@
         C.progression = Mock()
         C.connect(self.prj)
-        assert_equal(set(self.prj.connection_manager.connections),
+        assert_equal(set(self.prj.connections),
                      set([(17, 80, 5.0, 0.5),
                           (17, 82, 5.0, 0.5),
@@ -159 +153 @@
         C.progression = Mock()
         C.connect(self.prj)
-        assert_equal(self.prj.connection_manager.connections,
+        assert_equal(self.prj.connections,
                      [(17, 80, 1.0, 0.5),
                       (17, 82, 3.0, 0.5),
@@ -175 +169 @@
         C.progression = Mock()
         C.connect(self.prj)
-        assert_equal(self.prj.connection_manager.connections,
+        assert_equal(self.prj.connections,
                      [(17, 80, 163.0, 0.5),   # 100+|17-80|
                       (17, 82, 165.0, 0.5),   # 100+|17-82|
@@ -220 +214 @@
         # first 8 are created (17, 79), (17, 80), (17,81), (17,82), (17,83), (18,79), (18,80), (18,81)
         # of these, (17,80), (17,82), (18,80) are created on this node
-        assert_equal(self.prj.connection_manager.connections,
+        assert_equal(self.prj.connections,
                      [(17, 80, 0.0, MIN_DELAY),
                       (17, 82, 0.0, MIN_DELAY),
@@ -240 +234 @@
         # 20 possible connections. Only those with a sufficiently small distance
         # are created
-        assert_equal(self.prj.connection_manager.connections,
+        assert_equal(self.prj.connections,
                      [(18, 80, 0.0, MIN_DELAY),
                       (19, 80, 0.0, MIN_DELAY),
@@ -266 +260 @@
         C.connect(self.prj)
         # note that ListConnector does not filter out non-local connections
-        assert_equal(self.prj.connection_manager.connections,
+        assert_equal(self.prj.connections,
                      [(17, 79, 0.1, 0.1),
                       (17, 80, 0.5, 0.14),
@@ -307 +301 @@
         C = connectors.FromFileConnector("test.connections", distributed=False)
         C.connect(self.prj)
-        assert_equal(self.prj.connection_manager.connections,
+        assert_equal(self.prj.connections,
                      [(17, 79, 0.1, 0.1),
                       (17, 80, 0.5, 0.14),
@@ -319 +313 @@
         C = connectors.FromFileConnector("test.connections", distributed=True)
         C.connect(self.prj)
-        assert_equal(self.prj.connection_manager.connections,
+        assert_equal(self.prj.connections,
                      [(17, 80, 0.5, 0.14),
                       (19, 82, 0.3, 0.12)])
@@ -340 +334 @@
         C.connect(self.prj)
         # FixedNumberPost does not currently filter out only local connections
-        assert_equal(self.prj.connection_manager.connections,
+        assert_equal(self.prj.connections,
                      [(17, 79, 0.0, MIN_DELAY),
                       (17, 80, 0.0, MIN_DELAY),
@@ -371 +365 @@
         self.prj.post.local_cells = [MockCell(n) for n in self.prj.post.local_cells]
         C.connect(self.prj)
-        assert_equal(self.prj.connection_manager.connections,
+        assert_equal(self.prj.connections,
                      [(17, 80, 0.0, MIN_DELAY),
                       (18, 80, 0.0, MIN_DELAY),

trunk/test/unittests/test_projection.py

@@ -24 +24 @@
     first_id = 555
 
-class MockConnectionManager(object):
     def __len__(self):
         return 999
@@ -49 +48 @@
                             synapse_dynamics=standardmodels.SynapseDynamics())
     
-def test_len():
-    p1 = MockPopulation()
-    p2 = MockPopulation()
-    prj = common.Projection(p1, p2, method=Mock())
-    prj.connection_manager = MockConnectionManager()
-    assert_equal(len(prj), len(prj.connection_manager))
-    
 def test_size_no_gather():
     p1 = MockPopulation()
     p2 = MockPopulation()
     prj = common.Projection(p1, p2, method=Mock())
-    prj.connection_manager = MockConnectionManager()
-    assert_equal(prj.size(gather=False), len(prj))
+    orig_len = common.Projection.__len__
+    common.Projection.__len__ = Mock(return_value=42)
+    n = prj.size(gather=False)
+    prj.__len__.assert_called()
+    common.Projection.__len__ = orig_len
     
 def test_size_with_gather():
     orig_mpi_sum = common.recording.mpi_sum
+    orig_len = common.Projection.__len__
     common.recording.mpi_sum = Mock()
-    p1 = MockPopulation()
-    p2 = MockPopulation()
-    prj = common.Projection(p1, p2, method=Mock())
-    prj.connection_manager = MockConnectionManager()
+    common.Projection.__len__ = Mock(return_value=42)
+    p1 = MockPopulation()
+    p2 = MockPopulation()
+    prj = common.Projection(p1, p2, method=Mock())
     prj.size(gather=True)
     common.recording.mpi_sum.assert_called_with(len(prj))
     common.recording.mpi_sum = orig_mpi_sum
-    
-def test__getitem():
-    p1 = MockPopulation()
-    p2 = MockPopulation()
-    prj = common.Projection(p1, p2, method=Mock())
-    prj.connection_manager = MockConnectionManager()
-    assert_equal(prj[0], 888)
+    common.Projection.__len__ = orig_len
     
 def test_set_weights():
@@ -87 +77 @@
     prj.synapse_type = "foo"
     prj.post.local_cells = [0]
-    prj.connection_manager = MockConnectionManager()
-    prj.connection_manager.set = Mock()
+    prj.set = Mock()
     prj.setWeights(0.5)
-    prj.connection_manager.set.assert_called_with('weight', 0.5)
+    prj.set.assert_called_with('weight', 0.5)
     
 def test_randomize_weights():
-    p1 = MockPopulation()
-    p2 = MockPopulation()
-    prj = common.Projection(p1, p2, method=Mock())
-    prj.connection_manager = MockConnectionManager()
-    prj.setWeights = Mock()
+    orig_len = common.Projection.__len__
+    common.Projection.__len__ = Mock(return_value=42)
+    p1 = MockPopulation()
+    p2 = MockPopulation()
+    prj = common.Projection(p1, p2, method=Mock())
+    prj.set = Mock()
     rd = Mock()
     rd.next = Mock(return_value=777)
     prj.randomizeWeights(rd)
     rd.next.assert_called_with(len(prj))
-    prj.setWeights.assert_called_with(777)
+    prj.set.assert_called_with('weight', 777)
+    common.Projection.__len__ = orig_len
     
 def test_set_delays():
@@ -108 +99 @@
     p2 = MockPopulation()
     prj = common.Projection(p1, p2, method=Mock())
-    prj.connection_manager = MockConnectionManager()
-    prj.connection_manager.set = Mock()
+    prj.set = Mock()
     prj.setDelays(0.5)
-    prj.connection_manager.set.assert_called_with('delay', 0.5)
+    prj.set.assert_called_with('delay', 0.5)
     
 def test_randomize_delays():
-    p1 = MockPopulation()
-    p2 = MockPopulation()
-    prj = common.Projection(p1, p2, method=Mock())
-    prj.connection_manager = MockConnectionManager()
-    prj.setDelays = Mock()
+    orig_len = common.Projection.__len__
+    common.Projection.__len__ = Mock(return_value=42)
+    p1 = MockPopulation()
+    p2 = MockPopulation()
+    prj = common.Projection(p1, p2, method=Mock())
+    prj.set = Mock()
     rd = Mock()
     rd.next = Mock(return_value=777)
     prj.randomizeDelays(rd)
     rd.next.assert_called_with(len(prj))
-    prj.setDelays.assert_called_with(777)
+    prj.set.assert_called_with('delay', 777)
+    common.Projection.__len__ = orig_len
     
 def test_set_synapse_dynamics_param():
@@ -129 +121 @@
     p2 = MockPopulation()
     prj = common.Projection(p1, p2, method=Mock())
-    prj.connection_manager = MockConnectionManager()
-    prj.connection_manager.set = Mock()
+    prj.set = Mock()
     prj.setSynapseDynamics('U', 0.5)
-    prj.connection_manager.set.assert_called_with('U', 0.5)
+    prj.set.assert_called_with('U', 0.5)
     
 def test_get_weights():
@@ -138 +129 @@
     p2 = MockPopulation()
     prj = common.Projection(p1, p2, method=Mock())
-    prj.connection_manager = MockConnectionManager()
-    prj.connection_manager.get = Mock()
+    prj.get = Mock()
     prj.getWeights(format='list', gather=False)
-    prj.connection_manager.get.assert_called_with('weight', 'list')
+    prj.get.assert_called_with('weight', 'list')
     
 def test_get_delays():
@@ -147 +137 @@
     p2 = MockPopulation()
     prj = common.Projection(p1, p2, method=Mock())
-    prj.connection_manager = MockConnectionManager()
-    prj.connection_manager.get = Mock()
+    prj.get = Mock()
     prj.getDelays(format='list', gather=False)
-    prj.connection_manager.get.assert_called_with('delay', 'list')
+    prj.get.assert_called_with('delay', 'list')
 
 def test_save_connections():
@@ -159 +148 @@
     p2 = MockPopulation()
     prj = common.Projection(p1, p2, method=Mock())
-    prj.connection_manager = MockConnectionManager()
     prj.connections = [MockConnection(), MockConnection(), MockConnection()]
     prj.saveConnections(filename, gather=False, compatible_output=False)
@@ -172 +160 @@
     p2 = MockPopulation()
     prj = common.Projection(p1, p2, method=Mock())
-    prj.connection_manager = MockConnectionManager()
+    prj.get = Mock(return_value=range(5))
     prj.printWeights(filename, format='list', gather=False)
+    prj.get.assert_called_with('weight', format='list', gather=False)
     assert os.path.exists(filename)
     os.remove(filename)
@@ -184 +173 @@
     p2 = MockPopulation()
     prj = common.Projection(p1, p2, method=Mock())
-    prj.connection_manager = MockConnectionManager()
+    prj.get = Mock(return_value=numpy.arange(5.0))
     prj.printWeights(filename, format='array', gather=False)
+    prj.get.assert_called_with('weight', format='array', gather=False)
     assert os.path.exists(filename)
     os.remove(filename)
@@ -214 +204 @@
 
 def test_describe():
+    orig_len = common.Projection.__len__
+    common.Projection.__len__ = Mock(return_value=42)
     p1 = MockPopulation()
     p2 = MockPopulation()
     prj = common.Projection(p1, p2, method=Mock(), synapse_dynamics=standardmodels.SynapseDynamics())
-    prj.connection_manager = MockConnectionManager()
     prj.pre.describe = Mock()
     prj.post.describe = Mock()
     assert isinstance(prj.describe(engine='string'), basestring)
     assert isinstance(prj.describe(template=None), dict)
+    common.Projection.__len__ = orig_len