def test_block_verify(self):
# check that file verifies against itself for single block
filename = self.get_filename_path(
'Cheetah_v4.0.2/original_data/CSC14_trunc.Ncs')
data0 = np.memmap(filename,
dtype=NeuralynxRawIO._ncs_dtype,
mode='r',
offset=NlxHeader.HEADER_SIZE)
hdr0 = NlxHeader(filename)
nb0 = NcsSectionsFactory.build_for_ncs_file(data0, hdr0)
self.assertTrue(NcsSectionsFactory._verifySectionsStructure(
data0, nb0))
# check that fails against file with two blocks
filename = self.get_filename_path(
'BML_unfilledsplit/original_data/unfilledSplitRecords.Ncs')
data1 = np.memmap(filename,
dtype=NeuralynxRawIO._ncs_dtype,
mode='r',
offset=NlxHeader.HEADER_SIZE)
hdr1 = NlxHeader(filename)
nb1 = NcsSectionsFactory.build_for_ncs_file(data1, hdr1)
self.assertFalse(
NcsSectionsFactory._verifySectionsStructure(data1, nb0))
# check that two blocks verify against self
self.assertTrue(NcsSectionsFactory._verifySectionsStructure(
data1, nb1))
def scan_ncs_files(self, ncs_filenames):
"""
Given a list of ncs files, read their basic structure.
PARAMETERS:
------
ncs_filenames - list of ncs filenames to scan.
RETURNS:
------
memmaps
[ {} for seg_index in range(self._nb_segment) ][chan_uid]
seg_time_limits
SegmentTimeLimits for sections in scanned Ncs files
Files will be scanned to determine the sections of records. If file is a single
section of records, this scan is brief, otherwise it will check each record which may
take some time.
"""
# :TODO: Needs to account for gaps and start and end times potentially
# being different in different groups of channels. These groups typically
# correspond to the channels collected by a single ADC card.
if len(ncs_filenames) == 0:
return None, None
# Build dictionary of chan_uid to associated NcsSections, memmap and NlxHeaders. Only
# construct new NcsSections when it is different from that for the preceding file.
chanSectMap = dict()
for chan_uid, ncs_filename in self.ncs_filenames.items():
data = np.memmap(ncs_filename,
dtype=self._ncs_dtype,
mode='r',
offset=NlxHeader.HEADER_SIZE)
nlxHeader = NlxHeader(ncs_filename)
if not chanSectMap or (
chanSectMap
and not NcsSectionsFactory._verifySectionsStructure(
data, lastNcsSections)):
lastNcsSections = NcsSectionsFactory.build_for_ncs_file(
data, nlxHeader)
chanSectMap[chan_uid] = [lastNcsSections, nlxHeader, data]
# Construct an inverse dictionary from NcsSections to list of associated chan_uids
revSectMap = dict()
for k, v in chanSectMap.items():
revSectMap.setdefault(v[0], []).append(k)
# If there is only one NcsSections structure in the set of ncs files, there should only
# be one entry. Otherwise this is presently unsupported.
if len(revSectMap) > 1:
raise IOError(
'ncs files have {} different sections structures. Unsupported.'
.format(len(revSectMap)))
seg_time_limits = SegmentTimeLimits(nb_segment=len(
lastNcsSections.sects),
t_start=[],
t_stop=[],
length=[],
timestamp_limits=[])
memmaps = [{} for seg_index in range(seg_time_limits.nb_segment)]
# create segment with subdata block/t_start/t_stop/length for each channel
for i, fileEntry in enumerate(self.ncs_filenames.items()):
chan_uid = fileEntry[0]
data = chanSectMap[chan_uid][2]
# create a memmap for each record section of the current file
curSects = chanSectMap[chan_uid][0]
for seg_index in range(len(curSects.sects)):
curSect = curSects.sects[seg_index]
subdata = data[curSect.startRec:(curSect.endRec + 1)]
memmaps[seg_index][chan_uid] = subdata
# create segment timestamp limits based on only NcsSections structure in use
if i == 0:
numSampsLastSect = subdata[-1]['nb_valid']
ts0 = subdata[0]['timestamp']
ts1 = NcsSectionsFactory.calc_sample_time(
curSects.sampFreqUsed, subdata[-1]['timestamp'],
numSampsLastSect)
seg_time_limits.timestamp_limits.append((ts0, ts1))
t_start = ts0 / 1e6
seg_time_limits.t_start.append(t_start)
t_stop = ts1 / 1e6
seg_time_limits.t_stop.append(t_stop)
# :NOTE: This should really be the total of nb_valid in records, but this
# allows the last record of a section to be shorter, the most common case.
# Have never seen a section of records with not full records before the last.
length = (subdata.size -
1) * NcsSection._RECORD_SIZE + numSampsLastSect
seg_time_limits.length.append(length)
return memmaps, seg_time_limits