class NixIOWriteTest(NixIOTest):
def setUp(self):
self.filename = "nixio_testfile_write.h5"
self.writer = NixIO(self.filename, "ow")
self.io = self.writer
self.reader = nix.File.open(self.filename,
nix.FileMode.ReadOnly,
backend="h5py")
def tearDown(self):
self.writer.close()
self.reader.close()
os.remove(self.filename)
def write_and_compare(self, blocks):
self.writer.write_all_blocks(blocks)
self.compare_blocks(self.writer.read_all_blocks(), self.reader.blocks)
self.compare_blocks(blocks, self.reader.blocks)
def test_block_write(self):
block = Block(name=self.rword(),
description=self.rsentence())
self.write_and_compare([block])
block.annotate(**self.rdict(5))
self.write_and_compare([block])
def test_segment_write(self):
block = Block(name=self.rword())
segment = Segment(name=self.rword(), description=self.rword())
block.segments.append(segment)
self.write_and_compare([block])
segment.annotate(**self.rdict(2))
self.write_and_compare([block])
def test_channel_index_write(self):
block = Block(name=self.rword())
chx = ChannelIndex(name=self.rword(),
description=self.rsentence(),
channel_ids=[10, 20, 30, 50, 80, 130],
index=[1, 2, 3, 5, 8, 13])
block.channel_indexes.append(chx)
self.write_and_compare([block])
chx.annotate(**self.rdict(3))
self.write_and_compare([block])
chx.channel_names = ["one", "two", "three", "five",
"eight", "xiii"]
self.write_and_compare([block])
def test_signals_write(self):
block = Block()
seg = Segment()
block.segments.append(seg)
asig = AnalogSignal(signal=self.rquant((10, 3), pq.mV),
sampling_rate=pq.Quantity(10, "Hz"))
seg.analogsignals.append(asig)
self.write_and_compare([block])
anotherblock = Block("ir signal block")
seg = Segment("ir signal seg")
anotherblock.segments.append(seg)
irsig = IrregularlySampledSignal(
signal=np.random.random((20, 3)),
times=self.rquant(20, pq.ms, True),
units=pq.A
)
seg.irregularlysampledsignals.append(irsig)
self.write_and_compare([block, anotherblock])
block.segments[0].analogsignals.append(
AnalogSignal(signal=[10.0, 1.0, 3.0], units=pq.S,
sampling_period=pq.Quantity(3, "s"),
dtype=np.double, name="signal42",
description="this is an analogsignal",
t_start=45 * pq.ms),
)
self.write_and_compare([block, anotherblock])
block.segments[0].irregularlysampledsignals.append(
IrregularlySampledSignal(times=np.random.random(10),
signal=np.random.random((10, 3)),
units="mV", time_units="s",
dtype=np.float,
name="some sort of signal",
description="the signal is described")
)
self.write_and_compare([block, anotherblock])
def test_epoch_write(self):
block = Block()
seg = Segment()
block.segments.append(seg)
epoch = Epoch(times=[1, 1, 10, 3]*pq.ms, durations=[3, 3, 3, 1]*pq.ms,
labels=np.array(["one", "two", "three", "four"]),
name="test epoch", description="an epoch for testing")
seg.epochs.append(epoch)
self.write_and_compare([block])
def test_event_write(self):
block = Block()
seg = Segment()
block.segments.append(seg)
event = Event(times=np.arange(0, 30, 10)*pq.s,
labels=np.array(["0", "1", "2"]),
name="event name",
description="event description")
seg.events.append(event)
self.write_and_compare([block])
def test_spiketrain_write(self):
block = Block()
seg = Segment()
block.segments.append(seg)
spiketrain = SpikeTrain(times=[3, 4, 5]*pq.s, t_stop=10.0,
name="spikes!", description="sssssspikes")
seg.spiketrains.append(spiketrain)
self.write_and_compare([block])
waveforms = self.rquant((3, 5, 10), pq.mV)
spiketrain = SpikeTrain(times=[1, 1.1, 1.2]*pq.ms, t_stop=1.5*pq.s,
name="spikes with wf",
description="spikes for waveform test",
waveforms=waveforms)
seg.spiketrains.append(spiketrain)
self.write_and_compare([block])
spiketrain.left_sweep = np.random.random(10)*pq.ms
self.write_and_compare([block])
def test_metadata_structure_write(self):
neoblk = self.create_all_annotated()
self.io.write_block(neoblk)
blk = self.io.nix_file.blocks[0]
blkmd = blk.metadata
self.assertEqual(blk.name, blkmd.name)
grp = blk.groups[0] # segment
self.assertIn(grp.name, blkmd.sections)
grpmd = blkmd.sections[grp.name]
for da in grp.data_arrays: # signals
name = ".".join(da.name.split(".")[:-1])
self.assertIn(name, grpmd.sections)
for mtag in grp.multi_tags: # spiketrains, events, and epochs
self.assertIn(mtag.name, grpmd.sections)
srcchx = blk.sources[0] # chx
self.assertIn(srcchx.name, blkmd.sections)
for srcunit in blk.sources: # units
self.assertIn(srcunit.name, blkmd.sections)
self.write_and_compare([neoblk])
def test_anonymous_objects_write(self):
nblocks = 2
nsegs = 2
nanasig = 4
nirrseg = 2
nepochs = 3
nevents = 4
nspiketrains = 3
nchx = 5
nunits = 10
times = self.rquant(1, pq.s)
signal = self.rquant(1, pq.V)
blocks = []
for blkidx in range(nblocks):
blk = Block()
blocks.append(blk)
for segidx in range(nsegs):
seg = Segment()
blk.segments.append(seg)
for anaidx in range(nanasig):
seg.analogsignals.append(AnalogSignal(signal=signal,
sampling_rate=pq.Hz))
for irridx in range(nirrseg):
seg.irregularlysampledsignals.append(
IrregularlySampledSignal(times=times,
signal=signal,
time_units=pq.s)
)
for epidx in range(nepochs):
seg.epochs.append(Epoch(times=times, durations=times))
for evidx in range(nevents):
seg.events.append(Event(times=times))
for stidx in range(nspiketrains):
seg.spiketrains.append(SpikeTrain(times=times,
t_stop=times[-1]+pq.s,
units=pq.s))
for chidx in range(nchx):
chx = ChannelIndex(name="chx{}".format(chidx),
index=[1, 2],
channel_ids=[11, 22])
blk.channel_indexes.append(chx)
for unidx in range(nunits):
unit = Unit()
chx.units.append(unit)
self.writer.write_all_blocks(blocks)
self.compare_blocks(blocks, self.reader.blocks)
def test_multiref_write(self):
blk = Block("blk1")
signal = AnalogSignal(name="sig1", signal=[0, 1, 2], units="mV",
sampling_period=pq.Quantity(1, "ms"))
for idx in range(3):
segname = "seg" + str(idx)
seg = Segment(segname)
blk.segments.append(seg)
seg.analogsignals.append(signal)
chidx = ChannelIndex([10, 20, 29])
seg = blk.segments[0]
st = SpikeTrain(name="choochoo", times=[10, 11, 80], t_stop=1000,
units="s")
seg.spiketrains.append(st)
blk.channel_indexes.append(chidx)
for idx in range(6):
unit = Unit("unit" + str(idx))
chidx.units.append(unit)
unit.spiketrains.append(st)
self.writer.write_block(blk)
self.compare_blocks([blk], self.reader.blocks)
def test_to_value(self):
section = self.io.nix_file.create_section("Metadata value test",
"Test")
writeprop = self.io._write_property
# quantity
qvalue = pq.Quantity(10, "mV")
writeprop(section, "qvalue", qvalue)
self.assertEqual(section["qvalue"], 10)
self.assertEqual(section.props["qvalue"].unit, "mV")
# datetime
dt = self.rdate()
writeprop(section, "dt", dt)
self.assertEqual(datetime.fromtimestamp(section["dt"]), dt)
# string
randstr = self.rsentence()
writeprop(section, "randstr", randstr)
self.assertEqual(section["randstr"], randstr)
# bytes
bytestring = b"bytestring"
writeprop(section, "randbytes", bytestring)
self.assertEqual(section["randbytes"], bytestring.decode())
# iterables
randlist = np.random.random(10).tolist()
writeprop(section, "randlist", randlist)
self.assertEqual(randlist, section["randlist"])
randarray = np.random.random(10)
writeprop(section, "randarray", randarray)
np.testing.assert_almost_equal(randarray, section["randarray"])
# numpy item
npval = np.float64(2398)
writeprop(section, "npval", npval)
self.assertEqual(npval, section["npval"])
# number
val = 42
writeprop(section, "val", val)
self.assertEqual(val, section["val"])
epoch_times = tstart + np.cumsum(np.random.random(3)) * pq.ms
epoch = Epoch(name="Seg {} :: Epoch".format(idx),
times=epoch_times,
durations=np.random.random(4) * pq.ms,
labels=["A+", "B+", "C+"])
seg.epochs.append(epoch)
st_times = tstart + np.cumsum(np.random.random(10)) * pq.ms
tstop = max(event_times[-1], epoch_times[-1], st_times[-1]) + 1 * pq.ms
st = SpikeTrain(name="Seg {} :: SpikeTrain".format(idx),
times=st_times,
t_start=tstart,
t_stop=tstop)
st.sampling_rate = sampling_rate
seg.spiketrains.append(st)
unit = Unit(name="unit-{}".format(idx))
unit.spiketrains.append(st)
chx.units.append(unit)
# Write the Block to file using the NixIO
# Any existing file will be overwritten
fname = "neoraw.nix"
io = NixIO(fname, "ow")
io.write_block(block1)
io.write_block(block2)
io.close()
print("Done. Saved to {}".format(fname))
# random sampling times for data_b
data_b_t = np.cumsum(np.random.random(1200))
# Create one AnalogSignal and one IrregularlySampledSignal
asig_a = AnalogSignal(name="Data A",
signal=data_a,
units="mV",
sampling_rate=pq.Quantity(10, "Hz"))
isig_a = IrregularlySampledSignal(name="Sampled data",
signal=data_b,
units="nA",
times=data_b_t,
time_units="ms")
# Attach the signals to the first segment
seg_a.analogsignals.append(asig_a)
seg_a.irregularlysampledsignals.append(isig_a)
# Create a second AnalogSignal and attach it to the second segment
st_a = AnalogSignal(name="Data A",
signal=data_c * pq.mV,
sampling_rate=20 * pq.Hz)
seg_b.analogsignals.append(st_a)
# Write the Block to file using the NixIO
# Replace NixIO with any other IO to change storage format
io = NixIO("example-file.nix", mode='ow')
io.write_block(block)
io.close()
class NixIOWriteTest(NixIOTest):
def setUp(self):
self.tempdir = mkdtemp(prefix="nixiotest")
self.filename = os.path.join(self.tempdir, "testnixio.nix")
self.writer = NixIO(self.filename, "ow")
self.io = self.writer
self.reader = nix.File.open(self.filename,
nix.FileMode.ReadOnly,
backend="h5py")
def tearDown(self):
self.writer.close()
self.reader.close()
shutil.rmtree(self.tempdir)
def write_and_compare(self, blocks):
self.writer.write_all_blocks(blocks)
self.compare_blocks(blocks, self.reader.blocks)
self.compare_blocks(self.writer.read_all_blocks(), self.reader.blocks)
self.compare_blocks(blocks, self.reader.blocks)
def test_block_write(self):
block = Block(name=self.rword(), description=self.rsentence())
self.write_and_compare([block])
block.annotate(**self.rdict(5))
self.write_and_compare([block])
def test_segment_write(self):
block = Block(name=self.rword())
segment = Segment(name=self.rword(), description=self.rword())
block.segments.append(segment)
self.write_and_compare([block])
segment.annotate(**self.rdict(2))
self.write_and_compare([block])
def test_channel_index_write(self):
block = Block(name=self.rword())
chx = ChannelIndex(name=self.rword(),
description=self.rsentence(),
channel_ids=[10, 20, 30, 50, 80, 130],
index=[1, 2, 3, 5, 8, 13])
block.channel_indexes.append(chx)
self.write_and_compare([block])
chx.annotate(**self.rdict(3))
self.write_and_compare([block])
chx.channel_names = ["one", "two", "three", "five", "eight", "xiii"]
chx.coordinates = self.rquant((6, 3), pq.um)
self.write_and_compare([block])
# add an empty channel index and check again
newchx = ChannelIndex(np.array([]))
block.channel_indexes.append(newchx)
self.write_and_compare([block])
def test_signals_write(self):
block = Block()
seg = Segment()
block.segments.append(seg)
asig = AnalogSignal(signal=self.rquant((10, 3), pq.mV),
sampling_rate=pq.Quantity(10, "Hz"))
seg.analogsignals.append(asig)
self.write_and_compare([block])
anotherblock = Block("ir signal block")
seg = Segment("ir signal seg")
anotherblock.segments.append(seg)
irsig = IrregularlySampledSignal(signal=np.random.random((20, 3)),
times=self.rquant(20, pq.ms, True),
units=pq.A)
seg.irregularlysampledsignals.append(irsig)
self.write_and_compare([block, anotherblock])
block.segments[0].analogsignals.append(
AnalogSignal(signal=[10.0, 1.0, 3.0],
units=pq.S,
sampling_period=pq.Quantity(3, "s"),
dtype=np.double,
name="signal42",
description="this is an analogsignal",
t_start=45 * pq.ms), )
self.write_and_compare([block, anotherblock])
block.segments[0].irregularlysampledsignals.append(
IrregularlySampledSignal(times=np.random.random(10),
signal=np.random.random((10, 3)),
units="mV",
time_units="s",
dtype=np.float,
name="some sort of signal",
description="the signal is described"))
self.write_and_compare([block, anotherblock])
def test_signals_compound_units(self):
block = Block()
seg = Segment()
block.segments.append(seg)
units = pq.CompoundUnit("1/30000*V")
srate = pq.Quantity(10, pq.CompoundUnit("1.0/10 * Hz"))
asig = AnalogSignal(signal=self.rquant((10, 3), units),
sampling_rate=srate)
seg.analogsignals.append(asig)
self.write_and_compare([block])
anotherblock = Block("ir signal block")
seg = Segment("ir signal seg")
anotherblock.segments.append(seg)
irsig = IrregularlySampledSignal(signal=np.random.random((20, 3)),
times=self.rquant(
20, pq.CompoundUnit("0.1 * ms"),
True),
units=pq.CompoundUnit("10 * V / s"))
seg.irregularlysampledsignals.append(irsig)
self.write_and_compare([block, anotherblock])
block.segments[0].analogsignals.append(
AnalogSignal(signal=[10.0, 1.0, 3.0],
units=pq.S,
sampling_period=pq.Quantity(3, "s"),
dtype=np.double,
name="signal42",
description="this is an analogsignal",
t_start=45 * pq.CompoundUnit("3.14 * s")), )
self.write_and_compare([block, anotherblock])
times = self.rquant(10, pq.CompoundUnit("3 * year"), True)
block.segments[0].irregularlysampledsignals.append(
IrregularlySampledSignal(times=times,
signal=np.random.random((10, 3)),
units="mV",
dtype=np.float,
name="some sort of signal",
description="the signal is described"))
self.write_and_compare([block, anotherblock])
def test_epoch_write(self):
block = Block()
seg = Segment()
block.segments.append(seg)
epoch = Epoch(times=[1, 1, 10, 3] * pq.ms,
durations=[3, 3, 3, 1] * pq.ms,
labels=np.array(["one", "two", "three", "four"]),
name="test epoch",
description="an epoch for testing")
seg.epochs.append(epoch)
self.write_and_compare([block])
def test_event_write(self):
block = Block()
seg = Segment()
block.segments.append(seg)
event = Event(times=np.arange(0, 30, 10) * pq.s,
labels=np.array(["0", "1", "2"]),
name="event name",
description="event description")
seg.events.append(event)
self.write_and_compare([block])
def test_spiketrain_write(self):
block = Block()
seg = Segment()
block.segments.append(seg)
spiketrain = SpikeTrain(times=[3, 4, 5] * pq.s,
t_stop=10.0,
name="spikes!",
description="sssssspikes")
seg.spiketrains.append(spiketrain)
self.write_and_compare([block])
waveforms = self.rquant((3, 5, 10), pq.mV)
spiketrain = SpikeTrain(times=[1, 1.1, 1.2] * pq.ms,
t_stop=1.5 * pq.s,
name="spikes with wf",
description="spikes for waveform test",
waveforms=waveforms)
seg.spiketrains.append(spiketrain)
self.write_and_compare([block])
spiketrain.left_sweep = np.random.random(10) * pq.ms
self.write_and_compare([block])
spiketrain.left_sweep = pq.Quantity(-10, "ms")
self.write_and_compare([block])
def test_metadata_structure_write(self):
neoblk = self.create_all_annotated()
self.io.write_block(neoblk)
blk = self.io.nix_file.blocks[0]
blkmd = blk.metadata
self.assertEqual(blk.name, blkmd.name)
grp = blk.groups[0] # segment
self.assertIn(grp.name, blkmd.sections)
grpmd = blkmd.sections[grp.name]
for da in grp.data_arrays: # signals
name = ".".join(da.name.split(".")[:-1])
self.assertIn(name, grpmd.sections)
for mtag in grp.multi_tags: # spiketrains, events, and epochs
self.assertIn(mtag.name, grpmd.sections)
srcchx = blk.sources[0] # chx
self.assertIn(srcchx.name, blkmd.sections)
for srcunit in blk.sources: # units
self.assertIn(srcunit.name, blkmd.sections)
self.write_and_compare([neoblk])
def test_anonymous_objects_write(self):
nblocks = 2
nsegs = 2
nanasig = 4
nirrseg = 2
nepochs = 3
nevents = 4
nspiketrains = 3
nchx = 5
nunits = 10
times = self.rquant(1, pq.s)
signal = self.rquant(1, pq.V)
blocks = []
for blkidx in range(nblocks):
blk = Block()
blocks.append(blk)
for segidx in range(nsegs):
seg = Segment()
blk.segments.append(seg)
for anaidx in range(nanasig):
seg.analogsignals.append(
AnalogSignal(signal=signal, sampling_rate=pq.Hz))
for irridx in range(nirrseg):
seg.irregularlysampledsignals.append(
IrregularlySampledSignal(times=times,
signal=signal,
time_units=pq.s))
for epidx in range(nepochs):
seg.epochs.append(Epoch(times=times, durations=times))
for evidx in range(nevents):
seg.events.append(Event(times=times))
for stidx in range(nspiketrains):
seg.spiketrains.append(
SpikeTrain(times=times,
t_stop=times[-1] + pq.s,
units=pq.s))
for chidx in range(nchx):
chx = ChannelIndex(name="chx{}".format(chidx),
index=[1, 2],
channel_ids=[11, 22])
blk.channel_indexes.append(chx)
for unidx in range(nunits):
unit = Unit()
chx.units.append(unit)
self.writer.write_all_blocks(blocks)
self.compare_blocks(blocks, self.reader.blocks)
def test_multiref_write(self):
blk = Block("blk1")
signal = AnalogSignal(name="sig1",
signal=[0, 1, 2],
units="mV",
sampling_period=pq.Quantity(1, "ms"))
othersignal = IrregularlySampledSignal(name="i1",
signal=[0, 0, 0],
units="mV",
times=[1, 2, 3],
time_units="ms")
event = Event(name="Evee", times=[0.3, 0.42], units="year")
epoch = Epoch(name="epoche",
times=[0.1, 0.2] * pq.min,
durations=[0.5, 0.5] * pq.min)
st = SpikeTrain(name="the train of spikes",
times=[0.1, 0.2, 10.3],
t_stop=11,
units="us")
for idx in range(3):
segname = "seg" + str(idx)
seg = Segment(segname)
blk.segments.append(seg)
seg.analogsignals.append(signal)
seg.irregularlysampledsignals.append(othersignal)
seg.events.append(event)
seg.epochs.append(epoch)
seg.spiketrains.append(st)
chidx = ChannelIndex([10, 20, 29])
seg = blk.segments[0]
st = SpikeTrain(name="choochoo",
times=[10, 11, 80],
t_stop=1000,
units="s")
seg.spiketrains.append(st)
blk.channel_indexes.append(chidx)
for idx in range(6):
unit = Unit("unit" + str(idx))
chidx.units.append(unit)
unit.spiketrains.append(st)
self.writer.write_block(blk)
self.compare_blocks([blk], self.reader.blocks)
def test_no_segment_write(self):
# Tests storing AnalogSignal, IrregularlySampledSignal, and SpikeTrain
# objects in the secondary (ChannelIndex) substructure without them
# being attached to a Segment.
blk = Block("segmentless block")
signal = AnalogSignal(name="sig1",
signal=[0, 1, 2],
units="mV",
sampling_period=pq.Quantity(1, "ms"))
othersignal = IrregularlySampledSignal(name="i1",
signal=[0, 0, 0],
units="mV",
times=[1, 2, 3],
time_units="ms")
sta = SpikeTrain(name="the train of spikes",
times=[0.1, 0.2, 10.3],
t_stop=11,
units="us")
stb = SpikeTrain(name="the train of spikes b",
times=[1.1, 2.2, 10.1],
t_stop=100,
units="ms")
chidx = ChannelIndex([8, 13, 21])
blk.channel_indexes.append(chidx)
chidx.analogsignals.append(signal)
chidx.irregularlysampledsignals.append(othersignal)
unit = Unit()
chidx.units.append(unit)
unit.spiketrains.extend([sta, stb])
self.writer.write_block(blk)
self.compare_blocks([blk], self.reader.blocks)
self.writer.close()
reader = NixIO(self.filename, "ro")
blk = reader.read_block(neoname="segmentless block")
chx = blk.channel_indexes[0]
self.assertEqual(len(chx.analogsignals), 1)
self.assertEqual(len(chx.irregularlysampledsignals), 1)
self.assertEqual(len(chx.units[0].spiketrains), 2)
def test_to_value(self):
section = self.io.nix_file.create_section("Metadata value test",
"Test")
writeprop = self.io._write_property
# quantity
qvalue = pq.Quantity(10, "mV")
writeprop(section, "qvalue", qvalue)
self.assertEqual(section["qvalue"], 10)
self.assertEqual(section.props["qvalue"].unit, "mV")
# datetime
dt = self.rdate()
writeprop(section, "dt", dt)
self.assertEqual(datetime.fromtimestamp(section["dt"]), dt)
# string
randstr = self.rsentence()
writeprop(section, "randstr", randstr)
self.assertEqual(section["randstr"], randstr)
# bytes
bytestring = b"bytestring"
writeprop(section, "randbytes", bytestring)
self.assertEqual(section["randbytes"], bytestring.decode())
# iterables
randlist = np.random.random(10).tolist()
writeprop(section, "randlist", randlist)
self.assertEqual(randlist, section["randlist"])
randarray = np.random.random(10)
writeprop(section, "randarray", randarray)
np.testing.assert_almost_equal(randarray, section["randarray"])
# numpy item
npval = np.float64(2398)
writeprop(section, "npval", npval)
self.assertEqual(npval, section["npval"])
# number
val = 42
writeprop(section, "val", val)
self.assertEqual(val, section["val"])
# empty string
writeprop(section, "emptystring", "")
self.assertEqual("", section["emptystring"])
def test_annotations_special_cases(self):
# Special cases for annotations: empty list, list of strings,
# multidimensional lists/arrays
# These are handled differently on read, so we test them on a block
# instead of just checking the property writer method
# empty value
# empty list
wblock = Block("block with empty list", an_empty_list=list())
self.writer.write_block(wblock)
rblock = self.writer.read_block(neoname="block with empty list")
self.assertEqual(rblock.annotations["an_empty_list"], list())
# empty tuple (gets read out as list)
wblock = Block("block with empty tuple", an_empty_tuple=tuple())
self.writer.write_block(wblock)
rblock = self.writer.read_block(neoname="block with empty tuple")
self.assertEqual(rblock.annotations["an_empty_tuple"], list())
# list of strings
losval = ["one", "two", "one million"]
wblock = Block("block with list of strings", los=losval)
self.writer.write_block(wblock)
rblock = self.writer.read_block(neoname="block with list of strings")
self.assertEqual(rblock.annotations["los"], losval)
def create_nix_file(file_pat,
output=None,
signed=False,
rate=1,
electrode_scale=0.0104,
analog_scale=12.5122,
channels=channels,
chunks=256 * 1024 * 1024):
'''The default resolution (i.e. voltage per bit) in uV '''
filenames = sorted(glob(file_pat))
dtype = np.int16 if signed else np.uint16
N = len(channels)
slice_size = N * 2
chunks = chunks - chunks % slice_size # round to equal blocks
reader = read_files(filenames, dtype, chunks, slice_size)
data = next(reader)
if signed:
af = lambda x: x.astype(np.float32) * analog_scale
ef = lambda x: x.astype(np.float32) * electrode_scale
df = lambda x: np.array(x, dtype=np.bool_)
else:
af = lambda x: (x.astype(np.float32) - 2**15) * analog_scale
ef = lambda x: (x.astype(np.float32) - 2**15) * electrode_scale
df = lambda x: np.array(x.astype(np.int32) - 2**15, dtype=np.bool_)
analogs = [(i, ch) for i, ch in enumerate(channels) if ch.startswith('A')]
digitals = [(i, ch) for i, ch in enumerate(channels) if ch.startswith('D')]
electrodes = [(i, ch) for i, ch in enumerate(channels)
if not ch.startswith('D') and not ch.startswith('A')]
groups = (('Analog', analogs, af, np.float32),
('Digital', digitals, df, np.bool_), ('Electrodes', electrodes,
ef, np.float32))
if output is None:
output = '{}.h5'.format(splitext(filenames[0])[0])
ofile = NixIO(output, mode='ow')
blk = Block()
for group_name, channels, f, dtype in groups:
seg = Segment(name=group_name)
for slice_idx, chan_name in channels:
seg.analogsignals.append(
AnalogSignal(f(data[slice_idx::N]),
dtype=dtype,
units=uV,
sampling_rate=rate * Hz,
name=chan_name))
blk.segments.append(seg)
ofile.write_block(blk)
nix_file = ofile.nix_file
nix_groups = nix_file.blocks[0].groups
for data in reader:
for k, (group_name, channels, f, _) in enumerate(groups):
data_arrays = nix_groups[k].data_arrays
for i, (slice_idx, _) in enumerate(channels):
# nix_file._h5file.flush()
data_arrays[i].append(f(data[slice_idx::N]))
nix_file.close()
return output
