Example #1
0
    def connect(self, projection):
        """Connect-up a Projection."""
        if projection.pre.size == projection.post.size:
            N = projection.post.size
            local = projection.post._mask_local
            if isinstance(self.weights, basestring) or isinstance(
                    self.delays, basestring):
                raise Exception(
                    'Expression for weights or delays is not supported for OneToOneConnector !'
                )
            weights_generator = WeightGenerator(self.weights, local,
                                                projection, self.safe)
            delays_generator = DelayGenerator(self.delays, local, self.safe)
            weights = weights_generator.get(N)
            delays = delays_generator.get(N)
            self.progressbar(len(projection.post.local_cells))
            count = 0
            create = numpy.arange(0, N)[local]
            sources = projection.pre.all_cells[create]

            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)])
                self.progression(count)
                count += 1
        else:
            raise errors.InvalidDimensionsError(
                "OneToOneConnector does not support presynaptic and postsynaptic Populations of different sizes."
            )
Example #2
0
    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()
            if isinstance(self.weights, basestring) or isinstance(
                    self.delays, basestring):
                raise Exception(
                    'Expression for weights or delays is not supported for OneToOneConnector !'
                )
            weights_generator = WeightGenerator(self.weights, local,
                                                projection, self.safe)
            delays_generator = DelayGenerator(self.delays, local, self.safe)
            weights = weights_generator.get(N)
            delays = delays_generator.get(N)
            self.progressbar(len(projection.post.local_cells))
            count = 0

            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._divergent_connect(src, [tgt], float(w), float(d))
                self.progression(count)
                count += 1
        else:
            raise errors.InvalidDimensionsError(
                "OneToOneConnector does not support presynaptic and postsynaptic Populations of different sizes."
            )
Example #3
0
    def update(self, **parameters):
        """
        Update the contents of the parameter space according to the
        `(key, value)` pairs in ``**parameters``. All values will be turned into
        lazy arrays.

        If the :class:`ParameterSpace` has a schema, the keys and the data types
        of the values will be checked against the schema.
        """
        if self.schema:
            for name, value in parameters.items():
                try:
                    expected_dtype = self.schema[name]
                except KeyError:
                    if self.component:
                        model_name = self.component.__name__
                    else:
                        model_name = 'unknown'
                    raise errors.NonExistentParameterError(
                        name,
                        model_name,
                        valid_parameter_names=self.schema.keys())
                if issubclass(expected_dtype, ArrayParameter) and isinstance(
                        value, collections.Sized):
                    if len(value) == 0:
                        value = ArrayParameter([])
                    elif not isinstance(
                            value[0], ArrayParameter
                    ):  # may be a more generic way to do it, but for now this special-casing seems like the most robust approach
                        if isinstance(
                                value[0],
                                collections.Sized):  # e.g. list of tuples
                            value = type(value)(
                                [ArrayParameter(x) for x in value])
                        else:
                            value = ArrayParameter(value)
                try:
                    self._parameters[name] = LazyArray(value,
                                                       shape=self._shape,
                                                       dtype=expected_dtype)
                except (TypeError, errors.InvalidParameterValueError):
                    raise errors.InvalidParameterValueError(
                        "For parameter %s expected %s, got %s" %
                        (name, expected_dtype, type(value)))
                except ValueError as err:
                    raise errors.InvalidDimensionsError(
                        err
                    )  # maybe put the more specific error classes into lazyarray
        else:
            for name, value in parameters.items():
                self._parameters[name] = LazyArray(value, shape=self._shape)