Changeset 727

Timestamp:

03/11/10 15:25:14 (2 years ago)

Author:

pierre

Message:

New implementation of the connector class, which is fully operationnal. All tests are passed, and now, a generic implementation allows to use distance dependent expressions for all the connectors (except OneToOne? ?). They are also much faster, computing only local computations, and all provides therefore a good scaling with MPI. In addition, a safe flag has been added to all the Connector: on by default, user can turn it off to avoid tests on weights and delays. Again, if really someone need to do a big network and knows what he is bulding, then all those superfical tests can be turned off

Files:

• trunk/src/connectors2.py (modified) (7 diffs)

trunk/src/connectors2.py

@@ -1 +1 @@
 import numpy
-from pyNN import common, core
+from pyNN import errors, common, core, random
 from pyNN.space import Space
 from pyNN.random import RandomDistribution
@@ -7 +7 @@
 class ConnectionAttributeGenerator(object):
     
-    def __init__(self, source, local_mask):
-        self.source = source
+    def __init__(self, source, local_mask, safe=True):
+        self.source     = source
         self.local_mask = local_mask
+        self.safe       = safe
         if isinstance(self.source, numpy.ndarray):
             self.source_iterator = iter(self.source)
     
-    def get(self, connectivity_matrix, distance_matrix):
-        local_value_mask = self.local_mask[connectivity_matrix]
-        if numpy.isscalar(self.source):
-            return numpy.ones((local_value_mask.sum(),))*self.source
+    def get(self, N, distance_matrix=None, sub_mask=None):
+        if isinstance(self.source, basestring):
+            assert distance_matrix is not None
+            d      = distance_matrix.as_array(sub_mask)
+            values = eval(self.source)
+            return values
+        elif numpy.isscalar(self.source):
+            if sub_mask is None:
+                values = numpy.ones((self.local_mask.sum(),))*self.source
+            else:
+                values = numpy.ones((len(sub_mask),))*self.source
+            return values
         elif isinstance(self.source, RandomDistribution):
-            all_values = self.source.next(connectivity_matrix.sum(),
-                                          mask_local=False)
-            local_values = all_values[local_value_mask]
-            return local_values
+            values = self.source.next(N, mask_local=self.local_mask)
+            if sub_mask is not None:
+                values = values[sub_mask]
+            return values
         elif isinstance(self.source, numpy.ndarray):
             source_row = self.source_iterator.next()
-            assert source_row.shape == connectivity_matrix.shape
-            return source_row[local_value_mask]
-        elif isinstance(self.source, basestring):
-            d = distance_matrix.as_array(mask=local_value_mask)
-            values = eval(self.source)
+            values     = source_row[self.local_mask]
+            if sub_mask:
+                values = values[sub_mask]
             return values
 
 
 class WeightGenerator(ConnectionAttributeGenerator):
+    
+    def __init__(self, source, local_mask, projection, safe=True):
+      ConnectionAttributeGenerator.__init__(self, source, local_mask, safe)
+      self.projection     = projection
+      self.is_conductance = common.is_conductance(projection.post.local_cells[0])
+
+    def check(self, weight):
+        if weight is None:
+            weight = DEFAULT_WEIGHT
+        if core.is_listlike(weight):
+            weight     = numpy.array(weight)
+            nan_filter = (1-numpy.isnan(weight)).astype(bool) # weight arrays may contain NaN, which should be ignored
+            filtered_weight = weight[nan_filter]
+            all_negative = (filtered_weight<=0).all()
+            all_positive = (filtered_weight>=0).all()
+            if not (all_negative or all_positive):
+                raise errors.InvalidWeightError("Weights must be either all positive or all negative")
+        elif numpy.isscalar(weight):
+            all_positive = weight >= 0
+            all_negative = weight < 0
+        else:
+            raise Exception("Weight must be a number or a list/array of numbers.")
+        if self.is_conductance or self.projection.synapse_type == 'excitatory':
+            if not all_positive:
+                raise errors.InvalidWeightError("Weights must be positive for conductance-based and/or excitatory synapses")
+        elif self.is_conductance==False and self.projection.synapse_type == 'inhibitory':
+            if not all_negative:
+                raise errors.InvalidWeightError("Weights must be negative for current-based, inhibitory synapses")
+        else: # is_conductance is None. This happens if the cell does not exist on the current node.
+            logger.debug("Can't check weight, conductance status unknown.")
+        return weight
+
+    def get(self, N, distance_matrix=None, sub_mask=None):
+      values = ConnectionAttributeGenerator.get(self, N, distance_matrix, sub_mask)      
+      if self.safe:
+          values = self.check(values)
+      return values
+
+
+class DelayGenerator(ConnectionAttributeGenerator):
+
+    def __init__(self, source, local_mask, safe=True):
+        ConnectionAttributeGenerator.__init__(self, source, local_mask, safe)
+        self.min_delay = common.get_min_delay()
+        self.max_delay = common.get_max_delay()
+
+    def check(self, delay):
+        all_negative = (delay<=self.max_delay).all()
+        all_positive = (delay>=self.min_delay).all()# If the delay is too small , we have to throw an error
+        if not (all_negative and all_positive):
+            raise errors.ConnectionError("delay (%s) is out of range [%s,%s]" % (delay, common.get_min_delay(), common.get_max_delay()))
+        return delay
+
+    def get(self, N, distance_matrix=None, sub_mask=None):
+        values = ConnectionAttributeGenerator.get(self, N, distance_matrix, sub_mask)
+        if self.safe:
+            values = self.check(values)
+        return values
+
+
+class ProbaGenerator(ConnectionAttributeGenerator):
     pass
 
-class DelayGenerator(ConnectionAttributeGenerator):
-    pass
-
 
 class DistanceMatrix(object):
     
-    def __init__(self, A, B, space):
-        assert A.shape == (3,)
+    def __init__(self, B, space, mask=None):
         assert B.shape[0] == 3
         self.space = space
+        if mask is not None:
+            self.B = ((B.T)[mask]).T
+        else:
+            self.B = B
+        
+    def as_array(self, sub_mask=None):
+        if self._distance_matrix is None and self.A is not None:
+            if sub_mask is None:
+                self._distance_matrix = self.space.distances(self.A, self.B)[0]
+            else:
+                self._distance_matrix = self.space.distances(self.A, self.B[:,sub_mask])[0]
+        return self._distance_matrix
+        
+    def set_source(self, A):
+        assert A.shape == (3,)
         self.A = A
-        self.B = B
-        self._distance_matrix = None
-        self._last_mask = None
-        
-    def as_array(self, mask=None):
-        if self._distance_matrix is None or mask != self._last_mask:
-            if mask is not None and mask.sum() < mask.size:
-                local_B = ((self.B.T)[mask]).T
-            else:
-                local_B = self.B
-            self._distance_matrix = self.space.distances(self.A, local_B)[0]
-            self._last_mask = mask
-        return self._distance_matrix
-        
+        self._distance_matrix = None        
+
 
 class Connector(object):
     
-    def __init__(self, weights=0.0, delays=None):
+    def __init__(self, weights=0.0, delays=None, space=Space(), safe=True):
         self.weights = weights
-        min_delay = common.get_min_delay()
+        self.space   = space
+        self.safe    = safe
+        min_delay    = common.get_min_delay()
         if delays is None:
             self.delays = min_delay
@@ -78 +147 @@
         pass
     
-    
+
+
+class ProbabilisticConnector(Connector):
+    
+    def __init__(self, projection, weights=0.0, delays=None, allow_self_connections=True, space=Space(), safe=True):
+
+        Connector.__init__(self, weights, delays, space, safe)
+        if isinstance(projection.rng, random.NativeRNG):
+            raise Exception("Use of NativeRNG not implemented.")
+        else:
+            self.rng = projection.rng
+        
+        self.local             = projection.post._mask_local.flatten()
+        self.N                 = projection.post.size
+        self.weights_generator = WeightGenerator(weights, self.local, projection, safe)
+        self.delays_generator  = DelayGenerator(delays, self.local, safe)
+        self.probas_generator  = ProbaGenerator(RandomDistribution('uniform',(0,1), rng=self.rng), self.local)
+        self.distance_matrix   = DistanceMatrix(projection.post.positions, self.space, self.local)
+        self.projection        = projection
+        self.allow_self_connections = allow_self_connections
+
+    def _probabilistic_connect(self, src, p):
+        """
+        Connect-up a Projection with connection probability p, where p may be either
+        a float 0<=p<=1, or a dict containing a float array for each pre-synaptic
+        cell, the array containing the connection probabilities for all the local
+        targets of that pre-synaptic cell.
+        """
+        if numpy.isscalar(p) and p == 1:
+            create = numpy.arange(self.local.sum())
+        else:
+            rarr   = self.probas_generator.get(self.N, self.distance_matrix)
+            create = numpy.where(rarr < p)[0]
+        
+        if isinstance(self.weights, basestring) or isinstance(self.delays, basestring):      
+            self.distance_matrix.set_source(src.position)
+        
+        targets = self.projection.post.local_cells[create]
+        weights = self.weights_generator.get(self.N, self.distance_matrix, create)
+        delays  = self.delays_generator.get(self.N, self.distance_matrix, create)
+            
+        if not self.allow_self_connections and self.projection.pre == self.projection.post and src in targets:
+            i       = numpy.where(targets == src)[0]
+            weights = numpy.delete(weights, i)
+            delays  = numpy.delete(delays, i)
+            targets = numpy.delete(targets, i)
+        
+        if len(targets) > 0:
+            self.projection.connection_manager.connect(src, targets.tolist(), weights, delays)
+
     
     
@@ -87 +205 @@
     """
     
-    def __init__(self, allow_self_connections=True,
-                 weights=0.0, delays=None, space=Space()):
+    def __init__(self, allow_self_connections=True, weights=0.0, delays=None, space=Space(), safe=True):
         """
         Create a new connector.
@@ -104 +221 @@
                    dependent weights or delays
         """
-        Connector.__init__(self, weights, delays)
+        Connector.__init__(self, weights, delays, space, safe)
         assert isinstance(allow_self_connections, bool)
         self.allow_self_connections = allow_self_connections
-        self.space = space
-        
-        
-    def connect(self, projection):       
-        local = projection.post._mask_local.flatten()
-        weight_generator = WeightGenerator(self.weights, local)
-        delay_generator = DelayGenerator(self.delays, local)
-        
-        global_target_mask = numpy.ones((projection.post.size,), dtype=bool)
-        targets = projection.post.local_cells.tolist()
-        if len(targets) > 0:
-            for src in projection.pre.all():
-                distance_matrix = DistanceMatrix(src.position,
-                                                 projection.post.positions,
-                                                 space=self.space)
-                weights = weight_generator.get(global_target_mask, distance_matrix)
-                delays = delay_generator.get(global_target_mask, distance_matrix)
-                projection.connection_manager.connect(src, targets, weights, delays)
+        
+    def connect(self, projection):
+        connector = ProbabilisticConnector(projection, self.weights, self.delays, self.allow_self_connections, self.space, safe=self.safe)
+        for src in projection.pre.all():
+            connector._probabilistic_connect(src, 1)
 
     
@@ -133 +237 @@
     """
     
-    def __init__(self, p_connect, allow_self_connections=True,
-                 weights=0.0, delays=None, space=Space()):
+    def __init__(self, p_connect, allow_self_connections=True, weights=0.0, delays=None, space=Space(), safe=True):
         """
         Create a new connector.
@@ -152 +255 @@
                    dependent weights or delays
         """
-        Connector.__init__(self, weights, delays)
+        Connector.__init__(self, weights, delays, space, safe)
         assert isinstance(allow_self_connections, bool)
         self.allow_self_connections = allow_self_connections
         self.p_connect = float(p_connect)
-        self.space = space
         assert 0 <= self.p_connect
         
     def connect(self, projection):
-        assert projection.rng.parallel_safe
-        p = self.p_connect
-        local = projection.post._mask_local.flatten()
-        weight_generator = WeightGenerator(self.weights, local)
-        delay_generator = DelayGenerator(self.delays, local)
+        #assert projection.rng.parallel_safe
+        connector = ProbabilisticConnector(projection, self.weights, self.delays, self.allow_self_connections, self.space, safe=self.safe)
         for src in projection.pre.all():
-            
-            N = projection.post.size
-            rarr = projection.rng.next(N, 'uniform', (0,1), mask_local=False)
-            if not core.is_listlike(rarr) and numpy.isscalar(rarr): # if N=1, rarr will be a single number
-                rarr = numpy.array([rarr])
-            global_target_mask = rarr < p
-            local_target_mask = global_target_mask[local]
-            targets = projection.post.local_cells[local_target_mask].tolist()
-            
-            if len(targets) > 0:
-                distance_matrix = DistanceMatrix(src.position,
-                                                 projection.post.positions,
-                                                 space=self.space)
-                weights = weight_generator.get(global_target_mask, distance_matrix)
-                delays = delay_generator.get(global_target_mask, distance_matrix)
-                projection.connection_manager.connect(src, targets, weights, delays)
-
+            connector._probabilistic_connect(src, self.p_connect)
+
+
+class DistanceDependentProbabilityConnector(ProbabilisticConnector):
+    """
+    For each pair of pre-post cells, the connection probability depends on distance.
+    """
+    
+    def __init__(self, d_expression, allow_self_connections=True,
+                 weights=0.0, delays=None, space=Space(), safe=True):
+        """
+        Create a new connector.
+        , projection
+        `d_expression` -- the right-hand side of a valid python expression for
+            probability, involving 'd', e.g. "exp(-abs(d))", or "d<3"
+        `space` -- a Space object.
+        `weights` -- may either be a float, a RandomDistribution object, a list/
+                     1D array with at least as many items as connections to be
+                     created, or a DistanceDependence object. Units nA.
+        `delays`  -- as `weights`. If `None`, all synaptic delays will be set
+                     to the global minimum delay.
+        """
+        Connector.__init__(self, weights, delays, space, safe)
+        assert isinstance(d_expression, str)
+        try:
+            d = 0; assert 0 <= eval(d_expression), eval(d_expression)
+            d = 1e12; assert 0 <= eval(d_expression), eval(d_expression)
+        except ZeroDivisionError, err:
+            raise ZeroDivisionError("Error in the distance expression %s. %s" % (d_expression, err))
+        self.d_expression = d_expression
+        assert isinstance(allow_self_connections, bool)
+        self.allow_self_connections = allow_self_connections
+        
+    def connect(self, projection):
+        """Connect-up a Projection."""
+        connector       = ProbabilisticConnector(projection, self.weights, self.delays, self.allow_self_connections, self.space, safe=self.safe)
+        proba_generator = ProbaGenerator(self.d_expression, connector.local)
+
+        for src in projection.pre.all():     
+            connector.distance_matrix.set_source(src.position)
+            proba  = proba_generator.get(connector.N, connector.distance_matrix)
+            if proba.dtype == 'bool':
+                proba = proba.astype(float)
+            connector._probabilistic_connect(src, proba)
+
+
+class FromListConnector(Connector):
+    """
+    Make connections according to a list.
+    """
+    
+    def __init__(self, conn_list):
+        """
+        Create a new connector.
+        
+        `conn_list` -- a list of tuples, one tuple for each connection. Each
+                       tuple should contain:
+                          (pre_addr, post_addr, weight, delay)
+                       where pre_addr is the address (a tuple) of the presynaptic
+                       neuron, and post_addr is the address of the postsynaptic
+                       neuron.
+        """
+        # needs extending for dynamic synapses.
+        Connector.__init__(self, 0., common.get_min_delay())
+        self.conn_list = conn_list        
+        
+    def connect(self, projection):
+        """Connect-up a Projection."""
+        # slow: should maybe sort by pre
+        for i in xrange(len(self.conn_list)):
+            src, tgt, weight, delay = self.conn_list[i][:]
+            src = projection.pre[tuple(src)]           
+            tgt = projection.post[tuple(tgt)]
+            projection.connection_manager.connect(src, [tgt], weight, delay)
+
+
+class FromFileConnector(FromListConnector):
+    """
+    Make connections according to a list read from a file.
+    """
+    
+    def __init__(self, filename, distributed=False):
+        """
+        Create a new connector.
+        
+        `filename` -- name of a text file containing a list of connections, in
+                      the format required by `FromListConnector`.
+        `distributed` -- if this is True, then each node will read connections
+                         from a file called `filename.x`, where `x` is the MPI
+                         rank. This speeds up loading connections for
+                         distributed simulations.
+        """
+        Connector.__init__(self, 0., common.get_min_delay())
+        self.filename = filename
+        self.distributed = distributed
+
+    def connect(self, projection):
+        """Connect-up a Projection."""
+        if self.distributed:
+            self.filename += ".%d" % common.rank()
+        # open the file...
+        f = open(self.filename, 'r', 10000)
+        lines = f.readlines()
+        f.close()
+        # gather all the data in a list of tuples (one per line)
+        input_tuples = []
+        for line in lines:
+            single_line = line.rstrip()
+            src, tgt, w, d = single_line.split("\t", 4)
+            src = "[%s" % src.split("[",1)[1]
+            tgt = "[%s" % tgt.split("[",1)[1]
+            input_tuples.append((eval(src), eval(tgt), float(w), float(d)))
+        self.conn_list = input_tuples
+        FromListConnector.connect(self, projection)
+
+
+
+class FixedNumberPostConnector(Connector):
+    """
+    Each pre-synaptic neuron is connected to exactly n post-synaptic neurons
+    chosen at random.
+    
+    If n is less than the size of the post-synaptic population, there are no
+    multiple connections, i.e., no instances of the same pair of neurons being
+    multiply connected. If n is greater than the size of the post-synaptic
+    population, all possible single connections are made before starting to add
+    duplicate connections.
+    """
+    
+    def __init__(self, n, allow_self_connections=True, weights=0.0, delays=None, space=Space(), safe=True):
+        """
+        Create a new connector.
+        
+        `n` -- either a positive integer, or a `RandomDistribution` that produces
+               positive integers. If `n` is a `RandomDistribution`, then the
+               number of post-synaptic neurons is drawn from this distribution
+               for each pre-synaptic neuron.
+        `allow_self_connections` -- if the connector is used to connect a
+               Population to itself, this flag determines whether a neuron is
+               allowed to connect to itself, or only to other neurons in the
+               Population.
+        `weights` -- may either be a float, a RandomDistribution object, a list/
+                     1D array with at least as many items as connections to be
+                     created. Units nA.
+        `delays`  -- as `weights`. If `None`, all synaptic delays will be set
+                     to the global minimum delay.
+        """
+        Connector.__init__(self, weights, delays, space, safe)
+        assert isinstance(allow_self_connections, bool)
+        self.allow_self_connections = allow_self_connections
+        if isinstance(n, int):
+            self.n = n
+            assert n >= 0
+        elif isinstance(n, random.RandomDistribution):
+            self.rand_distr = n
+            # weak check that the random distribution is ok
+            assert numpy.all(numpy.array(n.next(100)) >= 0), "the random distribution produces negative numbers"
+        else:
+            raise Exception("n must be an integer or a RandomDistribution object")
+        
+    def connect(self, projection):
+        """Connect-up a Projection."""        
+        local             = projection.post._mask_local.flatten()
+        weights_generator = WeightGenerator(self.weights, local, projection, self.safe)
+        delays_generator  = DelayGenerator(self.delays, local, self.safe)
+        distance_matrix   = DistanceMatrix(projection.post.positions, self.space, local)
+        candidates        = projection.post.all_cells.flatten()            
+        
+        if isinstance(projection.rng, random.NativeRNG):
+            raise Exception("Use of NativeRNG not implemented.")        
+        
+        for src in projection.pre.all():
+            # pick n neurons at random
+            if hasattr(self, 'rand_distr'):
+                n = self.rand_distr.next()
+            else:
+                n = self.n
+            
+            targets     = numpy.zeros(0, int)
+            loc_targets = []
+            create      = []
+            
+            while len(targets) < n: # if the number of requested cells is larger than the size of the
+                                    # postsynaptic population, we allow multiple connections for a given cell                
+                ids     = projection.rng.permutation(candidates)[0:n] - projection.post.first_id
+                targets = numpy.concatenate((targets, candidates[ids.astype(int)]))                 
+                if not self.allow_self_connections and projection.pre == projection.post:                
+                    idx     = numpy.where(targets == src)[0]
+                    targets = numpy.delete(targets, idx)
+            
+            targets = targets[:n]            
+            if isinstance(self.weights, basestring) or isinstance(self.delays, basestring):      
+                distance_matrix.set_source(src.position)
+            
+            # We need to keep only the local cells, because then distances will be computed only
+            # by the nodes that will established the connections. create is just a mask with all 
+            # the id of the cells that are local and that need to be used. Same id could be repeted
+            # but this is not a problem.
+            for id in targets:
+                pos = numpy.where(id == projection.post.local_cells)[0]
+                N   = len(pos)
+                if N > 0:
+                    loc_targets += N*[id]
+                    create      += [pos[0]]
+            
+            weights = weights_generator.get(n, distance_matrix, create)
+            delays  = delays_generator.get(n, distance_matrix, create)            
+                        
+            if len(loc_targets) > 0:
+                projection.connection_manager.connect(src, loc_targets, weights, delays)
+                    
+
+class FixedNumberPreConnector(Connector):
+    """
+    Each post-synaptic neuron is connected to exactly n pre-synaptic neurons
+    chosen at random.
+    
+    If n is less than the size of the pre-synaptic population, there are no
+    multiple connections, i.e., no instances of the same pair of neurons being
+    multiply connected. If n is greater than the size of the pre-synaptic
+    population, all possible single connections are made before starting to add
+    duplicate connections.
+    """
+    
+    def __init__(self, n, allow_self_connections=True, weights=0.0, delays=None, space=Space(), safe=True):
+        """
+        Create a new connector.
+        
+        `n` -- either a positive integer, or a `RandomDistribution` that produces
+               positive integers. If `n` is a `RandomDistribution`, then the
+               number of pre-synaptic neurons is drawn from this distribution
+               for each post-synaptic neuron.
+        `allow_self_connections` -- if the connector is used to connect a
+            Population to itself, this flag determines whether a neuron is
+            allowed to connect to itself, or only to other neurons in the
+            Population.
+        `weights` -- may either be a float, a RandomDistribution object, a list/
+                     1D array with at least as many items as connections to be
+                     created. Units nA.
+        `delays`  -- as `weights`. If `None`, all synaptic delays will be set
+                     to the global minimum delay.
+        """
+        Connector.__init__(self, weights, delays, space, safe)
+        assert isinstance(allow_self_connections, bool)
+        self.allow_self_connections = allow_self_connections
+        if isinstance(n, int):
+            self.n = n
+            assert n >= 0
+        elif isinstance(n, random.RandomDistribution):
+            self.rand_distr = n
+            # weak check that the random distribution is ok
+            assert numpy.all(numpy.array(n.next(100)) >= 0), "the random distribution produces negative numbers"
+        else:
+            raise Exception("n must be an integer or a RandomDistribution object")
+
+    def connect(self, projection):
+        """Connect-up a Projection."""
+        local             = numpy.arange(len(projection.post))        
+        weights_generator = WeightGenerator(self.weights, local, projection, self.safe)
+        delays_generator  = DelayGenerator(self.delays, local, self.safe)
+        distance_matrix   = DistanceMatrix(projection.pre.positions, self.space)
+        candidates        = projection.pre.all_cells.flatten()                        
+        
+        if isinstance(projection.rng, random.NativeRNG):
+            raise Exception("Warning: use of NativeRNG not implemented.")
+            
+        for tgt in projection.post.local_cells.flat:
+            # pick n neurons at random
+            if hasattr(self, 'rand_distr'):
+                n = self.rand_distr.next()
+            else:
+                n = self.n
+            
+            sources = []
+            while len(sources) < n: # if the number of requested cells is larger than the size of the
+                                    # presynaptic population, we allow multiple connections for a given cell
+                ids     = projection.rng.permutation(candidates)[0:n] - projection.pre.first_id
+                sources = numpy.concatenate((sources, candidates[ids.astype(int)])) 
+                if not self.allow_self_connections and projection.pre == projection.post:
+                    i       = numpy.where(sources == tgt)[0]
+                    sources = numpy.delete(sources, i)
+            
+            sources = sources[:n].astype(int)
+            
+            if isinstance(self.weights, basestring) or isinstance(self.delays, basestring):      
+                distance_matrix.set_source(tgt.position)
+            
+            create  = sources - projection.pre.first_id
+            weights = weights_generator.get(n, distance_matrix, create)
+            delays  = delays_generator.get(n, distance_matrix, create)            
+                                            
+            for src, w, d in zip(sources, weights, delays):
+                projection.connection_manager.connect(src, [tgt], w, d)
+                    
+
+class OneToOneConnector(Connector):
+    """
+    Where the pre- and postsynaptic populations have the same size, connect
+    cell i in the presynaptic population to cell i in the postsynaptic
+    population for all i.
+    """
+    #In fact, despite the name, this should probably be generalised to the
+    #case where the pre and post populations have different dimensions, e.g.,
+    #cell i in a 1D pre population of size n should connect to all cells
+    #in row i of a 2D post population of size (n,m).
+    
+    
+    def __init__(self, weights=0.0, delays=None, space=Space()):
+        """
+        Create a new connector.
+        
+        `weights` -- may either be a float, a RandomDistribution object, a list/
+                     1D array with at least as many items as connections to be
+                     created. Units nA.
+        `delays`  -- as `weights`. If `None`, all synaptic delays will be set
+                     to the global minimum delay.
+        """
+        Connector.__init__(self, weights, delays, space)
+    
+    def connect(self, projection):
+        """Connect-up a Projection."""        
+        if projection.pre.dim == projection.post.dim:
+            N                 = projection.post.size
+            local             = projection.post._mask_local.flatten()
+            weights_generator = WeightGenerator(self.weights, local, projection)
+            delays_generator  = DelayGenerator(self.delays, local)                
+            weights           = weights_generator.get(N)
+            delays            = delays_generator.get(N)
+            
+            for tgt, w, d in zip(projection.post.local_cells, weights, delays):
+                src = projection.pre.index(projection.post.id_to_index(tgt))
+                
+                # 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))
+        else:
+            raise errors.InvalidDimensionsError("OneToOneConnector does not support presynaptic and postsynaptic Populations of different sizes.")