6971580850

Committed 23 Nov 2023 03:19PM UTC coverage: 63.042% (-0.1%) from 63.152%

Build # 6971580850

Build Type

Pull #1345

github

Committed by

rowleya

Commit Message

Fix the atoms per dimension per core issue

Pull Request Pull Request #1345: Interdimensional compatibility

Run Details

1902 of 4417 branches covered (0.0%)

Branch coverage included in aggregate %.

192 of 517 new or added lines in 39 files covered. (37.14%)

72 existing lines in 24 files now uncovered.

12648 of 18663 relevant lines covered (67.77%)

0.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.3

/spynnaker/pyNN/models/common/population_application_vertex.py

# Copyright (c) 2020 The University of Manchester
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import Collection, Container, Iterable, List, Optional, Tuple
from spinn_utilities.overrides import overrides
from spinn_utilities.ranged.abstract_sized import Selector
from pacman.model.graphs.application import ApplicationVertex
from pacman.model.graphs.machine import MachineVertex
from pacman.model.graphs.common import Slice
from pacman.model.routing_info import RoutingInfo
from pacman.utilities.utility_calls import get_keys
from spinn_front_end_common.utilities.exceptions import ConfigurationException
from spinn_front_end_common.abstract_models import HasCustomAtomKeyMap
from spinn_front_end_common.interface.ds import DataType
from spynnaker.pyNN.models.common.parameter_holder import ParameterHolder
from spynnaker.pyNN.utilities.buffer_data_type import BufferDataType
from spynnaker.pyNN.models.current_sources import AbstractCurrentSource
from .types import Names, Values


# pylint: disable=abstract-method
class PopulationApplicationVertex(ApplicationVertex, HasCustomAtomKeyMap):
    """
    A vertex that can be used in a Population.

    Provides some default functions that can be overridden if the vertex
    supports these.
    """

    # No data required here; makes it easy to mix in!
    __slots__ = ()

    @staticmethod
    def _as_list(names: Names) -> List[str]:
        """
        Normalise the input to a list.

        :param names: The item or items to normalise
        :type names: str or list
        :rtype: list(str)
        """
        if isinstance(names, str):
            return [names]
        return list(names)

    @staticmethod
    def _check_names(names: Names, allowed: Container[str],
                     type_of_thing: str):
        """
        Check the list of names are allowed or not.

        :param names: The names to check
        :type names: str or list
        :param set(str) allowed: The set of allowed names
        :param str type_of_thing: The "type of thing" to report in any error
        :raises KeyError: If one of the names is not allowed
        """
        for name in PopulationApplicationVertex._as_list(names):
            if name not in allowed:
                raise KeyError(f"{name} is not a recognized {type_of_thing}")

    @staticmethod
    def _check_parameters(names: Names, allowed: Container[str]):
        """
        Check that parameters are allowed.

        :param names: The names to check
        :type names: str or list
        :param set(str) allowed: The set of allowed names
        """
        PopulationApplicationVertex._check_names(names, allowed, "parameter")

    @staticmethod
    def _check_variables(names: Names, allowed: Container[str]):
        """
        Check that state variables are allowed.

        :param names: The names to check
        :type names: str or list
        :param set(str) allowed: The set of allowed names
        """
        PopulationApplicationVertex._check_names(names, allowed, "variable")

    def get_parameter_values(
            self, names: Names, selector: Selector = None) -> ParameterHolder:
        """
        Get the values of a parameter or parameters for the whole
        Population or a subset if the selector is used.

        :param names: The name or names of the parameter to get
        :type names: str or list
        :param selector: a description of the subrange to accept, or ``None``
            for all. See:
            :py:meth:`~spinn_utilities.ranged.AbstractSized.selector_to_ids`
        :type selector: None or slice or int or list(bool) or list(int)
        :rtype: ParameterHolder
        :raise KeyError: if the parameter is not something that can be read
        """
        raise KeyError(
            "This Population does not support the reading of parameters")

    def set_parameter_values(
            self, name: str, value: Values, selector: Selector = None):
        """
        Set the values of a parameter for the whole Population or a subset
        if the selector is used.

        :param str name: The name of the parameter to set
        :param selector: a description of the subrange to accept, or ``None``
            for all. See:
            :py:meth:`~spinn_utilities.ranged.AbstractSized.selector_to_ids`
        :type selector: None or slice or int or list(bool) or list(int)
        :raise KeyError: if the parameter is not something that can be changed
        """
        raise KeyError(
            "This Population does not support the setting of parameters")

    def get_parameters(self) -> List[str]:
        """
        Get the names of all the parameters that can be obtained

        :rtype: list(str)
        """
        return []

    def get_initial_state_values(
            self, names: Names, selector: Selector = None) -> ParameterHolder:
        """
        Get the initial values of a state variable for the whole Population
        or a subset if the selector is used.

        :param names: The name or names of the variable to get
        :type names: str or list(str)
        :param selector: a description of the subrange to accept, or ``None``
            for all. See:
            :py:meth:`~spinn_utilities.ranged.AbstractSized.selector_to_ids`
        :type selector: None or slice or int or list(bool) or list(int)
        :rtype: ParameterHolder
        :raise KeyError: if the variable is not something that can be read
        """
        raise KeyError(
            "This Population does not support the reading of state"
            " variables")

    def set_initial_state_values(
            self, name: str, value: Values, selector: Selector = None):
        """
        Set the initial values of a state variable for the whole Population
        or a subset if the selector is used.

        :param str name: The name of the variable to set
        :param selector: a description of the subrange to accept, or ``None``
            for all. See:
            :py:meth:`~spinn_utilities.ranged.AbstractSized.selector_to_ids`
        :type selector: None or slice or int or list(bool) or list(int)
        :raise KeyError: if the variable is not something that can be changed
        """
        raise KeyError(
            "This Population does not support the initialization of state"
            " variables")

    def get_current_state_values(
            self, names: Names, selector: Selector = None) -> ParameterHolder:
        """
        Get the current values of a state variable for the whole Population
        or a subset if the selector is used.

        :param names: The name or names of the variable to get
        :type names: str or list(str)
        :param selector: a description of the subrange to accept, or ``None``
            for all. See:
            :py:meth:`~spinn_utilities.ranged.AbstractSized.selector_to_ids`
        :type selector: None or slice or int or list(bool) or list(int)
        :rtype: ParameterHolder
        :raise KeyError: if the variable is not something that can be read
        """
        raise KeyError(
            "This Population does not support the reading of state"
            " variables")

    def set_current_state_values(
            self, name: str, value: Values, selector: Selector = None):
        """
        Set the current values of a state variable for the whole Population
        or a subset if the selector is used.

        :param str name: The name of the variable to set
        :param selector: a description of the subrange to accept, or ``None``
            for all. See:
            :py:meth:`~spinn_utilities.ranged.AbstractSized.selector_to_ids`
        :type selector: None or slice or int or list(bool) or list(int)
        :raise KeyError: if the variable is not something that can be changed
        """
        raise KeyError(
            "This Population does not support the setting of state"
            " variables")

    def get_state_variables(self) -> List[str]:
        """
        Get a list of supported state variables.

        :rtype: list(str)
        """
        return []

    def get_units(self, name: str) -> str:
        """
        Get the units of the given parameter or state variable.

        :param str name: the name of the parameter to get the units of
        :rtype: str
        :raise KeyError:
            if the name isn't recognised or the units cannot be identified
        """
        raise KeyError(f"The units for {name} cannot be found")

    @property
    def conductance_based(self) -> bool:
        """
        Whether the vertex models post-synaptic inputs as
        currents or conductance.

        By default this is False; override if the model accepts
        conductance based input.

        :rtype: bool
        """
        return False

    # recording methods
    # If get_recordable_variables implemented other recording methods must
    # be too

    def get_recordable_variables(self) -> List[str]:
        """
        Get a list of the names and types of things that can be recorded.

        This methods list the variable recorded via the Population.

        :rtype: list(str)
        """
        return []

    def set_recording(
            self, name: str, sampling_interval: Optional[float] = None,
            indices: Optional[Collection[int]] = None):
        """
        Set a variable recording.

        :param str name: The name of the variable to set the status of
        :param sampling_interval:
            How often the variable should be recorded or `None` for every
            time step, in milliseconds
        :type sampling_interval: float or None
        :param indices: The list of neuron indices to record or `None` for all
        :type indices: list(int) or None
        :raises KeyError: if the variable cannot be recorded
        """
        # pylint: disable=unused-argument
        if not self.get_recordable_variables():
            raise KeyError("This Population does not support recording")
        raise NotImplementedError(
            f"{type(self)} has recording variables so should implement "
            f"set_recording")

    def set_not_recording(
            self, name: str, indices: Optional[Collection[int]] = None):
        """
        Set a variable not recording.

        :param str name: The name of the variable to not record
        :param indices:
            The list of neuron indices to not record or `None` for all
        :type indices: list(int) or None
        :raises KeyError: if the variable cannot be stopped from recording
        """
        # pylint: disable=unused-argument
        if not self.get_recordable_variables():
            raise KeyError("This Population does not support recording")
        raise NotImplementedError(
            f"{type(self)} has recording variables so should implement "
            f"set_not_recording")

    def get_recording_variables(self) -> List[str]:
        """
        Get a list of variables that are currently being recorded.

        :rtype: list(str)
        """
        if not self.get_recordable_variables():
            return []
        raise NotImplementedError(
            f"{type(self)} has recording variables so should implement "
            f"get_recording_variables")

    def get_buffer_data_type(self, name: str) -> BufferDataType:
        """
        Get the type of data recorded by the buffer manager.

        The buffer data type controls how data returned by the cores is
        handled in NeoBufferDatabase.

        :param str name: The name of the variable recorded
        :rtype:
            ~spinn_front_end_common.interface.buffer_management.storage_objects.BufferDatabase
        :raises KeyError: if the variable isn't being recorded
        """
        if name not in self.get_recordable_variables():
            raise KeyError(f"{name} is not being recorded")
        raise NotImplementedError(
            f"{type(self)} has recording variables so should implement "
            f"get_recording_variables")

    def get_sampling_interval_ms(self, name: str) -> float:
        """
        Get the sampling interval of the recording for the given variable.

        The values is in ms and unless selective recording is used will be
        `SpynnakerDataView.get_simulation_time_step_us()`

        :rtype: float
        :raises KeyError: If the variable isn't being recorded
        """
        if name not in self.get_recordable_variables():
            raise KeyError(f"{name} is not being recorded")
        raise NotImplementedError(
            f"{type(self)} has recording variables so should implement "
            f"get_recording_variables")

    def get_data_type(self, name: str) -> Optional[DataType]:
        """
        Get the type data returned by a recording of the variable.

        This is the type of data the C code is returning.
        For instance data such as spikes this will be `None`.

        :param str name: The name of the variable to get the type of
        :rtype: ~data_specification.enums.DataType or None
        :raise KeyError: If the variable isn't recordable
        """
        if name not in self.get_recordable_variables():
            raise KeyError(f"{name} is not being recorded")
        raise NotImplementedError(
            f"{type(self)} has recording variables so should implement "
            f"get_data_type")

    def get_recording_region(self, name: str) -> int:
        """
        Gets the recording region for the named variable.

        :param str name: The name of the variable to get the region of
        :rtype: int
        :raises KeyError: If the variable isn't being recorded
        """
        if name not in self.get_recordable_variables():
            raise KeyError(f"{name} is not being recorded")
        raise NotImplementedError(
            f"{type(self)} has recording variables so should implement "
            f"get_recording_region")

    def get_neurons_recording(
            self, name: str, vertex_slice: Slice) -> Optional[Collection[int]]:
        """
        Gets the neurons being recorded on the core with this slice.

        Typically `vertex_slice.get_raster_ids(atoms_shape)`
        but may be a sublist if doing selective recording.

        :param str name: The name of the variable to get the region of
        :param ~pacman.model.graphs.common.Slice vertex_slice:
        :return: A list of the global raster IDs of the atoms in recording
            named variable within this slice
        :rtype: list(int)
        """
        # pylint: disable=unused-argument
        if name not in self.get_recordable_variables():
            raise KeyError(f"{name} is not being recorded")
        raise NotImplementedError(
            f"{type(self)} has recording variables so should implement "
            f"get_neurons_recording")

    # end of recording methods

    def inject(self, current_source: AbstractCurrentSource,
               selector: Selector = None):
        """
        Inject a current source into this population.

        :param AbstractCurrentSource current_source:
            the current source to be injected
        :param selector: a description of the subrange to accept, or ``None``
            for all. See:
            :py:meth:`~spinn_utilities.ranged.AbstractSized.selector_to_ids`
        :type selector: None or slice or int or list(bool) or list(int)
        :raises \
            ~spinn_front_end_common.utilities.exceptions.ConfigurationException:
            if the population doesn't support injection
        """
        raise ConfigurationException(
            "This Population doesn't support injection")

    @property
    def n_colour_bits(self) -> int:
        """
        The number of colour bits sent by this vertex.

        Assumed 0 unless overridden

        :rtype: int
        """
        return 0

    @overrides(HasCustomAtomKeyMap.get_atom_key_map)
    def get_atom_key_map(
            self, pre_vertex: MachineVertex, partition_id: str,
            routing_info: RoutingInfo) -> Iterable[Tuple[int, int]]:
        base_key = routing_info.get_first_key_from_pre_vertex(
            pre_vertex, partition_id)
        # This might happen if there are no edges
        if base_key is None:
            base_key = 0
        vertex_slice = pre_vertex.vertex_slice
        keys = get_keys(base_key, vertex_slice, self.n_colour_bits)
        return zip(vertex_slice.get_raster_ids(), keys)

1	# Copyright (c) 2020 The University of Manchester
2	#
3	# Licensed under the Apache License, Version 2.0 (the "License");
4	# you may not use this file except in compliance with the License.
5	# You may obtain a copy of the License at
6	#
7	# https://www.apache.org/licenses/LICENSE-2.0
8	#
9	# Unless required by applicable law or agreed to in writing, software
10	# distributed under the License is distributed on an "AS IS" BASIS,
11	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	# See the License for the specific language governing permissions and
13	# limitations under the License.
14	from typing import Collection, Container, Iterable, List, Optional, Tuple	1✔
15	from spinn_utilities.overrides import overrides	1✔
16	from spinn_utilities.ranged.abstract_sized import Selector	1✔
17	from pacman.model.graphs.application import ApplicationVertex	1✔
18	from pacman.model.graphs.machine import MachineVertex	1✔
19	from pacman.model.graphs.common import Slice	1✔
20	from pacman.model.routing_info import RoutingInfo	1✔
21	from pacman.utilities.utility_calls import get_keys	1✔
22	from spinn_front_end_common.utilities.exceptions import ConfigurationException	1✔
23	from spinn_front_end_common.abstract_models import HasCustomAtomKeyMap	1✔
24	from spinn_front_end_common.interface.ds import DataType	1✔
25	from spynnaker.pyNN.models.common.parameter_holder import ParameterHolder	1✔
26	from spynnaker.pyNN.utilities.buffer_data_type import BufferDataType	1✔
27	from spynnaker.pyNN.models.current_sources import AbstractCurrentSource	1✔
28	from .types import Names, Values	1✔
29
30
31	# pylint: disable=abstract-method
32	class PopulationApplicationVertex(ApplicationVertex, HasCustomAtomKeyMap):	1✔
33	"""
34	A vertex that can be used in a Population.
35
36	Provides some default functions that can be overridden if the vertex
37	supports these.
38	"""
39
40	# No data required here; makes it easy to mix in!
41	__slots__ = ()	1✔
42
43	@staticmethod	1✔
44	def _as_list(names: Names) -> List[str]:	1✔
45	"""
46	Normalise the input to a list.
47
48	:param names: The item or items to normalise
49	:type names: str or list
50	:rtype: list(str)
51	"""
52	if isinstance(names, str):	1✔
53	return [names]	1✔
54	return list(names)	1✔
55
56	@staticmethod	1✔
57	def _check_names(names: Names, allowed: Container[str],	1✔
58	type_of_thing: str):
59	"""
60	Check the list of names are allowed or not.
61
62	:param names: The names to check
63	:type names: str or list
64	:param set(str) allowed: The set of allowed names
65	:param str type_of_thing: The "type of thing" to report in any error
66	:raises KeyError: If one of the names is not allowed
67	"""
68	for name in PopulationApplicationVertex._as_list(names):	1✔
69	if name not in allowed:	1✔
70	raise KeyError(f"{name} is not a recognized {type_of_thing}")	1✔
71
72	@staticmethod	1✔
73	def _check_parameters(names: Names, allowed: Container[str]):	1✔
74	"""
75	Check that parameters are allowed.
76
77	:param names: The names to check
78	:type names: str or list
79	:param set(str) allowed: The set of allowed names
80	"""
81	PopulationApplicationVertex._check_names(names, allowed, "parameter")	1✔
82
83	@staticmethod	1✔
84	def _check_variables(names: Names, allowed: Container[str]):	1✔
85	"""
86	Check that state variables are allowed.
87
88	:param names: The names to check
89	:type names: str or list
90	:param set(str) allowed: The set of allowed names
91	"""
92	PopulationApplicationVertex._check_names(names, allowed, "variable")	1✔
93
94	def get_parameter_values(	1✔
95	self, names: Names, selector: Selector = None) -> ParameterHolder:
96	"""
97	Get the values of a parameter or parameters for the whole
98	Population or a subset if the selector is used.
99
100	:param names: The name or names of the parameter to get
101	:type names: str or list
102	:param selector: a description of the subrange to accept, or ``None``
103	for all. See:
104	:py:meth:`~spinn_utilities.ranged.AbstractSized.selector_to_ids`
105	:type selector: None or slice or int or list(bool) or list(int)
106	:rtype: ParameterHolder
107	:raise KeyError: if the parameter is not something that can be read
108	"""
109	raise KeyError(	×
110	"This Population does not support the reading of parameters")
111
112	def set_parameter_values(	1✔
113	self, name: str, value: Values, selector: Selector = None):
114	"""
115	Set the values of a parameter for the whole Population or a subset
116	if the selector is used.
117
118	:param str name: The name of the parameter to set
119	:param selector: a description of the subrange to accept, or ``None``
120	for all. See:
121	:py:meth:`~spinn_utilities.ranged.AbstractSized.selector_to_ids`
122	:type selector: None or slice or int or list(bool) or list(int)
123	:raise KeyError: if the parameter is not something that can be changed
124	"""
125	raise KeyError(	×
126	"This Population does not support the setting of parameters")
127
128	def get_parameters(self) -> List[str]:	1✔
129	"""
130	Get the names of all the parameters that can be obtained
131
132	:rtype: list(str)
133	"""
134	return []	×
135
136	def get_initial_state_values(	1✔
137	self, names: Names, selector: Selector = None) -> ParameterHolder:
138	"""
139	Get the initial values of a state variable for the whole Population
140	or a subset if the selector is used.
141
142	:param names: The name or names of the variable to get
143	:type names: str or list(str)
144	:param selector: a description of the subrange to accept, or ``None``
145	for all. See:
146	:py:meth:`~spinn_utilities.ranged.AbstractSized.selector_to_ids`
147	:type selector: None or slice or int or list(bool) or list(int)
148	:rtype: ParameterHolder
149	:raise KeyError: if the variable is not something that can be read
150	"""
151	raise KeyError(	1✔
152	"This Population does not support the reading of state"
153	" variables")
154
155	def set_initial_state_values(	1✔
156	self, name: str, value: Values, selector: Selector = None):
157	"""
158	Set the initial values of a state variable for the whole Population
159	or a subset if the selector is used.
160
161	:param str name: The name of the variable to set
162	:param selector: a description of the subrange to accept, or ``None``
163	for all. See:
164	:py:meth:`~spinn_utilities.ranged.AbstractSized.selector_to_ids`
165	:type selector: None or slice or int or list(bool) or list(int)
166	:raise KeyError: if the variable is not something that can be changed
167	"""
168	raise KeyError(	1✔
169	"This Population does not support the initialization of state"
170	" variables")
171
172	def get_current_state_values(	1✔
173	self, names: Names, selector: Selector = None) -> ParameterHolder:
174	"""
175	Get the current values of a state variable for the whole Population
176	or a subset if the selector is used.
177
178	:param names: The name or names of the variable to get
179	:type names: str or list(str)
180	:param selector: a description of the subrange to accept, or ``None``
181	for all. See:
182	:py:meth:`~spinn_utilities.ranged.AbstractSized.selector_to_ids`
183	:type selector: None or slice or int or list(bool) or list(int)
184	:rtype: ParameterHolder
185	:raise KeyError: if the variable is not something that can be read
186	"""
187	raise KeyError(	×
188	"This Population does not support the reading of state"
189	" variables")
190
191	def set_current_state_values(	1✔
192	self, name: str, value: Values, selector: Selector = None):
193	"""
194	Set the current values of a state variable for the whole Population
195	or a subset if the selector is used.
196
197	:param str name: The name of the variable to set
198	:param selector: a description of the subrange to accept, or ``None``
199	for all. See:
200	:py:meth:`~spinn_utilities.ranged.AbstractSized.selector_to_ids`
201	:type selector: None or slice or int or list(bool) or list(int)
202	:raise KeyError: if the variable is not something that can be changed
203	"""
204	raise KeyError(	×
205	"This Population does not support the setting of state"
206	" variables")
207
208	def get_state_variables(self) -> List[str]:	1✔
209	"""
210	Get a list of supported state variables.
211
212	:rtype: list(str)
213	"""
214	return []	1✔
215
216	def get_units(self, name: str) -> str:	1✔
217	"""
218	Get the units of the given parameter or state variable.
219
220	:param str name: the name of the parameter to get the units of
221	:rtype: str
222	:raise KeyError:
223	if the name isn't recognised or the units cannot be identified
224	"""
225	raise KeyError(f"The units for {name} cannot be found")	×
226
227	@property	1✔
228	def conductance_based(self) -> bool:	1✔
229	"""
230	Whether the vertex models post-synaptic inputs as
231	currents or conductance.
232
233	By default this is False; override if the model accepts
234	conductance based input.
235
236	:rtype: bool
237	"""
238	return False	×
239
240	# recording methods
241	# If get_recordable_variables implemented other recording methods must
242	# be too
243
244	def get_recordable_variables(self) -> List[str]:	1✔
245	"""
246	Get a list of the names and types of things that can be recorded.
247
248	This methods list the variable recorded via the Population.
249
250	:rtype: list(str)
251	"""
252	return []	1✔
253
254	def set_recording(	1✔
255	self, name: str, sampling_interval: Optional[float] = None,
256	indices: Optional[Collection[int]] = None):
257	"""
258	Set a variable recording.
259
260	:param str name: The name of the variable to set the status of
261	:param sampling_interval:
262	How often the variable should be recorded or `None` for every
263	time step, in milliseconds
264	:type sampling_interval: float or None
265	:param indices: The list of neuron indices to record or `None` for all
266	:type indices: list(int) or None
267	:raises KeyError: if the variable cannot be recorded
268	"""
269	# pylint: disable=unused-argument
270	if not self.get_recordable_variables():	×
271	raise KeyError("This Population does not support recording")	×
272	raise NotImplementedError(
273	f"{type(self)} has recording variables so should implement "
274	f"set_recording")
275
276	def set_not_recording(	1✔
277	self, name: str, indices: Optional[Collection[int]] = None):
278	"""
279	Set a variable not recording.
280
281	:param str name: The name of the variable to not record
282	:param indices:
283	The list of neuron indices to not record or `None` for all
284	:type indices: list(int) or None
285	:raises KeyError: if the variable cannot be stopped from recording
286	"""
287	# pylint: disable=unused-argument
288	if not self.get_recordable_variables():	×
289	raise KeyError("This Population does not support recording")	×
290	raise NotImplementedError(
291	f"{type(self)} has recording variables so should implement "
292	f"set_not_recording")
293
294	def get_recording_variables(self) -> List[str]:	1✔
295	"""
296	Get a list of variables that are currently being recorded.
297
298	:rtype: list(str)
299	"""
300	if not self.get_recordable_variables():	1✔
301	return []	1✔
302	raise NotImplementedError(
303	f"{type(self)} has recording variables so should implement "
304	f"get_recording_variables")
305
306	def get_buffer_data_type(self, name: str) -> BufferDataType:	1✔
307	"""
308	Get the type of data recorded by the buffer manager.
309
310	The buffer data type controls how data returned by the cores is
311	handled in NeoBufferDatabase.
312
313	:param str name: The name of the variable recorded
314	:rtype:
315	~spinn_front_end_common.interface.buffer_management.storage_objects.BufferDatabase
316	:raises KeyError: if the variable isn't being recorded
317	"""
318	if name not in self.get_recordable_variables():	×
319	raise KeyError(f"{name} is not being recorded")	×
320	raise NotImplementedError(
321	f"{type(self)} has recording variables so should implement "
322	f"get_recording_variables")
323
324	def get_sampling_interval_ms(self, name: str) -> float:	1✔
325	"""
326	Get the sampling interval of the recording for the given variable.
327
328	The values is in ms and unless selective recording is used will be
329	`SpynnakerDataView.get_simulation_time_step_us()`
330
331	:rtype: float
332	:raises KeyError: If the variable isn't being recorded
333	"""
334	if name not in self.get_recordable_variables():	×
335	raise KeyError(f"{name} is not being recorded")	×
336	raise NotImplementedError(
337	f"{type(self)} has recording variables so should implement "
338	f"get_recording_variables")
339
340	def get_data_type(self, name: str) -> Optional[DataType]:	1✔
341	"""
342	Get the type data returned by a recording of the variable.
343
344	This is the type of data the C code is returning.
345	For instance data such as spikes this will be `None`.
346
347	:param str name: The name of the variable to get the type of
348	:rtype: ~data_specification.enums.DataType or None
349	:raise KeyError: If the variable isn't recordable
350	"""
351	if name not in self.get_recordable_variables():	×
352	raise KeyError(f"{name} is not being recorded")	×
353	raise NotImplementedError(
354	f"{type(self)} has recording variables so should implement "
355	f"get_data_type")
356
357	def get_recording_region(self, name: str) -> int:	1✔
358	"""
359	Gets the recording region for the named variable.
360
361	:param str name: The name of the variable to get the region of
362	:rtype: int
363	:raises KeyError: If the variable isn't being recorded
364	"""
365	if name not in self.get_recordable_variables():	×
366	raise KeyError(f"{name} is not being recorded")	×
367	raise NotImplementedError(
368	f"{type(self)} has recording variables so should implement "
369	f"get_recording_region")
370
371	def get_neurons_recording(	1✔
372	self, name: str, vertex_slice: Slice) -> Optional[Collection[int]]:
373	"""
374	Gets the neurons being recorded on the core with this slice.
375
376	Typically `vertex_slice.get_raster_ids(atoms_shape)`
377	but may be a sublist if doing selective recording.
378
379	:param str name: The name of the variable to get the region of
380	:param ~pacman.model.graphs.common.Slice vertex_slice:
381	:return: A list of the global raster IDs of the atoms in recording
382	named variable within this slice
383	:rtype: list(int)
384	"""
385	# pylint: disable=unused-argument
386	if name not in self.get_recordable_variables():	×
387	raise KeyError(f"{name} is not being recorded")	×
388	raise NotImplementedError(
389	f"{type(self)} has recording variables so should implement "
390	f"get_neurons_recording")
391
392	# end of recording methods
393
394	def inject(self, current_source: AbstractCurrentSource,	1✔
395	selector: Selector = None):
396	"""
397	Inject a current source into this population.
398
399	:param AbstractCurrentSource current_source:
400	the current source to be injected
401	:param selector: a description of the subrange to accept, or ``None``
402	for all. See:
403	:py:meth:`~spinn_utilities.ranged.AbstractSized.selector_to_ids`
404	:type selector: None or slice or int or list(bool) or list(int)
405	:raises \
406	~spinn_front_end_common.utilities.exceptions.ConfigurationException:
407	if the population doesn't support injection
408	"""
409	raise ConfigurationException(	×
410	"This Population doesn't support injection")
411
412	@property	1✔
413	def n_colour_bits(self) -> int:	1✔
414	"""
415	The number of colour bits sent by this vertex.
416
417	Assumed 0 unless overridden
418
419	:rtype: int
420	"""
421	return 0	1✔
422
423	@overrides(HasCustomAtomKeyMap.get_atom_key_map)	1✔
424	def get_atom_key_map(	1✔
425	self, pre_vertex: MachineVertex, partition_id: str,
426	routing_info: RoutingInfo) -> Iterable[Tuple[int, int]]:
427	base_key = routing_info.get_first_key_from_pre_vertex(	×
428	pre_vertex, partition_id)
429	# This might happen if there are no edges
430	if base_key is None:	×
431	base_key = 0	×
432	vertex_slice = pre_vertex.vertex_slice	×
NEW 433	keys = get_keys(base_key, vertex_slice, self.n_colour_bits)	×
NEW 434	return zip(vertex_slice.get_raster_ids(), keys)	×

SpiNNakerManchester / sPyNNaker / 6971580850

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous