def test_GetElement(self): """Check if GetElement returns proper lists.""" ldict = {'elements': 'iaf_neuron', 'rows': 4, 'columns': 5} nest.ResetKernel() l = topo.CreateLayer((ldict, ldict)) checkpos = [[0, 0], [1, 1], [4, 3]] # single gid, single coord gives 1-elem gid list n1 = topo.GetElement(l[:1], checkpos[0]) self.assertEqual(len(n1), 1) self.assertIsInstance(n1[0], int) # multiple gid, single coord gives l-elem gid list n2 = topo.GetElement(l, checkpos[0]) self.assertEqual(len(n2), len(l)) self.assertTrue(all(nest.is_sequence_of_gids(n) for n in n2)) # single gid, multiple coord gives len(checkpos)-elem gid list n3 = topo.GetElement(l[:1], checkpos) self.assertEqual(len(n3), len(checkpos)) self.assertTrue(all(nest.is_sequence_of_gids(n) for n in n3)) self.assertTrue(all(len(n) == 1 for n in n3)) # multiple gid, multiple coord gives l*len(cp)-elem gid list n4 = topo.GetElement(l, checkpos) self.assertEqual(len(n4), len(l)) self.assertTrue(all(nest.is_iterable(n) for n in n4)) self.assertTrue(all(len(n) == len(checkpos) for n in n4)) self.assertTrue(all( nest.is_sequence_of_gids(m) for n in n4 for m in n))
def _check_displacement_args(from_arg, to_arg, caller): """ Internal helper function to check arguments to Displacement and Distance and make them lists of equal length. """ import numpy if isinstance(from_arg, numpy.ndarray): from_arg = (from_arg, ) elif not (nest.is_iterable(from_arg) and len(from_arg) > 0): raise nest.NESTError("%s: from_arg must be lists of GIDs or positions" % caller) # invariant: from_arg is list if not nest.is_sequence_of_gids(to_arg): raise nest.NESTError("%s: to_arg must be lists of GIDs" % caller) # invariant: from_arg and to_arg are sequences if len(from_arg) > 1 and len(to_arg) > 1 and not len(from_arg) == len(to_arg): raise nest.NESTError("%s: If to_arg and from_arg are lists, they must have equal length." % caller) # invariant: from_arg and to_arg have equal length, or (at least) one has length 1 if len(from_arg) == 1: from_arg = from_arg*len(to_arg) # this is a no-op if len(to_arg)==1 if len(to_arg) == 1: to_arg = to_arg*len(from_arg) # this is a no-op if len(from_arg)==1 # invariant: from_arg and to_arg have equal length return from_arg, to_arg
def test_GetElement(self): """Check if GetElement returns proper lists.""" ldict = {'elements': 'iaf_psc_alpha', 'rows': 4, 'columns': 5} nest.ResetKernel() l = topo.CreateLayer((ldict, ldict)) checkpos = [[0, 0], [1, 1], [4, 3]] # single gid, single coord gives 1-elem gid list n1 = topo.GetElement(l[:1], checkpos[0]) self.assertEqual(len(n1), 1) self.assertIsInstance(n1[0], int) # multiple gid, single coord gives l-elem gid list n2 = topo.GetElement(l, checkpos[0]) self.assertEqual(len(n2), len(l)) self.assertTrue(all(nest.is_sequence_of_gids(n) for n in n2)) # single gid, multiple coord gives len(checkpos)-elem gid list n3 = topo.GetElement(l[:1], checkpos) self.assertEqual(len(n3), len(checkpos)) self.assertTrue(all(nest.is_sequence_of_gids(n) for n in n3)) self.assertTrue(all(len(n) == 1 for n in n3)) # multiple gid, multiple coord gives l*len(cp)-elem gid list n4 = topo.GetElement(l, checkpos) self.assertEqual(len(n4), len(l)) self.assertTrue(all(nest.is_iterable(n) for n in n4)) self.assertTrue(all(len(n) == len(checkpos) for n in n4)) self.assertTrue(all(nest.is_sequence_of_gids(m) for n in n4 for m in n))
def raster_plot_from_file(fname, hist=False, hist_binwidth=5.0, xlim=None, sel=None): """ Plot raster from file """ if nest.is_iterable(fname): data = None for f in fname: if data is None: data = np.loadtxt(f) else: data = np.concatenate((data, np.loadtxt(f))) else: data = np.loadtxt(fname) ts = data[:, 1] gids = data[:, 0] if not len(ts): raise nest.NESTError("No events recorded!") val = extract_events(ts, gids, sel=sel) make_plot(ts, gids, val, hist, hist_binwidth, sel, xlim)
def from_file(fname, title=None, hist=False, hist_binwidth=5.0, grayscale=False): """ Plot raster from file """ if nest.is_iterable(fname): data = None for f in fname: if data is None: data = numpy.loadtxt(f) else: data = numpy.concatenate((data, numpy.loadtxt(f))) else: data = numpy.loadtxt(fname) return from_data(data, title, hist, hist_binwidth, grayscale)
def from_file(fname, **kwargs): """Plot raster from file. Parameters ---------- fname : str Name of file kwargs: Parameters passed to _make_plot """ if nest.is_iterable(fname): data = None for f in fname: if data is None: data = numpy.loadtxt(f) else: data = numpy.concatenate((data, numpy.loadtxt(f))) else: data = numpy.loadtxt(fname) return from_data(data, **kwargs)
def from_file(fname, title=None, grayscale=False): """Plot voltage trace from file. Parameters ---------- fname : str or list Filename or list of filenames to load from title : str, optional Plot title grayscale : bool, optional Plot in grayscale Raises ------ ValueError """ if nest.is_iterable(fname): data = None for f in fname: if data is None: data = numpy.loadtxt(f) else: data = numpy.concatenate((data, numpy.loadtxt(f))) else: data = numpy.loadtxt(fname) if grayscale: line_style = "k" else: line_style = "" if len(data.shape) == 1: print("INFO: only found 1 column in the file. \ Assuming that only one neuron was recorded.") plotid = pylab.plot(data, line_style) pylab.xlabel("Time (steps of length interval)") elif data.shape[1] == 2: print("INFO: found 2 columns in the file. Assuming \ them to be gid, pot.") plotid = [] data_dict = {} for d in data: if not d[0] in data_dict: data_dict[d[0]] = [d[1]] else: data_dict[d[0]].append(d[1]) for d in data_dict: plotid.append( pylab.plot(data_dict[d], line_style, label="Neuron %i" % d) ) pylab.xlabel("Time (steps of length interval)") pylab.legend() elif data.shape[1] == 3: plotid = [] data_dict = {} g = data[0][0] t = [] for d in data: if not d[0] in data_dict: data_dict[d[0]] = [d[2]] else: data_dict[d[0]].append(d[2]) if d[0] == g: t.append(d[1]) for d in data_dict: plotid.append( pylab.plot(t, data_dict[d], line_style, label="Neuron %i" % d) ) pylab.xlabel("Time (ms)") pylab.legend() else: raise ValueError("Inappropriate data shape %i!" % data.shape) if not title: title = "Membrane potential from file '%s'" % fname pylab.title(title) pylab.ylabel("Membrane potential (mV)") pylab.draw() return plotid
def from_file(fname, title=None, grayscale=False): """Plot voltage trace from file. Parameters ---------- fname : str or list Filename or list of filenames to load from title : str, optional Plot title grayscale : bool, optional Plot in grayscale Raises ------ ValueError """ if nest.is_iterable(fname): data = None for f in fname: if data is None: data = numpy.loadtxt(f) else: data = numpy.concatenate((data, numpy.loadtxt(f))) else: data = numpy.loadtxt(fname) if grayscale: line_style = "k" else: line_style = "" if len(data.shape) == 1: print("INFO: only found 1 column in the file. \ Assuming that only one neuron was recorded.") plotid = pylab.plot(data, line_style) pylab.xlabel("Time (steps of length interval)") elif data.shape[1] == 2: print("INFO: found 2 columns in the file. Assuming \ them to be gid, pot.") plotid = [] data_dict = {} for d in data: if not d[0] in data_dict: data_dict[d[0]] = [d[1]] else: data_dict[d[0]].append(d[1]) for d in data_dict: plotid.append( pylab.plot(data_dict[d], line_style, label="Neuron %i" % d)) pylab.xlabel("Time (steps of length interval)") pylab.legend() elif data.shape[1] == 3: plotid = [] data_dict = {} g = data[0][0] t = [] for d in data: if not d[0] in data_dict: data_dict[d[0]] = [d[2]] else: data_dict[d[0]].append(d[2]) if d[0] == g: t.append(d[1]) for d in data_dict: plotid.append( pylab.plot(t, data_dict[d], line_style, label="Neuron %i" % d)) pylab.xlabel("Time (ms)") pylab.legend() else: raise ValueError("Inappropriate data shape %i!" % data.shape) if not title: title = "Membrane potential from file '%s'" % fname pylab.title(title) pylab.ylabel("Membrane potential (mV)") pylab.draw() return plotid
def FindNearestElement(layers, locations, find_all=False): """ Return the node(s) closest to the location(s) in the given layer(s). Parameters ---------- layers : list of layer GIDs locations: 2-element array with coordinates of a single position, or list of 2-element arrays of positions find_all : Default value false: if there are several nodes with same minimal distance, return only the first found. If True, instead of returning a single GID, return a list of GIDs containing all nodes with minimal distance. Returns ------- List of GIDs If layers contains a single GID and locations is a single 2-element array giving a location, return single-element list with GID of layer element closest to the given location. If layers is a list with a single GID and locations is a list of coordinates, the function returns a list of GIDs of the nodes closest to all locations. If layers is a list of GIDs and locations single 2-element array giving a position location, the function returns a list with the GIDs of the nodes in all layers closest to the given location. If layers and locations are lists, it returns a list of lists of GIDs, one for each layer. See also -------- GetElement """ import numpy if not nest.is_sequence_of_gids(layers): raise TypeError("layers must be a sequence of GIDs") if not len(layers) > 0: raise nest.NESTError("layers cannot be empty") if not nest.is_iterable(locations): raise TypeError("locations must be coordinate array or list of coordinate arrays") # ensure locations is sequence, keeps code below simpler if not nest.is_iterable(locations[0]): locations = (locations, ) result = [] # collect one list per layer # loop over layers for lyr in layers: els = nest.GetChildren((lyr, ))[0] lyr_result = [] # loop over locations for loc in locations: d = Distance(numpy.array(loc), els) if not find_all: dx = numpy.argmin(d) # finds location of one minimum lyr_result.append(els[dx]) else: mingids = list(els[:1]) minval = d[0] for idx in range(1, len(els)): if d[idx] < minval: mingids = [els[idx]] minval = d[idx] elif numpy.abs(d[idx] - minval) <= 1e-14 * minval: mingids.append(els[idx]) lyr_result.append(tuple(mingids)) result.append(tuple(lyr_result)) # If both layers and locations are multi-element lists, result shall remain a nested list # Otherwise, either the top or the second level is a single element list and we flatten assert(len(result) > 0) if len(result) == 1: assert(len(layers) == 1) return result[0] elif len(result[0]) == 1: assert(len(locations) == 1) return tuple(el[0] for el in result) else: return tuple(result)
def make_tuple(x): if not nest.is_iterable(x): return (x, ) else: return x
def GetElement(layers, locations): """ Return the node(s) at the location(s) in the given layer(s). Parameters ---------- layers : list of layer GIDs locations: 2-element array with coordinates of a single grid location, or list of 2-element arrays of coordinates Returns ------- List of GIDs This function works for fixed grid layers only. If layers contains a single GID and locations is a single 2-element array giving a grid location, return a list of GIDs of layer elements at the given location. If layers is a list with a single GID and locations is a list of coordinates, the function returns a list of lists with GIDs of the nodes at all locations. If layers is a list of GIDs and locations single 2-element array giving a grid location, the function returns a list of lists with the GIDs of the nodes in all layers at the given location. If layers and locations are lists, it returns a nested list of GIDs, one list for each layer and each location. See also -------- FindNearestElement nest.help("topology::GetElement") """ if not nest.is_sequence_of_gids(layers): raise TypeError("layers must be a sequence of GIDs") if not len(layers) > 0: raise nest.NESTError("layers cannot be empty") if not (nest.is_iterable(locations) and len(locations) > 0): raise nest.NESTError("locations must be coordinate array or list of coordinate arrays") # ensure that all layers are grid-based, otherwise one ends up with an # incomprehensible error message try: topology_func('{ [ /topology [ /rows /columns ] ] get ; } forall', layers) except: raise nest.NESTError("layers must contain only grid-based topology layers") # SLI GetElement returns either single GID or list def make_tuple(x): if not nest.is_iterable(x): return (x, ) else: return x if nest.is_iterable(locations[0]): # layers and locations are now lists nodes = topology_func('/locs Set { /lyr Set locs { lyr exch GetElement } Map } Map', layers, locations) node_list = tuple(tuple(make_tuple(nodes_at_loc) for nodes_at_loc in nodes_in_lyr) for nodes_in_lyr in nodes) else: # layers is list, locations is a single location nodes = topology_func('/loc Set { loc GetElement } Map', layers, locations) node_list = tuple(make_tuple(nodes_in_lyr) for nodes_in_lyr in nodes) # If only a single layer is given, un-nest list if len(layers)==1: node_list=node_list[0] return node_list