def _append_previous_segment(self, block, segment_number, variables, view_indexes): if segment_number not in self._data_cache: logger.warning("No Data available for Segment {}", segment_number) segment = neo.Segment(name="segment{}".format(segment_number), description="Empty", rec_datetime=datetime.now()) block.segments.append(segment) return data_cache = self._data_cache[segment_number] # sort out variables variables = self._clean_variables(variables) # build segment for the previous data to be gathered in segment = neo.Segment(name="segment{}".format(segment_number), description=data_cache.description, rec_datetime=data_cache.rec_datetime) for variable in variables: if variable not in data_cache.variables: logger.warning("No Data available for Segment {} variable {}", segment_number, variable) continue variable_cache = data_cache.get_data(variable) if variable == SPIKES: self.__read_in_spikes( segment=segment, spikes=variable_cache.data, t=data_cache.t, n_neurons=variable_cache.n_neurons, recording_start_time=data_cache.recording_start_time, sampling_interval=variable_cache.sampling_interval, indexes=view_indexes, label=data_cache.label) elif variable == REWIRING: self.__read_in_event( segment=segment, event_array=variable_cache.data, variable=variable, recording_start_time=data_cache.recording_start_time) else: self.__read_in_signal( segment=segment, block=block, signal_array=variable_cache.data, data_indexes=variable_cache.indexes, view_indexes=view_indexes, variable=variable, recording_start_time=data_cache.recording_start_time, sampling_interval=variable_cache.sampling_interval, units=variable_cache.units, label=data_cache.label) block.segments.append(segment)
def _get_current_segment(self, filter_ids=None, variables='all', clear=False): segment = neo.Segment( name="segment%03d" % self._simulator.state.segment_counter, description=self.population.describe(), rec_datetime=datetime.now() ) # would be nice to get the time at the start of the recording, not the end variables_to_include = set(self.recorded.keys()) if variables is not 'all': variables_to_include = variables_to_include.intersection( set(variables)) for variable in variables_to_include: if variable == 'spikes': t_stop = self._simulator.state.t * pq.ms # must run on all MPI nodes sids = sorted(self.filter_recorded('spikes', filter_ids)) data = self._get_spiketimes(sids) segment.spiketrains = [ neo.SpikeTrain(data.get(int(id), []), t_start=self._recording_start_time, t_stop=t_stop, units='ms', source_population=self.population.label, source_id=int(id), source_index=self.population.id_to_index( int(id))) for id in sids ] else: ids = sorted(self.filter_recorded(variable, filter_ids)) signal_array = self._get_all_signals(variable, ids, clear=clear) t_start = self._recording_start_time sampling_period = self.sampling_interval * pq.ms current_time = self._simulator.state.t * pq.ms mpi_node = self._simulator.state.mpi_rank # for debugging if signal_array.size > 0: # may be empty if none of the recorded cells are on this MPI node units = self.population.find_units(variable) source_ids = numpy.fromiter(ids, dtype=int) signal = neo.AnalogSignal( signal_array, units=units, t_start=t_start, sampling_period=sampling_period, name=variable, source_population=self.population.label, source_ids=source_ids) signal.channel_index = neo.ChannelIndex( index=numpy.arange(source_ids.size), channel_ids=numpy.array( [self.population.id_to_index(id) for id in ids])) segment.analogsignals.append(signal) logger.debug("%d **** ids=%s, channels=%s", mpi_node, source_ids, signal.channel_index) assert segment.analogsignals[ 0].t_stop - current_time - 2 * sampling_period < 1e-10 # need to add `Unit` and `RecordingChannelGroup` objects return segment
def __init__(self, RecordFile=None, UnitGain=1e6, Seg=None): self.UnitGain = UnitGain if not RecordFile: self.Seg = Seg if self.Seg: self.UpdateEventDict() self.UpdateSignalsDict() else: self.Seg = neo.Segment('New Seg') return ftype = RecordFile.split('.')[-1] if ftype == 'h5': self.RecFile = neo.io.NixIO(filename=RecordFile, mode='ro') Block = self.RecFile.read_block() elif ftype == 'smr': self.RecFile = neo.io.Spike2IO(filename=RecordFile) Block = self.RecFile.read()[0] self.Seg = Block.segments[0] self.UpdateSignalsDict() self.UpdateEventDict()
def write_data_to_hdf5(self, filename='data'): """This is a function to call after simulation that writes the data of all probes to filename using the Neo HDF5 IO module. :param string filename: the name of the file to write out to """ import neo from neo import hdf5io # get list of probes probe_list = [ self.nodes[node] for node in self.nodes if node[:5] == 'Probe' ] # if no probes then just return if len(probe_list) == 0: return # open up hdf5 file if not filename.endswith('.hd5'): filename += '.hd5' iom = hdf5io.NeoHdf5IO(filename=filename) #TODO: set up to write multiple trials/segments to same block # for trials run at different points # create the all encompassing block structure block = neo.Block() # create the segment, representing a trial segment = neo.Segment() # put the segment in the block block.segments.append(segment) # create the appropriate Neo structures from the Probes data #TODO: pair any analog signals and spike trains from the same # population together into a RecordingChannel for probe in probe_list: # decoded signals become AnalogSignals if probe.target_name.endswith('decoded'): segment.analogsignals.append( neo.AnalogSignal( probe.get_data() * quantities.dimensionless, sampling_period=probe.dt_sample * quantities.s, target_name=probe.target_name)) # spikes become spike trains elif probe.target_name.endswith('spikes'): # have to change spike train of 0s and 1s to list of times for neuron in probe.get_data().T: segment.spiketrains.append( neo.SpikeTrain([ t * probe.dt_sample for t, val in enumerate(neuron[0]) if val > 0 ] * quantities.s, t_stop=len(probe.data), target_name=probe.target_name)) else: print 'Do not know how to write %s to NeoHDF5 file' % probe.target_name assert False # write block to file iom.save(block) # close up hdf5 file iom.close()
def test_spiketrains_findable(self): # same test as `test_spread_0` with the addition of # a neo structure: we must not overwrite the spiketrain # list of the segment before determining the index sampling_rate = 1 / pq.s segment = neo.Segment() segment.spiketrains = [ neo.SpikeTrain([1, 5, 9, 11, 16, 19] * pq.s, t_stop=20 * pq.s), neo.SpikeTrain([1, 4, 8, 12, 16, 18] * pq.s, t_stop=20 * pq.s) ] segment.create_relationship() correct_annotations = np.array([[2, 1, 1, 1, 2, 1], [2, 1, 1, 1, 2, 1]]) self._test_template(segment.spiketrains, correct_annotations, sampling_rate, spread=0, mode='delete', in_place=True, deletion_threshold=2)
def test_unidirectional_uplinks(self): # same test as `test_spiketrains_findable` but the spiketrains # are rescaled first # the rescaled spiketrains have a unidirectional uplink to segment # check that this does not cause an error # check that a UserWarning is issued in this case sampling_rate = 1 / pq.s segment = neo.Segment() segment.spiketrains = [ neo.SpikeTrain([1, 5, 9, 11, 16, 19] * pq.s, t_stop=20 * pq.s), neo.SpikeTrain([1, 4, 8, 12, 16, 18] * pq.s, t_stop=20 * pq.s) ] segment.create_relationship() spiketrains = [st.rescale(pq.s) for st in segment.spiketrains] correct_annotations = np.array([[2, 1, 1, 1, 2, 1], [2, 1, 1, 1, 2, 1]]) with self.assertWarns(UserWarning): self._test_template(spiketrains, correct_annotations, sampling_rate, spread=0, mode='delete', in_place=True, deletion_threshold=2)
def create_big_neo_block(name='a block'): t1 = time.time() print 'b', b bl = neo.Block(name = name) rcg = neo.RecordingChannelGroup(name = 'big group') bl.recordingchannelgroups.append(rcg) for a in range(nb_sig): rc = neo.RecordingChannel(name = 'rec channel {}'.format(a), index = a) rcg.recordingchannels.append(rc) for s in range(nb_seg): print ' s', s seg = neo.Segment(name = 'seg {}'.format(s)) bl.segments.append(seg) for a in range(nb_sig): #~ print ' a', a #~ ana = neo.AnalogSignal(signal = np.empty(sig_size)*pq.mV, sampling_rate = 10*pq.kHz, t_start = -2.*pq.s, #~ name = 'signal {}'.format(a), description = 'this is a big signal') ana = neo.AnalogSignal(signal = np.random.rand(sig_size)*pq.mV, sampling_rate = 10*pq.kHz, t_start = -2.*pq.s, name = 'signal {}'.format(a), description = 'this is a big signal') seg.analogsignals.append(ana) rcg.recordingchannels[a].analogsignals.append(ana) t2 = time.time() print 'time for creating neo block', t2 - t1 return bl
def recording(self, port_name, t_start=None): """ Returns the recorded data for the given port name Parameters ---------- port_name : str The name of the port (or state-variable) to retrieve the recorded data for Returns ------- recording : neo.Segment The recorded data in a neo.Segment """ pyNN_data = self.get_data().segments[0] recording = neo.Segment() communicates, _ = self._get_port_details(port_name) if communicates == 'event': for st in pyNN_data.spiketrains: # FIXME: At some point we need to be able to specify multiple # event outputs if st.annotations: if t_start is not None: st = st[st > t_start] recording.spiketrains.append(st) else: for asig in pyNN_data.analogsignals: # FIXME: Not sure if this will work if asig.annotations['name'] == port_name: recording.analogsignals.append(asig) return recording
def save_sessions(fname, corr_coef, n_sessions=5): for i in range(n_sessions): r = neo.AsciiSpikeTrainIO(filename=fname.format(i)) spiketrains = generate_correlated_spike_trains(corr_coef, 50 * Hz, 1000 * ms, 10) seg = neo.Segment() seg.spiketrains = spiketrains r.write_segment(seg)
def generate_block(n_segments=3, n_channels=8, n_units=3, data_samples=1000, feature_samples=100): """ Generate a block with a single recording channel group and a number of segments, recording channels and units with associated analog signals and spike trains. """ feature_len = feature_samples / data_samples # Create container and grouping objects segments = [neo.Segment(index=i) for i in range(n_segments)] chx = neo.ChannelIndex(index=1, name='T0') for i in range(n_channels): rc = neo.RecordingChannel(name='C%d' % i, index=i) rc.channelindexes = [chx] chx.recordingchannels.append(rc) units = [neo.Unit('U%d' % i) for i in range(n_units)] chx.units = units block = neo.Block() block.segments = segments block.channel_indexes = [chx] # Create synthetic data for seg in segments: feature_pos = np.random.randint(0, data_samples - feature_samples) # Analog signals: Noise with a single sinewave feature wave = 3 * np.sin(np.linspace(0, 2 * np.pi, feature_samples)) for rc in chx.recordingchannels: sig = np.random.randn(data_samples) sig[feature_pos:feature_pos + feature_samples] += wave signal = neo.AnalogSignal(sig * pq.mV, sampling_rate=1 * pq.kHz) seg.analogsignals.append(signal) rc.analogsignals.append(signal) # Spike trains: Random spike times with elevated rate in short period feature_time = feature_pos / data_samples for u in units: random_spikes = np.random.rand(20) feature_spikes = np.random.rand(5) * feature_len + feature_time spikes = np.hstack([random_spikes, feature_spikes]) train = neo.SpikeTrain(spikes * pq.s, 1 * pq.s) seg.spiketrains.append(train) u.spiketrains.append(train) block.create_many_to_one_relationship() return block
def test_get_fp_start_ttl(self, mock_tdt): event = neo.Event(times=[1,2,3]*pq.s, name='A') segment = neo.Segment() segment.events.append(event) segment.events.append(event) block = neo.Block() block.segments.append(segment) mock_tdt.return_value = block self.assertEqual(1, GetBehavioralEvents().get_fp_start_ttl('/path/to/data/', event_name='A')) self.assertEqual(1, GetBehavioralEvents().get_fp_start_ttl('/path/to/data/', event_idx=0))
def create_hierarchy(cls, many_to_many): b = neo.Block() for ns in range(cls.SEGMENTS): b.segments.append(neo.Segment()) channels = [] if many_to_many: channels = [ neo.RecordingChannel(name='Shared %d' % i, index=i + cls.CHANNELS) for i in range(cls.CHANNELS / 2) ] for ng in range(cls.CHANNEL_GROUPS): rcg = neo.RecordingChannelGroup() for nu in range(cls.UNITS): unit = neo.Unit() for ns in range(cls.SEGMENTS): spike = neo.Spike(0 * pq.s) unit.spikes.append(spike) b.segments[ns].spikes.append(spike) st = neo.SpikeTrain([] * pq.s, 0 * pq.s) unit.spiketrains.append(st) b.segments[ns].spiketrains.append(st) rcg.units.append(unit) if not many_to_many: for nc in range(cls.CHANNELS): rc = neo.RecordingChannel(name='Single %d' % nc, index=nc) rc.recordingchannelgroups.append(rcg) rcg.recordingchannels.append(rc) else: for nc in range(cls.CHANNELS): if nc % 2 == 0: rc = neo.RecordingChannel(name='Single %d' % (nc / 2), index=nc / 2) else: rc = channels[nc / 2] rc.recordingchannelgroups.append(rcg) rcg.recordingchannels.append(rc) rcg.channel_indexes = sp.array( [c.index for c in rcg.recordingchannels]) rcg.channel_names = sp.array( [c.name for c in rcg.recordingchannels]) b.recordingchannelgroups.append(rcg) try: neo.io.tools.create_many_to_one_relationship(b) except AttributeError: b.create_many_to_one_relationship() return b
def segment_from_recording_device(devices, variables_to_include, id_lists, t_stop, name="segment00"): """ Extract data from a NEST recording device and return it as a Neo Segment object. """ def get_data(device, variable, id_list): events = nest.GetStatus(device, 'events')[0] ids = events['senders'] values = events[variable] data = {} for id in id_list: data[id] = values[ids == id] assert len(data) > 0 return data segment = neo.Segment(name=name, rec_datetime=datetime.now()) for device, variable, id_list in zip(devices, variables_to_include, id_lists): print(name, device, variable) data = get_data(device, variable, id_list) if variable == 'times': print(" adding spiketrain") id0 = min(id_list) segment.spiketrains = [ neo.SpikeTrain(spiketrain, t_start=0.0, t_stop=t_stop, units='ms', source_id=id, source_index=id - id0) for id, spiketrain in data.items() ] else: print(" adding signal") source_ids = np.array(id_list) channel_indices = source_ids - source_ids.min() signal_array = np.vstack(data.values()).T segment.analogsignalarrays = [ neo.AnalogSignalArray(signal_array, units='mV', t_start=0.0 * ms, sampling_period=0.1 * ms, name=variable, channel_index=channel_indices, source_ids=source_ids) ] return segment
def test_GetImagingDataTTL(self, mock_tdt): event1 = neo.Event(times=[1, 2, 3] * pq.s, name='A') event2 = neo.Event(times=[4, 5, 6] * pq.s, name='B') event3 = neo.Event(times=[7, 8, 9] * pq.s, name='C') segment = neo.Segment() segment.events.append(event1) segment.events.append(event2) segment.events.append(event3) block = neo.Block() block.segments.append(segment) mock_tdt.return_value = block self.assertEqual( 3, GetImagingDataTTL('/dpath/', time_idx=-1, event_name='A')) self.assertEqual( 6, GetImagingDataTTL('/dpath/', time_idx=-1, event_idx=1))
def recordings(self, t_start=None): seg = neo.Segment(description="Simulation of '{}' cell".format( self._nineml.name, ('from {}'.format(t_start) if t_start is not None else ''))) for port_name in self._recorders: if port_name == self.code_generator.REGIME_VARNAME: continue sig = self.recording(port_name, t_start=t_start) if isinstance(sig, neo.AnalogSignal): seg.analogsignals.append(sig) else: seg.spiketrains.append(sig) try: seg.epochs.append(self.regime_epochs()) except Pype9RegimeTransitionsNotRecordedError: pass return seg
def __append_current_segment(self, block, variables, view_indexes, clear): # build segment for the current data to be gathered in segment = neo.Segment(name="segment{}".format( get_simulator().segment_counter), description=self.__population.describe(), rec_datetime=datetime.now()) # sort out variables for using variables = self._clean_variables(variables) for variable in variables: if variable == SPIKES: self.__read_in_spikes( segment=segment, spikes=self.get_spikes(), t=get_simulator().get_current_time(), n_neurons=self.__population.size, recording_start_time=self._recording_start_time, sampling_interval=self.__spike_sampling_interval, indexes=view_indexes, label=self.__population.label) elif variable == REWIRING: self.__read_in_event( segment=segment, event_array=self.get_events(variable), variable=variable, recording_start_time=self._recording_start_time) else: (data, data_indexes, sampling_interval) = \ self.get_recorded_matrix(variable) self.__read_in_signal( segment=segment, block=block, signal_array=data, data_indexes=data_indexes, view_indexes=view_indexes, variable=variable, recording_start_time=self._recording_start_time, sampling_interval=sampling_interval, units=self._get_units(variable), label=self.__population.label) block.segments.append(segment) if clear: self._clear_recording(variables)
def spike_array_to_neo(spike_array, population, t_stop): """ Convert the spike array produced by PyNN 0.7 to a Neo Block (the data format used by PyNN 0.8) """ from datetime import datetime segment = neo.Segment(name="I-F curve data", rec_datetime=datetime.now()) segment.spiketrains = [] for index in range(len(population)): segment.spiketrains.append( neo.SpikeTrain(spike_array[:, 1][spike_array[:, 0] == index], t_start=0.0, t_stop=t_stop, units='ms', source_index=index)) data = neo.Block(name="I-F curve data") data.segments.append(segment) return data
def test_remove_spiketrain(self): unit = neo.Unit() segment = neo.Segment() s = neo.Spike(0 * pq.s) unit.spikes.append(s) segment.spikes.append(s) s.unit = unit s.segment = segment st = neo.SpikeTrain([] * pq.s, 0 * pq.s) unit.spiketrains.append(st) segment.spiketrains.append(st) st.unit = unit st.segment = segment tools.remove_from_hierarchy(st) self.assertTrue(s in unit.spikes) self.assertTrue(s in segment.spikes) self.assertFalse(st in unit.spiketrains) self.assertFalse(st in segment.spiketrains)
def _run_simulations(self, model): """For each step in the protocol, run simulation and store recordings""" recordings = neo.Block() print("Total protocols: {}".format(len(self.protocol))) for idx, item in enumerate(self.protocol.items()): step_name = item[0] step = item[1] segment = neo.Segment(name=step_name) recordings.segments.append(segment) segment.block = recordings print("{}. Current protocol: {}".format(idx+1, step_name)) model.inject_current(step["stimuli"]) model.run(tstop=step["total_duration"]) signal = model.get_membrane_potential() stimulus_on = neo.Epoch(times=step["stimuli"]["delay"]*ms, durations=step["stimuli"]["duration"]*ms, labels="stimulus") segment.analogsignals.append(signal) segment.epochs.append(stimulus_on) return recordings
def spike_detector_to_neo(spike_detector, t_stop, label=""): """ Convert the spikes recorded by NEST to a Neo Block """ from datetime import datetime segment = neo.Segment(name=label, rec_datetime=datetime.now()) segment.spiketrains = [] events = nest.GetStatus(spike_detector, 'events')[0] ids = events['senders'] values = events['times'] for id in np.unique(ids): spike_times = values[ids == id] segment.spiketrains.append( neo.SpikeTrain(spike_times, t_start=0.0, t_stop=t_stop, units='ms', source_id=int(id))) data = neo.Block(name=label) data.segments.append(segment) return data
def test_load_save(): n_channels = 5 n_samples = 20 n_spikes = 50 fname = '/tmp/test_phy.exdir' if os.path.exists(fname): shutil.rmtree(fname) wf = np.random.random((n_spikes, n_channels, n_samples)) ts = np.sort(np.random.random(n_spikes)) t_stop = np.ceil(ts[-1]) sptr = neo.SpikeTrain(times=ts, units='s', waveforms=wf * pq.V, t_stop=t_stop, **{'group_id': 0}) blk = neo.Block() seg = neo.Segment() seg.duration = t_stop blk.segments.append(seg) chx = neo.ChannelIndex(index=range(n_channels), **{'group_id': 0}) blk.channel_indexes.append(chx) sptr.channel_index = chx unit = neo.Unit() unit.spiketrains.append(sptr) chx.units.append(unit) seg.spiketrains.append(sptr) epo = neo.Epoch() if os.path.exists(fname): shutil.rmtree(fname) io = neo.ExdirIO(fname) io.write_block(blk) wfswap = wf.swapaxes(1, 2) m = NeoModel(fname, overwrite=True) assert np.array_equal(m.spike_times, ts) assert np.array_equal(m.waveforms, wfswap) m.save() m2 = NeoModel(fname, overwrite=True) assert np.array_equal(m2.spike_times, ts) assert np.array_equal(m2.waveforms, wfswap) assert np.array_equal(m2.features, m.features) assert np.array_equal(m2.amplitudes, m.amplitudes) assert np.array_equal(m2.spike_clusters, m.spike_clusters)
def ButSaveViewClick(self): # TODO finish save if self.ChkSaveRec1.isChecked(): RecordFile, _ = QFileDialog.getSaveFileName( self, "Rec1 file", "", "NixIO (*.h5)") if RecordFile: out_f = neo.io.NixIO(filename=RecordFile) out_f.write_block(self.rec.Block) out_f.close() if self.ChkSaveRec2.isChecked(): RecordFile, _ = QFileDialog.getSaveFileName( self, "Rec2 file", "", "NixIO (*.h5)") if RecordFile: out_f = neo.io.NixIO(filename=RecordFile) out_f.write_block(self.rec2.Block) out_f.close() if self.ChkSaveView.isChecked(): RecordFile, _ = QFileDialog.getSaveFileName( self, "Current View file", "", "NixIO (*.h5)") if RecordFile: Tstart = self.SLTStart.value() * pq.s Tstop = self.SLTStop.value() * pq.s out_seg = neo.Segment(name='NewSeg') for sl in self.pltrec.Slots: SName = sl.DispName print SName sig = sl.rec.Signal(SName) out_seg.analogsignals.append(sig.time_slice(Tstart, Tstop)) out_bl = neo.Block(name='NewBlock') out_bl.segments.append(out_seg) out_f = neo.io.NixIO(filename='Test_out.h5') out_f.write_block(out_bl) out_f.close()
def build_block(data_file): """(plaintextfile_path) -> neo.core.block.Block Thie function reads a plain text file (data_file) with the data exported (per waveform) from Plexon Offline Sorter after sorting and returns a neo.Block with spiketrains ordered in any number of 10 minute segments. For practicality and Plexon management of channels names, units and channels have been ignored in the block structure.""" raw_data = pd.read_csv(data_file, sep=',', header=0, usecols=[0, 1, 2]) ord_times = raw_data.groupby(['Channel Name', 'Unit'])['Timestamp'] new_block = neo.Block() chx = neo.ChannelIndex(index=None, name='MEA_60') new_block.channel_indexes.append(chx) # Next line will not work properly if last spike happens # exactly at the end of the recording num_segments = range(int(raw_data['Timestamp'].max() // 600 + 1)) for ind in num_segments: seg = neo.Segment(name='segment {}'.format(ind), index=ind) new_block.segments.append(seg) for name, group in ord_times: time_stamps = ord_times.get_group(name).values inter = 600 # Number of seconds in 10 minutes first_seg = neo.SpikeTrain( time_stamps[time_stamps < inter], units='sec', t_start=0, t_stop=inter) new_block.segments[0].spiketrains.append(first_seg) new_unit = neo.Unit(name=name) sptrs = [first_seg] for seg in num_segments[1:-1]: seg_train = neo.SpikeTrain(time_stamps[(time_stamps > seg * inter) & (time_stamps < ((seg + 1) * inter))], units='sec', t_start=(seg * inter), t_stop=((seg + 1) * inter)) new_block.segments[seg].spiketrains.append(seg_train) sptrs.append(seg_train) last_seg = neo.SpikeTrain(time_stamps[time_stamps > (num_segments[-1] * inter)], units='sec', t_start=(num_segments[-1]) * inter, t_stop=((num_segments[-1] + 1) * inter)) new_block.segments[num_segments[-1]].spiketrains.append(last_seg) sptrs.append(last_seg) new_unit.spiketrains = sptrs chx.units.append(new_unit) return new_block
def InitContMeas(self, Vin, Fs, Refresh, RecDC=True, GenTestSig=False): # Init Neo record out_seg = neo.Segment(name='NewSeg') if RecDC: self.EventContDcDone = self.ContDcDoneCallback for chk, chi, in sorted(self.DCChannelIndex.iteritems()): name = chk sig = neo.AnalogSignal(signal=np.empty((0, 1), float), units=pq.V, t_start=0*pq.s, sampling_rate=Fs*pq.Hz, name=name) out_seg.analogsignals.append(sig) self.ContRecord = NeoRecord(Seg=out_seg, UnitGain=1) # Lauch adquisition self.SetBias(Vsig=Vin) self.GetContinuousCurrent(Fs=Fs, Refresh=Refresh, GenTestSig=GenTestSig) self.CharactRunning = True
def runtest_neo(io, N): times = [] blk = neo.Block() seg = neo.Segment() blk.segments.append(seg) step = 1 if N >= 10: step = N // 10 Ns = list() for n in range(0, N + step, step): seg.analogsignals = [] for ni in range(n): seg.analogsignals.append( neo.AnalogSignal(signal=[0], units="V", sampling_rate=1 * pq.Hz)) t0 = time() io.write_block(blk) times.append(time() - t0) Ns.append(n) print(f" :: {n}/{N} {int(n/N*100):3d}%", end="\r") print(f" :: Last write time: {times[-1]:7.05f} s") print("Verifying neo-nix file") assert len(io.nix_file.blocks) == 1 blk = io.nix_file.blocks[0] assert blk.type == "neo.block" assert len(blk.groups) == 1 grp = blk.groups[0] assert grp.type == "neo.segment" assert len(blk.data_arrays) == N assert len(grp.data_arrays) == N return Ns, times
def read(self): """ Read all data* from a SONATA dataset directory. Returns a list of Blocks. (*Currently only spike data supported) """ file_path = join(self.base_dir, self.spike_file) block = neo.Block(file_origin=file_path) segment = neo.Segment(file_origin=file_path) spikes_file = h5py.File(file_path, 'r') for gid in np.unique(spikes_file['spikes']['gids']): index = spikes_file['spikes']['gids'].value == gid spike_times = spikes_file['spikes']['timestamps'][index] segment.spiketrains.append( neo.SpikeTrain(spike_times, t_stop = spike_times.max() + 1.0, t_start=0.0, units='ms', source_id=gid) ) block.segments.append(segment) return [block]
def __init__(self, RecordFile=None, Seg=None): self.SigNames = {} self.EventNames = {} if RecordFile is None: if Seg is None: self.Seg = neo.Segment('New Seg') else: self.Seg = Seg self.UpdateEventDict() self.UpdateSignalsDict() return ftype = RecordFile.split('.')[-1] if ftype == 'h5': self.RecFile = neo.io.NixIO(filename=RecordFile, mode='ro') Block = self.RecFile.read_block() elif ftype == 'smr': self.RecFile = neo.io.Spike2IO(filename=RecordFile) Block = self.RecFile.read()[0] self.Seg = Block.segments[0] self.UpdateSignalsDict() self.UpdateEventDict()
def test1(self): """Create clu and fet files based on spiketrains in a block. Checks that Files are created Converted to samples correctly Missing sampling rate are taken from IO reader default Spiketrains without cluster info are assigned to cluster 0 Spiketrains across segments are concatenated """ block = neo.Block() segment = neo.Segment() segment2 = neo.Segment() block.segments.append(segment) block.segments.append(segment2) # Fake spiketrain 1 st1 = neo.SpikeTrain(times=[.002, .004, .006], units='s', t_stop=1.) st1.annotations['cluster'] = 0 st1.annotations['group'] = 0 wff = np.array([[11.3, 0.2], [-0.3, 12.3], [3.0, -2.5]]) st1.annotations['waveform_features'] = wff segment.spiketrains.append(st1) # Create empty directory for writing if not os.path.exists(self.dirname): os.mkdir(self.dirname) delete_test_session(self.dirname) # Create writer kio = KlustaKwikIO(filename=os.path.join(self.dirname, 'base2'), sampling_rate=1000.) kio.write_block(block) # Check files were created for fn in ['.fet.0', '.clu.0']: self.assertTrue( os.path.exists(os.path.join(self.dirname, 'base2' + fn))) # Check files contain correct content fi = file(os.path.join(self.dirname, 'base2.fet.0')) # first line is nbFeatures self.assertEqual(fi.readline(), '2\n') # Now check waveforms and times are same data = fi.readlines() new_wff = [] new_times = [] for line in data: line_split = line.split() new_wff.append([float(val) for val in line_split[:-1]]) new_times.append(int(line_split[-1])) self.assertEqual(new_times, [2, 4, 6]) assert_arrays_almost_equal(wff, np.array(new_wff), .00001) # Clusters on group 0 data = file(os.path.join(self.dirname, 'base2.clu.0')).readlines() data = [int(d) for d in data] self.assertEqual(data, [1, 0, 0, 0]) # Now read the features and test same block = kio.read_block() train = block.segments[0].spiketrains[0] assert_arrays_almost_equal(wff, train.annotations['waveform_features'], .00001) # Empty out test session again delete_test_session(self.dirname)
def test1(self): """Create clu and fet files based on spiketrains in a block. Checks that Files are created Converted to samples correctly Missing sampling rate are taken from IO reader default Spiketrains without cluster info are assigned to cluster 0 Spiketrains across segments are concatenated """ block = neo.Block() segment = neo.Segment() segment2 = neo.Segment() block.segments.append(segment) block.segments.append(segment2) # Fake spiketrain 1, will be sorted st1 = neo.SpikeTrain(times=[.002, .004, .006], units='s', t_stop=1.) st1.annotations['cluster'] = 0 st1.annotations['group'] = 0 segment.spiketrains.append(st1) # Fake spiketrain 1B, on another segment. No group specified, # default is 0. st1B = neo.SpikeTrain(times=[.106], units='s', t_stop=1.) st1B.annotations['cluster'] = 0 segment2.spiketrains.append(st1B) # Fake spiketrain 2 on same group, no sampling rate specified st2 = neo.SpikeTrain(times=[.001, .003, .011], units='s', t_stop=1.) st2.annotations['cluster'] = 1 st2.annotations['group'] = 0 segment.spiketrains.append(st2) # Fake spiketrain 3 on new group, with different sampling rate st3 = neo.SpikeTrain(times=[.05, .09, .10], units='s', t_stop=1.) st3.annotations['cluster'] = -1 st3.annotations['group'] = 1 segment.spiketrains.append(st3) # Fake spiketrain 4 on new group, without cluster info st4 = neo.SpikeTrain(times=[.005, .009], units='s', t_stop=1.) st4.annotations['group'] = 2 segment.spiketrains.append(st4) # Create empty directory for writing delete_test_session() # Create writer with default sampling rate kio = KlustaKwikIO(filename=os.path.join(self.dirname, 'base1'), sampling_rate=1000.) kio.write_block(block) # Check files were created for fn in ['.fet.0', '.fet.1', '.clu.0', '.clu.1']: self.assertTrue( os.path.exists(os.path.join(self.dirname, 'base1' + fn))) # Check files contain correct content # Spike times on group 0 data = file(os.path.join(self.dirname, 'base1.fet.0')).readlines() data = [int(d) for d in data] self.assertEqual(data, [0, 2, 4, 6, 1, 3, 11, 106]) # Clusters on group 0 data = file(os.path.join(self.dirname, 'base1.clu.0')).readlines() data = [int(d) for d in data] self.assertEqual(data, [2, 0, 0, 0, 1, 1, 1, 0]) # Spike times on group 1 data = file(os.path.join(self.dirname, 'base1.fet.1')).readlines() data = [int(d) for d in data] self.assertEqual(data, [0, 50, 90, 100]) # Clusters on group 1 data = file(os.path.join(self.dirname, 'base1.clu.1')).readlines() data = [int(d) for d in data] self.assertEqual(data, [1, -1, -1, -1]) # Spike times on group 2 data = file(os.path.join(self.dirname, 'base1.fet.2')).readlines() data = [int(d) for d in data] self.assertEqual(data, [0, 5, 9]) # Clusters on group 2 data = file(os.path.join(self.dirname, 'base1.clu.2')).readlines() data = [int(d) for d in data] self.assertEqual(data, [1, 0, 0]) # Empty out test session again delete_test_session()
import neo import quantities as pq import numpy as np import nixio as nix from neo.io import NixIO block = neo.Block() chn_index = neo.ChannelIndex([0, 1, 2], channel_names=["a", "b", "c"], channel_ids=[1, 2, 3]) block.channel_indexes.append(chn_index) unit = neo.Unit(name="x", description="contain1st") chn_index.units.append(unit) seg = neo.Segment() asig = neo.AnalogSignal(name="signal", signal=[1.1, 1.2, 1.5], units="mV", sampling_rate=1 * pq.Hz) seg.analogsignals.append(asig) asig2 = neo.AnalogSignal(name="signal2", signal=[1.1, 1.2, 2.5], units="mV", sampling_rate=1 * pq.Hz) seg.analogsignals.append(asig2) irasig = neo.IrregularlySampledSignal(name="irsignal", signal=np.random.random((100, 2)), units="mV", times=np.cumsum( np.random.random(100) * pq.s)) seg.irregularlysampledsignals.append(irasig)