def _assert_array_indices(self, slice_tuple): if is_integer(slice_tuple) or isinstance(slice_tuple, string_types): return ([slice_tuple],) else: if isinstance(slice_tuple, slice): slice_tuple = (slice_tuple,) slice_list = [] for slc in slice_tuple: if is_integer(slc) or isinstance(slc, string_types): slice_list.append([slc]) else: slice_list.append(slc) return tuple(slice_list)
def configure(self, tvb_model): self.tvb_model = tvb_model # Organize the different kinds of interfaces and set the TVB region model of the TVB Simulator self.spikeNet_to_tvb_params = OrderedDict() # self.spikeNet_to_tvb_params_interfaces_ids = [] # deprecated self.spikeNet_to_tvb_sv_interfaces_ids = [] for interface_id, interface in enumerate( self.spikeNet_to_tvb_interfaces): if is_integer(interface.tvb_sv_id) and interface.tvb_sv_id >= 0: self.spikeNet_to_tvb_sv_interfaces_ids.append(interface_id) else: # self.spikeNet_to_tvb_params_interfaces_ids.append(interface_id) # deprecated raise ValueError( "tvb_sv_id=%s doesn't correspond " "to the index of a TVB state variable for interface %s!\n" % (str(interface.tvb_sv_id), str(interface))) # Even if the target in TVB is a state variable, # we are going to create a TVB parameter with the same name if interface.name not in list(self.spikeNet_to_tvb_params.keys()): self.spikeNet_to_tvb_params[ interface.name] = interface.nodes_ids else: self.spikeNet_to_tvb_params[ interface.name] += interface.nodes_ids self.spikeNet_to_tvb_params[interface.name] = \ np.unique(self.spikeNet_to_tvb_params[interface.name]).tolist()
def get_dimension_index(self, dim_name_or_index): if is_integer(dim_name_or_index): return self._assert_index(dim_name_or_index) elif isinstance(dim_name_or_index, string_types): return self._assert_index( self.labels_ordering.index(dim_name_or_index)) else: raise ValueError( "dim_name_or_index is neither a string nor an integer!")
def __getitem__(self, items): """If the argument is a sequence, a new SpikingRegionNode instance is returned. If the argument is an integer index or a string label index, the corresponding SpikingPopulation is returned. """ if isinstance(items, string_types) or is_integer(items): return super(SpikingRegionNode, self).__getitem__(items) return SpikingRegionNode(label=self.label, input_nodes=super(SpikingRegionNode, self).__getitem__(items))
def _index_or_label_or_slice(self, inputs): inputs = ensure_list(inputs) if numpy.all([is_integer(inp) for inp in inputs]): return "index" elif numpy.all([isinstance(inp, string_types) for inp in inputs]): return "label" elif numpy.all([isinstance(inp, slice) for inp in inputs]): return "slice" else: raise ValueError( "input %s is not of type integer, string or slice!" % str(inputs))
def select_greater_values_array_inds(values, threshold=None, percentile=None, nvals=None, verbose=False): if threshold is None and percentile is not None: threshold = np.percentile(values, percentile) if threshold is not None: return np.where(values > threshold)[0] else: if is_integer(nvals): return get_greater_values_array_inds(values, nvals) if verbose: logger.warning("Switching to curve elbow point method since threshold=" + str(threshold)) elbow_point = curve_elbow_point(values) return get_greater_values_array_inds(values, elbow_point)
def _assert_neurons(self, neurons=None): """Method to assert an input set of neurons either as: - the present instance of ANNarchy.Population class - a ANNarchy.PopulationView instance of the present instance of ANNarchy.Population class - a collection (tuple, list, numpy.ndarray) of global indices (i.e., tuples of (population_inds, neuron_ind), of the present instance of ANNarchy.Population class, or of local indices thereof, Default input = None, which corresponds to the present instance of ANNarchy.Population class. """ if neurons is None: neurons = self._population else: self._assert_annarchy() if isinstance(neurons, self.annarchy_instance.Population): # Assert that we refer to this object's Population assert self._population == neurons elif isinstance(neurons, self.annarchy_instance.PopulationView): # Assert that we refer to a view of this object's Population assert self._population == neurons.population else: # Let's check if these are global or local indices of neurons... local_inds = [] for neuron in ensure_list(neurons): if isinstance(neuron, (tuple, list)): # If neurons are global_ids formed as tuples of (population_ind, neuron_ind)... if neuron[0] == self.population_ind: # ... confirm that the population_ind is correct and get the neuron_ind local_inds.append(neuron[1]) # If neurons are just local inds, gather them... elif is_integer(neuron): local_inds.append(neuron) else: raise ValueError( "neurons %s\nis neither an instance of ANNarchy.Population, " "nor of ANNarchy.PopulationView,\n" "nor is it a collection (tuple, list, or numpy.ndarray) " "of global (tuple of (population_inds, neuron_ind) or local indices of neurons!" ) # Return a Population View: neurons = self._population[neurons] return neurons
def __getitem__(self, items): if isinstance(items, string_types) or is_integer(items): return super(SpikingBrain, self).__getitem__(items) return SpikingBrain(input_brain=super(SpikingBrain, self).__getitem__(items))