def test_write_dataset_datachunkiterator_data_only(self):
a = np.arange(30).reshape(5, 2, 3)
aiter = iter(a)
daiter = DataChunkIterator.from_iterable(aiter, buffer_size=2)
tstamps = np.arange(5.)
ts = TimeSeries(name='ts_name',
data=daiter,
unit='A',
timestamps=tstamps)
self.nwbfile.add_acquisition(ts)
with NWBHDF5IO(self.path, 'w') as io:
io.write(self.nwbfile, cache_spec=False)
with File(self.path, 'r') as f:
dset = f['/acquisition/ts_name/data']
self.assertListEqual(dset[:].tolist(), a.tolist())
def addContainer(self, file):
ts = TimeSeries('test_timeseries',
'example_source',
list(range(100, 200, 10)),
'SIunit',
timestamps=list(range(10)),
resolution=0.1)
self.file.add_acquisition(ts)
mod = file.create_processing_module(
'test_module', 'a test source for a ProcessingModule',
'a test module')
mod.add_container(
Clustering("an example source for Clustering",
"A fake Clustering interface", [0, 1, 2, 0, 1, 2],
[100, 101, 102], list(range(10, 61, 10))))
def to_nwb(self, nwbfile: NWBFile) -> NWBFile:
lick_timeseries = TimeSeries(
name='licks',
data=self.value['frame'].values,
timestamps=self.value['timestamps'].values,
description=('Timestamps and stimulus presentation '
'frame indices for lick events'),
unit='N/A')
# Add lick interface to nwb file, by way of a processing module:
licks_mod = ProcessingModule('licking',
'Licking behavior processing module')
licks_mod.add_data_interface(lick_timeseries)
nwbfile.add_processing_module(licks_mod)
return nwbfile
def setUp(self):
data = np.random.rand(160, 3)
self.ts_multi = SpatialSeries(
name="test_timeseries",
data=data,
reference_frame="lowerleft",
starting_time=0.0,
rate=1.0,
)
self.ts_single = TimeSeries(
name="test_timeseries",
data=data[:, 0],
unit="m",
starting_time=0.0,
rate=1.0,
)
def get_motion_correction(expt, channel):
fpath = os.path.join(expt.sima_path(), 'sequences.pkl')
with open(fpath, 'rb') as f:
aa = pickle.load(f)
obj = aa[0]
while True:
if 'displacements' in obj:
data = np.swapaxes(obj['displacements'][..., channel], 1, 2)
return TimeSeries(name='motion_correction',
data=data,
unit='pixels',
rate=1 / expt.frame_period())
obj = obj['base']
def test_write_dataset_custom_compress(self):
a = H5DataIO(np.arange(30).reshape(5, 2, 3),
compression='gzip',
compression_opts=5,
shuffle=True,
fletcher32=True)
ts = TimeSeries('ts_name', a, 'A', timestamps=np.arange(5))
self.nwbfile.add_acquisition(ts)
with NWBHDF5IO(self.path, 'w') as io:
io.write(self.nwbfile, cache_spec=False)
with File(self.path, 'r') as f:
dset = f['/acquisition/ts_name/data']
self.assertTrue(np.all(dset[:] == a.data))
self.assertEqual(dset.compression, 'gzip')
self.assertEqual(dset.compression_opts, 5)
self.assertEqual(dset.shuffle, True)
self.assertEqual(dset.fletcher32, True)
def setUpContainer(self):
self.timeseries = TimeSeries(name='dummy timeseries', description='desc',
data=np.ones((3, 3)), unit='flibs',
timestamps=np.ones((3,)))
bands = DynamicTable(name='bands', description='band info for LFPSpectralAnalysis', columns=[
VectorData(name='band_name', description='name of bands', data=['alpha', 'beta', 'gamma']),
VectorData(name='band_limits', description='low and high cutoffs in Hz', data=np.ones((3, 2)))
])
spec_anal = DecompositionSeries(name='LFPSpectralAnalysis',
description='my description',
data=np.ones((3, 3, 3)),
timestamps=np.ones((3,)),
source_timeseries=self.timeseries,
metric='amplitude',
bands=bands)
return spec_anal
def add_ekg(nwbfile, ecog_path, ekg_elecs):
if os.path.split(ecog_path)[1] == 'RawHTK':
rate, data = readhtks(ecog_path, ekg_elecs)
elif os.path.split(ecog_path)[1] == 'ecog.mat':
with File(ecog_path, 'r') as f:
data = f['ecogDS']['data'][:, ekg_elecs]
rate = f['ecogDS']['sampFreq'][:].ravel()[0]
elif os.path.split(ecog_path)[1] == 'raw.mat':
rate, data = load_wavs(ecog_path, ekg_elecs)
ekg_ts = TimeSeries('EKG',
H5DataIO(data, compression='gzip'),
unit='V',
rate=rate,
conversion=.001,
description='electrotorticography')
nwbfile.add_acquisition(ekg_ts)
def test_init(self):
ts = TimeSeries('test_ts',
'a hypothetical source',
list(),
'unit',
timestamps=list())
iS = IndexSeries('test_iS',
'a hypothetical source',
list(),
'unit',
ts,
timestamps=list())
self.assertEqual(iS.name, 'test_iS')
self.assertEqual(iS.source, 'a hypothetical source')
self.assertEqual(iS.unit, 'unit')
self.assertEqual(iS.indexed_timeseries, ts)
def test_copy(self):
self.nwbfile.add_unit(spike_times=[1., 2., 3.])
device = self.nwbfile.create_device('a')
elecgrp = self.nwbfile.create_electrode_group('a', 'b', device=device, location='a')
self.nwbfile.add_electrode(np.nan, np.nan, np.nan, np.nan, 'a', 'a', elecgrp, id=0)
self.nwbfile.add_electrode(np.nan, np.nan, np.nan, np.nan, 'b', 'b', elecgrp)
elec_region = self.nwbfile.create_electrode_table_region([1], 'name')
ts1 = TimeSeries('test_ts1', [0, 1, 2, 3, 4, 5], 'grams', timestamps=[0.0, 0.1, 0.2, 0.3, 0.4, 0.5])
ts2 = ElectricalSeries('test_ts2', [0, 1, 2, 3, 4, 5],
electrodes=elec_region, timestamps=[0.0, 0.1, 0.2, 0.3, 0.4, 0.5])
self.nwbfile.add_acquisition(ts1)
self.nwbfile.add_acquisition(ts2)
self.nwbfile.add_trial(start_time=50.0, stop_time=70.0)
self.nwbfile.add_invalid_times_column('comments', 'description of reason for omitting time')
self.nwbfile.create_processing_module('test_mod', 'test_description')
self.nwbfile.create_time_intervals('custom_interval', 'a custom time interval')
self.nwbfile.intervals['custom_interval'].add_interval(start_time=10., stop_time=20.)
newfile = self.nwbfile.copy()
# test dictionaries
self.assertIs(self.nwbfile.devices['a'], newfile.devices['a'])
self.assertIs(self.nwbfile.acquisition['test_ts1'], newfile.acquisition['test_ts1'])
self.assertIs(self.nwbfile.acquisition['test_ts2'], newfile.acquisition['test_ts2'])
self.assertIs(self.nwbfile.processing['test_mod'], newfile.processing['test_mod'])
# test dynamic tables
self.assertIsNot(self.nwbfile.electrodes, newfile.electrodes)
self.assertIs(self.nwbfile.electrodes['x'], newfile.electrodes['x'])
self.assertIsNot(self.nwbfile.units, newfile.units)
self.assertIs(self.nwbfile.units['spike_times'], newfile.units['spike_times'])
self.assertIsNot(self.nwbfile.trials, newfile.trials)
self.assertIsNot(self.nwbfile.trials.parent, newfile.trials.parent)
self.assertIs(self.nwbfile.trials.id, newfile.trials.id)
self.assertIs(self.nwbfile.trials['start_time'], newfile.trials['start_time'])
self.assertIs(self.nwbfile.trials['stop_time'], newfile.trials['stop_time'])
self.assertIsNot(self.nwbfile.invalid_times, newfile.invalid_times)
self.assertTupleEqual(self.nwbfile.invalid_times.colnames, newfile.invalid_times.colnames)
self.assertIsNot(self.nwbfile.intervals['custom_interval'], newfile.intervals['custom_interval'])
self.assertTupleEqual(self.nwbfile.intervals['custom_interval'].colnames,
newfile.intervals['custom_interval'].colnames)
self.assertIs(self.nwbfile.intervals['custom_interval']['start_time'],
newfile.intervals['custom_interval']['start_time'])
self.assertIs(self.nwbfile.intervals['custom_interval']['stop_time'],
newfile.intervals['custom_interval']['stop_time'])
def setUp(self):
type_map = get_type_map()
self.manager = BuildManager(type_map)
self.path = "test_pynwb_io_hdf5.h5"
self.start_time = datetime(1970, 1, 1, 12, 0, 0)
self.create_date = datetime(2017, 4, 15, 12, 0, 0)
self.ts_builder = GroupBuilder('test_timeseries',
attributes={'ancestry': 'TimeSeries',
'source': 'example_source',
'neurodata_type': 'TimeSeries',
'help': 'General purpose TimeSeries'},
datasets={'data': DatasetBuilder('data', list(range(100, 200, 10)),
attributes={'unit': 'SIunit',
'conversion': 1.0,
'resolution': 0.1}),
'timestamps': DatasetBuilder(
'timestamps', list(range(10)),
attributes={'unit': 'Seconds', 'interval': 1})})
self.ts = TimeSeries('test_timeseries', 'example_source', list(range(100, 200, 10)),
unit='SIunit', resolution=0.1, timestamps=list(range(10)))
self.manager.prebuilt(self.ts, self.ts_builder)
self.builder = GroupBuilder(
'root',
groups={'acquisition':
GroupBuilder('acquisition',
groups={'timeseries':
GroupBuilder('timeseries',
groups={'test_timeseries': self.ts_builder}),
'images': GroupBuilder('images')}),
'analysis': GroupBuilder('analysis'),
'epochs': GroupBuilder('epochs'),
'general': GroupBuilder('general'),
'processing': GroupBuilder('processing'),
'stimulus': GroupBuilder(
'stimulus',
groups={'presentation':
GroupBuilder('presentation'),
'templates': GroupBuilder('templates')})},
datasets={'file_create_date': DatasetBuilder('file_create_date', [str(self.create_date)]),
'identifier': DatasetBuilder('identifier', 'TEST123'),
'session_description': DatasetBuilder('session_description', 'a test NWB File'),
'nwb_version': DatasetBuilder('nwb_version', '1.0.6'),
'session_start_time': DatasetBuilder('session_start_time', str(self.start_time))},
attributes={'neurodata_type': 'NWBFile'})
def lick_piezo():
"""
Adds lick_piezo to acquisition.
Needs data from lickPiezo.raw.npy and lickPiezo.timestamps.npy.
"""
lp_raw = read_npy_file('lickPiezo.raw.npy')
lp_timestamps = read_npy_file('lickPiezo.timestamps.npy')
lp_rate = get_rate(lp_timestamps)
lick_piezo_ts = TimeSeries(
name='lickPiezo',
starting_time=lp_timestamps[0, 1],
rate=lp_rate,
data=np.ravel(lp_raw),
unit='V',
description='Voltage values from a thin-film piezo connected to the '
'lick spout, so that values are proportional to deflection '
'of the spout and licks can be detected as peaks of the signal.')
nwb_file.add_acquisition(lick_piezo_ts)
def sparse_noise():
"""
Adds receptive field mapping task to nwb_file.stimulus.
Needs data from sparseNoise.positions.npy and sparseNoise.times.npy.
"""
sparse_noise_pos = read_npy_file('sparseNoise.positions.npy')
sparse_noise_time = read_npy_file('sparseNoise.times.npy')
sp_noise = TimeSeries(
name='receptive_field_mapping_sparse_noise',
timestamps=np.ravel(sparse_noise_time),
data=sparse_noise_pos,
unit='degrees visual angle',
description='White squares shown on the screen with randomized '
'positions and timing - see manuscript Methods.',
comments='The altitude (first column) and azimuth (second column) '
'of the square.')
nwb_file.add_stimulus(sp_noise)
def test_get_neurodata_type(self):
ts1 = TimeSeries('test_ts1', [0, 1, 2, 3, 4, 5],
'grams',
timestamps=[0.0, 0.1, 0.2, 0.3, 0.4, 0.5])
ts2 = TimeSeries('test_ts2', [0, 1, 2, 3, 4, 5],
'grams',
timestamps=[0.0, 0.1, 0.2, 0.3, 0.4, 0.5])
self.nwbfile.add_acquisition(ts1)
self.nwbfile.add_acquisition(ts2)
p1 = ts1.get_ancestor(neurodata_type='NWBFile')
self.assertIs(p1, self.nwbfile)
p2 = ts2.get_ancestor(neurodata_type='NWBFile')
self.assertIs(p2, self.nwbfile)
def test_constructor(self):
"""Test that the constructors."""
eye_tracking = EllipseSeries(name='eye_tracking',
data=np.ones((100, 2)),
reference_frame='nose',
area=np.ones((100, )),
width=np.ones((100, )),
height=np.ones((100, )),
angle=np.ones((100, )),
timestamps=np.arange(100) / 20)
pupil_tracking = EllipseSeries(name='pupil_tracking',
data=np.ones((100, 2)),
reference_frame='nose',
area=np.ones((100, )),
width=np.ones((100, )),
height=np.ones((100, )),
angle=np.ones((100, )),
timestamps=eye_tracking)
corneal_reflection_tracking = EllipseSeries(
name='corneal_reflection_tracking',
data=np.ones((100, 2)),
reference_frame='nose',
area=np.ones((100, )),
width=np.ones((100, )),
height=np.ones((100, )),
angle=np.ones((100, )),
timestamps=eye_tracking)
likely_blink = TimeSeries(timestamps=[1.0, 5.0, 6.0],
data=[1, 1, 1],
name='likely_blink',
description='blinks',
unit='N/A')
ellipse_eye_tracking = EllipseEyeTracking(
eye_tracking=eye_tracking,
pupil_tracking=pupil_tracking,
corneal_reflection_tracking=corneal_reflection_tracking,
likely_blink=likely_blink)
return ellipse_eye_tracking
def setUp(self):
self.start_time = datetime(1971, 1, 1, 12, tzinfo=tzutc())
self.data = np.arange(2000).reshape((2, 1000))
self.timestamps = np.linspace(0, 1, 1000)
self.container = TimeSeries(
name='data_ts',
unit='V',
data=self.data,
timestamps=self.timestamps
)
self.data_filename = os.path.join(os.getcwd(), 'test_time_series_modular_data.nwb')
self.link_filename = os.path.join(os.getcwd(), 'test_time_series_modular_link.nwb')
self.read_container = None
self.link_read_io = None
self.data_read_io = None
def roundtripContainer(self):
# create and write data file
data_file = NWBFile(
session_description='a test file',
identifier='data_file',
session_start_time=self.start_time
)
data_file.add_acquisition(self.container)
with HDF5IO(self.data_filename, 'w', manager=get_manager()) as data_write_io:
data_write_io.write(data_file)
# read data file
with HDF5IO(self.data_filename, 'r', manager=get_manager()) as self.data_read_io:
data_file_obt = self.data_read_io.read()
# write "link file" with timeseries.data that is an external link to the timeseries in "data file"
# also link timeseries.timestamps.data to the timeseries.timestamps in "data file"
with HDF5IO(self.link_filename, 'w', manager=get_manager()) as link_write_io:
link_file = NWBFile(
session_description='a test file',
identifier='link_file',
session_start_time=self.start_time
)
self.link_container = TimeSeries(
name='test_mod_ts',
unit='V',
data=data_file_obt.get_acquisition('data_ts'), # test direct link
timestamps=H5DataIO(
data=data_file_obt.get_acquisition('data_ts').timestamps,
link_data=True # test with setting link data
)
)
link_file.add_acquisition(self.link_container)
link_write_io.write(link_file)
# note that self.link_container contains a link to a dataset that is now closed
# read the link file
self.link_read_io = HDF5IO(self.link_filename, 'r', manager=get_manager())
self.read_nwbfile = self.link_read_io.read()
return self.getContainer(self.read_nwbfile)
def test_init(self):
tstamps = np.arange(1.0, 100.0, 0.1, dtype=np.float)
ts = TimeSeries("test_ts",
"a hypothetical source",
list(range(len(tstamps))),
'unit',
timestamps=tstamps)
tsi = TimeSeriesIndex()
tsi.add_row(40, 105, ts)
ept = EpochTable()
self.assertEqual(ept.name, 'epochs')
ept.add_row(10.0, 20.0, "test,unittest,pynwb",
ListSlicer(tsi.data, slice(0, 1)), 'a test epoch')
row = ept[0]
self.assertEqual(row[0], 10.0)
self.assertEqual(row[1], 20.0)
self.assertEqual(row[2], "test,unittest,pynwb")
self.assertEqual(row[3].data, tsi.data)
self.assertEqual(row[3].region, slice(0, 1))
self.assertEqual(row[4], 'a test epoch')
def run_conversion(self,
nwbfile: NWBFile,
metadata: dict = None,
stub_test: bool = False):
conditions = intervals_from_traces(self.recording_extractor)
mech_stim = TimeIntervals(
name='MechanicalStimulus',
description=
"Activation times inferred from TTL commands for mechanical stimulus."
)
laser_stim = TimeIntervals(
name='LaserStimulus',
description=
"Activation times inferred from TTL commands for cortical laser stimulus."
)
for j, table in enumerate([mech_stim, laser_stim]):
for row in conditions[j]:
table.add_row(
dict(start_time=float(row[0]), stop_time=float(row[1])))
# TODO - these really should be IntervalSeries added to stimulus, rather than processing
check_module(nwbfile, 'stimulus',
"Contains stimuli data.").add(mech_stim)
check_module(nwbfile, 'stimulus',
"Contains stimuli data.").add(laser_stim)
if stub_test or self.subset_channels is not None:
recording = self.subset_recording(stub_test=stub_test)
else:
recording = self.recording_extractor
# Pressure values
nwbfile.add_stimulus(
TimeSeries(
name='MechanicalPressure',
data=H5DataIO(recording.get_traces(0), compression="gzip"),
unit=self.recording_extractor._channel_smrxinfo[0]['unit'],
conversion=recording.get_channel_property(0, 'gain'),
rate=recording.get_sampling_frequency(),
description=
"Pressure sensor attached to the mechanical stimulus used to repeatedly evoke spiking."
))
def align_by_trials(
timeseries: TimeSeries,
start_label="start_time",
before=0.0,
after=1.0,
):
"""
Args:
timeseries: TimeSeries
start_label: str
default: 'start_time'
before: float
time after start_label in secs (positive goes back in time)
after: float
time after stop_label in secs (positive goes forward in time)
Returns:
np.array(shape=(n_trials, n_time, ...))
"""
trials = timeseries.get_ancestor("NWBFile").trials
return align_by_time_intervals(timeseries, trials, start_label, before,
after)
def test_write_dataset_datachunkiterator_with_compression(self):
a = np.arange(30).reshape(5, 2, 3)
aiter = iter(a)
daiter = DataChunkIterator.from_iterable(aiter, buffer_size=2)
wrapped_daiter = H5DataIO(data=daiter,
compression='gzip',
compression_opts=5,
shuffle=True,
fletcher32=True)
ts = TimeSeries(name='ts_name', data=wrapped_daiter, unit='A', timestamps=np.arange(5.))
self.nwbfile.add_acquisition(ts)
with NWBHDF5IO(self.path, 'w') as io:
io.write(self.nwbfile, cache_spec=False)
with File(self.path, 'r') as f:
dset = f['/acquisition/ts_name/data']
self.assertEqual(dset.shape, a.shape)
self.assertListEqual(dset[:].tolist(), a.tolist())
self.assertEqual(dset.compression, 'gzip')
self.assertEqual(dset.compression_opts, 5)
self.assertEqual(dset.shuffle, True)
self.assertEqual(dset.fletcher32, True)
def setUpContainer(self):
container = NWBFile('a test source',
'a test NWB File',
'TEST123',
self.start_time,
file_create_date=self.create_date)
ts = TimeSeries('test_timeseries',
'example_source',
list(range(100, 200, 10)),
'SIunit',
timestamps=list(range(10)),
resolution=0.1)
container.add_acquisition(ts)
mod = container.create_processing_module(
'test_module', 'a test source for a ProcessingModule',
'a test module')
mod.add_container(
Clustering("an example source for Clustering",
"A fake Clustering interface", [0, 1, 2, 0, 1, 2],
[100, 101, 102], list(range(10, 61, 10))))
return container
def face_nwb():
"""
Adds Face Energy BehavioralTimeSeries to behavior processing module.
Needs data from face.motionEnergy.npy and face.timestamps.npy.
"""
face_motion_energy = read_npy_file('face.motionEnergy.npy')
face_timestamps = read_npy_file('face.timestamps.npy')
face_rate = get_rate(face_timestamps)
face_energy = TimeSeries(
name='face_motion_energy',
data=np.ravel(face_motion_energy),
unit='arb. unit',
starting_time=face_timestamps[0, 1],
rate=face_rate,
description='Features extracted from the video of the frontal aspect of '
'the subject, including the subject\'s face and forearms.',
comments='The integrated motion energy across the whole frame, i.e. '
'sum( (thisFrame-lastFrame)^2 ). Some smoothing is applied '
'before this operation.')
face_interface = BehavioralTimeSeries(face_energy)
behavior_module.add_data_interface(face_interface)
def _test_scratch_container(self, validate=True, **kwargs):
data = TimeSeries('test_ts', [1, 2, 3, 4, 5],
unit='unit',
timestamps=[1.1, 1.2, 1.3, 1.4, 1.5])
nwbfile = NWBFile('test',
'test',
self.start_time,
file_create_date=self.create_date)
nwbfile.add_scratch(data, **kwargs)
self.writer = NWBHDF5IO(self.filename, mode='w')
self.writer.write(nwbfile)
self.writer.close()
self.reader = NWBHDF5IO(self.filename, mode='r')
self.read_nwbfile = self.reader.read()
ret = self.read_nwbfile.get_scratch('test_ts')
self.assertContainerEqual(data, ret)
if validate:
self.validate()
def setUpContainer(self):
container = NWBFile(
'a test source',
'a test NWB File',
'TEST123',
self.start_time,
file_create_date=self.create_date,
experimenter='test experimenter',
stimulus_notes='test stimulus notes',
experiment_description='test experiment description',
data_collection='test data collection notes',
institution='nomad',
lab='nolab',
notes='nonotes',
pharmacology='nopharmacology',
protocol='noprotocol',
related_publications='nopubs',
session_id='007',
slices='noslices',
source_script='nosources',
surgery='nosurgery',
virus='novirus',
source_script_file_name='nofilename')
self.ts = TimeSeries('test_timeseries',
'example_source',
list(range(100, 200, 10)),
'SIunit',
timestamps=list(range(10)),
resolution=0.1)
container.add_acquisition(self.ts)
self.mod = container.create_processing_module(
'test_module', 'a test source for a ProcessingModule',
'a test module')
self.clustering = Clustering("an example source for Clustering",
"A fake Clustering interface",
[0, 1, 2, 0, 1, 2], [100, 101, 102],
list(range(10, 61, 10)))
self.mod.add_container(self.clustering)
return container
def ncs_to_timeseries(ncs, data_time_len, downsample=4):
rate = float(ncs['sampling_rate'])
# Use AcqEntName instead of channel_number to infer channel
ch = ncs['channel_number']
# ch = int(ncs['header']['AcqEntName'][3:])
n_samples = int(data_time_len * rate)
if downsample:
data = ncs['data'][:n_samples:downsample]
rate = rate / downsample
else:
data = ncs['data']
# ch_ts = TimeSeries(name='channel_{}'.format(ch),rate =rate, data=data.astype(np.float16),conversion=1.0/10**6,unit='V')
ts_kwargs = {
'name': 'channel_{}'.format(ch + 1),
'rate': rate,
'data': data.astype(np.float16),
'conversion': 1.0 / 10**6,
'comments': ncs['header']['AcqEntName']
}
return TimeSeries(**ts_kwargs)
def to_nwb(self, nwbfile: NWBFile) -> NWBFile:
# If there is no lick data, do not write
# anything to the NWB file (this is
# expected for passive sessions)
if len(self.value['frame']) == 0:
return nwbfile
lick_timeseries = TimeSeries(
name='licks',
data=self.value['frame'].values,
timestamps=self.value['timestamps'].values,
description=('Timestamps and stimulus presentation '
'frame indices for lick events'),
unit='N/A')
# Add lick interface to nwb file, by way of a processing module:
licks_mod = ProcessingModule('licking',
'Licking behavior processing module')
licks_mod.add_data_interface(lick_timeseries)
nwbfile.add_processing_module(licks_mod)
return nwbfile
def ncs_to_timeseries(ncs, data_time_len=None, fs=1000, dtype=np.float16):
rate = float(ncs['sampling_rate'])
n_samples = None
# Use AcqEntName instead of channel_number to infer channel
ch = ncs['channel_number']
# ch = int(ncs['header']['AcqEntName'][3:])
if fs:
downsample = int(rate / fs)
rate = fs
else:
downsample = 1
if data_time_len:
n_samples = int(data_time_len * rate)
data = ncs['data'][:n_samples:downsample]
else:
data = ncs['data']
# ch_ts = TimeSeries(name='channel_{}'.format(ch),rate =rate, data=data.astype(np.float16),conversion=1.0/10**6,unit='V')
ts_kwargs = {
'name':
os.path.split(ncs['file_path'])[1],
'rate':
float(rate),
'data':
data.astype(dtype),
'starting_time':
ncs['timestamp'][0] / 1000 / 1000,
'comments':
'{} originally from file {}'.format(ncs['header']['AcqEntName'],
ncs['file_path']),
'unit':
'uV',
}
return TimeSeries(**ts_kwargs)
def run(self):
ts_file, dat_file = self.input()[0]
print(ts_file, ts_file.path)
start_time = np.load(ts_file.path)[0]
self.default_ts = self.make_timeseries(ts_file, dat_file, 1)
print(self.default_ts.timestamps)
nwbfile = NWBFile(
session_description='pt1 Neuralynx Data',
identifier='pt1',
session_start_time=datetime.fromtimestamp(start_time / 1000 /
1000),
)
nwbfile.add_acquisition(self.default_ts)
i = 2
for ts_out, dat_out in tqdm(self.input(),
total=len(self.channels),
desc='Creating Channels'):
nts = np.load(ts_out.path) / 1000 / 1000
if np.all(nts == self.default_ts.timestamps):
nts = self.default_ts
dat = np.load(dat_out.path)
ch_ts = TimeSeries(
name='channel_{}'.format(i),
timestamps=nts,
data=dat,
unit='uV',
)
nwbfile.add_acquisition(ch_ts)
i += 1
out_fp = os.path.join(self.save_path(), 'data.nwb')
with NWBHDF5IO(out_fp, 'w') as io:
io.write(nwbfile)
create_date = datetime(2017, 4, 15, 12, tzinfo=tzlocal())
data = np.arange(1000).reshape((100, 10))
timestamps = np.arange(100)
filename1 = 'external1_example.nwb'
filename2 = 'external2_example.nwb'
filename3 = 'external_linkcontainer_example.nwb'
filename4 = 'external_linkdataset_example.nwb'
# Create the first file
nwbfile1 = NWBFile(session_description='demonstrate external files',
identifier='NWBE1',
session_start_time=start_time,
file_create_date=create_date)
# Create the second file
test_ts1 = TimeSeries(name='test_timeseries1',
data=data,
unit='SIunit',
timestamps=timestamps)
nwbfile1.add_acquisition(test_ts1)
# Write the first file
io = NWBHDF5IO(filename1, 'w')
io.write(nwbfile1)
io.close()
# Create the second file
nwbfile2 = NWBFile(session_description='demonstrate external files',
identifier='NWBE2',
session_start_time=start_time,
file_create_date=create_date)
# Create the second file
test_ts2 = TimeSeries(name='test_timeseries2',
data=data,
