Esempio n. 1
0
 def __init__(self,
              cset,
              weights=None,
              delays=None,
              safe=True,
              verbose=False):
     """
     """
     min_delay = common.get_min_delay()
     Connector.__init__(self, None, None, safe=safe, verbose=verbose)
     self.cset = cset
     if csa.arity(cset) == 0:
         #assert weights is not None and delays is not None, \
         #       'must specify weights and delays in addition to a CSA mask'
         self.weights = weights
         if weights is None:
             self.weights = common.DEFAULT_WEIGHT
         self.delays = delays
         if delays is None:
             self.delays = common.get_min_delay()
     else:
         assert csa.arity(
             cset
         ) == 2, 'must specify mask or connection-set with arity 2'
         assert weights is None and delays is None, \
                "weights or delays specified both in connection-set and as CSAConnector argument"
Esempio n. 2
0
 def __init__(self, cset, safe=True, callback=None):
     """
     """
     Connector.__init__(self, safe=safe, callback=callback)
     self.cset = cset
     if csa.arity(cset) == 0:
         pass
     else:
         assert csa.arity(cset) == 2, 'must specify mask or connection-set with arity 2'
Esempio n. 3
0
 def __init__(self, cset, safe=True, callback=None):
     """
     """
     Connector.__init__(self, safe=safe, callback=callback)
     self.cset = cset
     if csa.arity(cset) == 0:
         pass
     else:
         assert csa.arity(cset) == 2, 'must specify mask or connection-set with arity 2'
Esempio n. 4
0
 def __init__(self, cset, safe=True, callback=None):
     """
     """
     Connector.__init__(self, safe=safe, callback=callback)
     self.cset = cset
     arity = csa.arity(cset)
     assert arity in (0, 2), 'must specify mask or connection-set with arity 0 or 2'
Esempio n. 5
0
 def __init__(self, cset, safe=True, callback=None):
     """
     """
     Connector.__init__(self, safe=safe, callback=callback)
     self.cset = cset
     arity = csa.arity(cset)
     assert arity in (0, 2), 'must specify mask or connection-set with arity 0 or 2'
Esempio n. 6
0
    def connect(self, projection):
        """Connect-up a Projection."""
        # Cut out finite part
        c = csa.cross((0, projection.pre.size - 1),
                      (0, projection.post.size - 1)) * self.cset

        if csa.arity(self.cset) == 2:
            # Connection-set with arity 2
            for (i, j, weight, delay) in c:
                projection.connection_manager.connect(projection.pre[i],
                                                      [projection.post[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(projection.pre[i],
                                                      [projection.post[j]],
                                                      self.weights,
                                                      self.delays)
        else:
            # Mask with weights and/or delays iterable
            weights = self.weights
            if CSAConnector.isConstant(weights):
                weights = CSAConnector.constantIterator(weights)
            delays = self.delays
            if CSAConnector.isConstant(delays):
                delays = CSAConnector.constantIterator(delays)
            for (i, j), weight, delay in zip(c, weights, delays):
                projection.connection_manager.connect(projection.pre[i],
                                                      [projection.post[j]],
                                                      weight, delay)
Esempio n. 7
0
    def connect(self, projection):
        """Connect-up a Projection."""
        if self.delays is None:
            self.delays = projection._simulator.state.min_delay
        # Cut out finite part
        c = csa.cross(
            (0, projection.pre.size - 1),
            (0, projection.post.size -
             1)) * self.cset  # can't we cut out just the columns we want?

        if csa.arity(self.cset) == 2:
            # Connection-set with arity 2
            for (i, j, weight, delay) in c:
                projection._convergent_connect([projection.pre[i]],
                                               projection.post[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._convergent_connect([projection.pre[i]],
                                               projection.post[j],
                                               self.weights, self.delays)
        else:
            # Mask with weights and/or delays iterable
            weights = self.weights
            if CSAConnector.isConstant(weights):
                weights = repeat(weights)
            delays = self.delays
            if CSAConnector.isConstant(delays):
                delays = repeat(delays)
            for (i, j), weight, delay in zip(c, weights, delays):
                projection._convergent_connect([projection.pre[i]],
                                               projection.post[j], weight,
                                               delay)
Esempio n. 8
0
    def connect(self, projection):
        """Connect-up a Projection."""
        if self.delays is None:
            self.delays = projection._simulator.state.min_delay
        # Cut out finite part
        c = csa.cross((0, projection.pre.size-1), (0, projection.post.size-1)) * self.cset  # can't we cut out just the columns we want?

        if csa.arity(self.cset) == 2:
            # Connection-set with arity 2
            for (i, j, weight, delay) in c:
                projection._convergent_connect([projection.pre[i]], projection.post[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._convergent_connect([projection.pre[i]], projection.post[j], self.weights, self.delays)
        else:
            # Mask with weights and/or delays iterable
            weights = self.weights
            if CSAConnector.isConstant(weights):
                weights = repeat(weights)
            delays = self.delays
            if CSAConnector.isConstant(delays):
                delays = repeat(delays)
            for (i, j), weight, delay in zip (c, weights, delays):
                projection._convergent_connect([projection.pre[i]], projection.post[j], weight, delay)
Esempio n. 9
0
 def __init__ (self, cset, weights=None, delays=None, safe=True, verbose=False):
     """
     """
     Connector.__init__(self, None, None, safe=safe, verbose=verbose)
     self.cset = cset
     if csa.arity(cset) == 0:
         #assert weights is not None and delays is not None, \
         #       'must specify weights and delays in addition to a CSA mask'
         self.weights = weights
         if weights is None:
             self.weights = DEFAULT_WEIGHT
         self.delays = delays
     else:
         assert csa.arity(cset) == 2, 'must specify mask or connection-set with arity 2'
         assert weights is None and delays is None, \
                "weights or delays specified both in connection-set and as CSAConnector argument"
Esempio n. 10
0
    def connect(self, projection):
        """Connect-up a Projection."""
        # Cut out finite part
        c = csa.cross((0, projection.pre.size - 1), (0, projection.post.size - 1)) * self.cset  # can't we cut out just the columns we want?

        if csa.arity(self.cset) == 2:
            # Connection-set with arity 2
            for (i, j, weight, delay) in c:
                projection._convergent_connect([projection.pre[i]], projection.post[j], weight, delay)
        elif csa.arity(self.cset) == 0:
            # inefficient implementation as a starting point
            connection_map = numpy.zeros((projection.pre.size, projection.post.size), dtype=bool)
            for addr in c:
                connection_map[addr] = True
            self._connect_with_map(projection, LazyArray(connection_map))
        else:
            raise NotImplementedError
Esempio n. 11
0
    def connect(self, projection):
        """Connect-up a Projection."""
        # Cut out finite part
        c = csa.cross((0, projection.pre.size - 1), (0, projection.post.size - 1)) * self.cset  # can't we cut out just the columns we want?

        if csa.arity(self.cset) == 2:
            # Connection-set with arity 2
            for (i, j, weight, delay) in c:
                projection._convergent_connect([projection.pre[i]], projection.post[j], weight, delay)
        elif csa.arity(self.cset) == 0:
            # inefficient implementation as a starting point
            connection_map = numpy.zeros((projection.pre.size, projection.post.size), dtype=bool)
            for addr in c:
                connection_map[addr] = True
            self._connect_with_map(projection, LazyArray(connection_map))
        else:
            raise NotImplementedError
Esempio n. 12
0
    def connect(self, projection):
        """Connect-up a Projection."""
        if self.delays is None:
            self.delays = projection._simulator.state.min_delay

        def connect_csa(cset, pre, post, syn_type):
            print "connecting using cset"
            if isinstance(pre, Population) and isinstance(post, Population):
                # contiguous IDs, so just pass first_id and size
                nest.sli_func("Connect_cg_i_i_i_i_D_l",
                              self.cset,
                              pre.first_id, pre.size,
                              post.first_id, post.size,
                              {'weight': 0, 'delay': 1}, # ignored if arity==0
                              syn_type)
            else: # PopulationViews or Assemblies
                # IDs may be non-contiguous, so need to pass entire arrays
                nest.sli_func("Connect_cg_a_a_D_l",
                              self.cset,
                              pre.all_cells,
                              post.all_cells,
                              {'weight': 0, 'delay': 1}, # ignored if arity==0
                              syn_type)
        # TODO: fix weights units
        if csa.arity(self.cset) == 2:
            # Connection-set with arity 2
            connect_csa(self.cset, projection.pre,
                        projection.post, projection.synapse_model)
        elif CSAConnector.isConstant(self.weights) \
            and CSAConnector.isConstant(self.delays):
            # Mask with constant weights and delays
            assert csa.arity(self.cset) == 0
            nest.SetDefaults(projection.synapse_model, {'weight': self.weights, 'delay': self.delays})
            connect_csa(self.cset, projection.pre,
                        projection.post, projection.synapse_model)
        projection._sources = projection.pre.all_cells
Esempio n. 13
0
        def connect(self, projection):
            """Connect-up a Projection."""

            presynaptic_cells = projection.pre.all_cells.astype('int64')
            postsynaptic_cells = projection.post.all_cells.astype('int64')

            if csa.arity(self.cset) == 2:
                param_map = {'weight': 0, 'delay': 1}
                nest.CGConnect(presynaptic_cells, postsynaptic_cells, self.cset,
                               param_map, projection.nest_synapse_model)
            else:
                nest.CGConnect(presynaptic_cells, postsynaptic_cells, self.cset,
                               model=projection.nest_synapse_model)

            projection._connections = None  # reset the caching of the connection list, since this will have to be recalculated
            projection._sources.extend(presynaptic_cells)
Esempio n. 14
0
        def connect(self, projection):
            """Connect-up a Projection."""

            presynaptic_cells = projection.pre.all_cells.astype('int64')
            postsynaptic_cells = projection.post.all_cells.astype('int64')

            if csa.arity(self.cset) == 2:
                param_map = {'weight': 0, 'delay': 1}
                nest.CGConnect(presynaptic_cells, postsynaptic_cells, self.cset,
                               param_map, projection.nest_synapse_model)
            else:
                nest.CGConnect(presynaptic_cells, postsynaptic_cells, self.cset,
                               model=projection.nest_synapse_model)

            projection._connections = None  # reset the caching of the connection list, since this will have to be recalculated
            projection._sources.extend(presynaptic_cells)