Changeset 724 for trunk/src/nest/connectors.py

Timestamp:

03/05/10 15:33:46 (2 years ago)

Author:

pierre

Message:

Commit an home made version of the DistanceDependentProbabilityConnector? for NEST. Again, this is much faster than the generic implementation. Only this implementation scales and can be used for large scale networks. It is time and memory efficient, the only difference is that weights and delays are not saved in the connector. But anyway, I don't think that the way it is currently done in the generic implementation is efficient: those weights and delays should not be kept by the Connector, and I think that the Probabilistic object should be called for each sources, and not only once.

Files:

• trunk/src/nest/connectors.py (modified) (3 diffs)

trunk/src/nest/connectors.py

@@ -4 +4 @@
 $Id$
 """
-from pyNN import random, common
-
+from pyNN import random, common, core
+from numpy import arccos, arcsin, arctan, arctan2, ceil, cos, cosh, e, exp, \
+                  fabs, floor, fmod, hypot, ldexp, log, log10, modf, pi, power, \
+                  sin, sinh, sqrt, tan, tanh
 from pyNN.connectors import AllToAllConnector, \
                             OneToOneConnector, \
@@ -14 +16 @@
                             FixedNumberPreConnector, \
                             FixedNumberPostConnector
-
+import numpy
 
 class FixedNumberPreConnector(FixedNumberPreConnector):
@@ -48 +50 @@
             
             projection.connection_manager.convergent_connect(sources, [target], weights, delays)
+
+
+class DistanceDependentProbabilityConnector(DistanceDependentProbabilityConnector):
+
+    __doc__ = DistanceDependentProbabilityConnector.__doc__
+    
+    def connect(self, projection):
+        """Connect-up a Projection."""
+        local          = projection.post._mask_local.flatten()
+        positions      = self.space.scale_factor*(projection.post.positions[:, local] + self.space.offset)
+        N              = projection.post.size            
+        is_conductance = common.is_conductance(projection.post.index(0))   
+        
+        if isinstance(projection.rng, random.NativeRNG):
+            raise Exception("Use of NativeRNG not implemented.")
+        else:
+            rng = projection.rng
+        
+        for src in projection.pre.all():            
+            d     = self.space.distances(src.position, positions).flatten()
+            proba = eval(self.d_expression)
+            if proba.dtype == 'bool':
+                proba = proba.astype(float)
+            rarr = rng.next(N, 'uniform', (0, 1), mask_local=local)
+            if not core.is_listlike(rarr) and numpy.isscalar(rarr): # if N=1, rarr will be a single number
+                rarr = numpy.array([rarr])
+            create = rarr < proba
+            if create.shape != projection.post.local_cells.shape:
+                logger.warning("Too many random numbers. Discarding the excess. Did you specify MPI rank and number of processes when you created the random number generator?")
+                create = create[:projection.post.local_cells.size]
+            targets = projection.post.local_cells[create].tolist()
+            
+            if hasattr(self, 'w_expr'):
+                weights = eval(self.w_expr)[create]
+            else:
+                weights = self.get_weights(N, local)[create]            
+            weights = common.check_weight(weights, projection.synapse_type, is_conductance)
+            
+            if hasattr(self, 'd_expr'):
+                delays = eval(self.d_expr)[create]
+            else:
+                delays = self.get_delays(N, local)[create]            
+                
+            if not self.allow_self_connections and projection.pre == projection.post and src in targets:
+                assert len(targets) == len(weights) == len(delays)
+                i       = targets.index(src)
+                weights = numpy.delete(weights, i)
+                delays  = numpy.delete(delays, i)
+                targets.remove(src)
+
+            if len(targets) > 0:
+                projection.connection_manager.connect(src, targets, weights, delays)