def extract_task_replay(
session_path: str, sync: dict = None, sync_map: dict = None, treplay: np.array = None
) -> Tuple[pd.DataFrame, pd.DataFrame]:
if sync is None or sync_map is None:
sync, sync_map = ephys_fpga.get_main_probe_sync(session_path, bin_exists=False)
if treplay is None:
passivePeriods_df = extract_passive_periods(session_path, sync=sync, sync_map=sync_map)
treplay = passivePeriods_df.taskReplay.values
fttl = ephys_fpga.get_sync_fronts(sync, sync_map["frame2ttl"], tmin=treplay[0])
fttl = ephys_fpga._clean_frame2ttl(fttl)
passiveGabor_df = _extract_passiveGabor_df(fttl, session_path)
bpod = ephys_fpga.get_sync_fronts(sync, sync_map["bpod"], tmin=treplay[0])
passiveValve_intervals = _extract_passiveValve_intervals(bpod)
task_version = _load_task_protocol(session_path)
audio = ephys_fpga.get_sync_fronts(sync, sync_map["audio"], tmin=treplay[0])
passiveTone_intervals, passiveNoise_intervals = _extract_passiveAudio_intervals(audio,
task_version)
passiveStims_df = np.concatenate(
[passiveValve_intervals, passiveTone_intervals, passiveNoise_intervals], axis=1
)
columns = ["valveOn", "valveOff", "toneOn", "toneOff", "noiseOn", "noiseOff"]
passiveStims_df = pd.DataFrame(passiveStims_df, columns=columns)
return (
passiveGabor_df,
passiveStims_df,
) # _ibl_passiveGabor.table.csv, _ibl_passiveStims.times_table.csv
def extract_replay_debug(
session_path: str,
sync: dict = None,
sync_map: dict = None,
treplay: np.array = None,
ax: plt.axes = None,
) -> Tuple[pd.DataFrame, pd.DataFrame]:
# Load sessions sync channels, map
if sync is None or sync_map is None:
sync, sync_map = ephys_fpga.get_main_probe_sync(session_path, bin_exists=False)
if treplay is None:
passivePeriods_df = extract_passive_periods(session_path, sync=sync, sync_map=sync_map)
treplay = passivePeriods_df.taskReplay.values
if ax is None:
f, ax = plt.subplots(1, 1)
f = ax.figure
f.suptitle("/".join(str(session_path).split("/")[-5:]))
plot_sync_channels(sync=sync, sync_map=sync_map, ax=ax)
passivePeriods_df = extract_passive_periods(session_path, sync=sync, sync_map=sync_map)
treplay = passivePeriods_df.taskReplay.values
plot_passive_periods(passivePeriods_df, ax=ax)
fttl = ephys_fpga.get_sync_fronts(sync, sync_map["frame2ttl"], tmin=treplay[0])
passiveGabor_df = _extract_passiveGabor_df(fttl, session_path)
plot_gabor_times(passiveGabor_df, ax=ax)
bpod = ephys_fpga.get_sync_fronts(sync, sync_map["bpod"], tmin=treplay[0])
passiveValve_intervals = _extract_passiveValve_intervals(bpod)
plot_valve_times(passiveValve_intervals, ax=ax)
task_version = _load_task_protocol(session_path)
audio = ephys_fpga.get_sync_fronts(sync, sync_map["audio"], tmin=treplay[0])
passiveTone_intervals, passiveNoise_intervals = _extract_passiveAudio_intervals(audio,
task_version)
plot_audio_times(passiveTone_intervals, passiveNoise_intervals, ax=ax)
passiveStims_df = np.concatenate(
[passiveValve_intervals, passiveTone_intervals, passiveNoise_intervals], axis=1
)
columns = ["valveOn", "valveOff", "toneOn", "toneOff", "noiseOn", "noiseOff"]
passiveStims_df = pd.DataFrame(passiveStims_df, columns=columns)
return (
passiveGabor_df,
passiveStims_df,
) # _ibl_passiveGabor.table.csv, _ibl_passiveStims.table.csv
def extract_rfmapping(
session_path: str, sync: dict = None, sync_map: dict = None, trfm: np.array = None
) -> Tuple[np.array, np.array]:
meta = _load_passive_stim_meta()
mkey = (
"VISUAL_STIM_"
+ {v: k for k, v in meta["VISUAL_STIMULI"].items()}["receptive_field_mapping"]
)
if sync is None or sync_map is None:
sync, sync_map = ephys_fpga.get_main_probe_sync(session_path, bin_exists=False)
if trfm is None:
passivePeriods_df = extract_passive_periods(session_path, sync=sync, sync_map=sync_map)
trfm = passivePeriods_df.RFM.values
fttl = ephys_fpga.get_sync_fronts(sync, sync_map["frame2ttl"], tmin=trfm[0], tmax=trfm[1])
fttl = ephys_fpga._clean_frame2ttl(fttl)
RF_file = Path().joinpath(session_path, "raw_passive_data", "_iblrig_RFMapStim.raw.bin")
passiveRFM_frames, RF_ttl_trace = _reshape_RF(RF_file=RF_file, meta_stim=meta[mkey])
rf_id_up, rf_id_dw, RF_n_ttl_expected = _get_id_raisefall_from_analogttl(RF_ttl_trace)
meta[mkey]["ttl_num"] = RF_n_ttl_expected
rf_times_on_idx = np.where(np.diff(fttl["times"]) < 1)[0]
rf_times_off_idx = rf_times_on_idx + 1
RF_times = fttl["times"][np.sort(np.concatenate([rf_times_on_idx, rf_times_off_idx]))]
RF_times_1 = RF_times[0::2]
# Interpolate times for RF before outputting dataset
passiveRFM_times = _interpolate_rf_mapping_stimulus(
idxs_up=rf_id_up,
idxs_dn=rf_id_dw,
times=RF_times_1,
Xq=np.arange(passiveRFM_frames.shape[0]),
t_bin=1 / FRAME_FS,
)
return passiveRFM_times # _ibl_passiveRFM.times.npy
def _get_passive_spacers(session_path, sync=None, sync_map=None):
"""
load and get spacer information, do corr to find spacer timestamps
returns t_passive_starts, t_starts, t_ends
"""
if sync is None or sync_map is None:
sync, sync_map = ephys_fpga.get_main_probe_sync(session_path, bin_exists=False)
meta = _load_passive_stim_meta()
# t_end_ephys = passive.ephysCW_end(session_path=session_path)
fttl = ephys_fpga.get_sync_fronts(sync, sync_map["frame2ttl"], tmin=None)
fttl = ephys_fpga._clean_frame2ttl(fttl, display=False)
spacer_template = (
np.array(meta["VISUAL_STIM_0"]["ttl_frame_nums"], dtype=np.float32) / FRAME_FS
)
jitter = 3 / FRAME_FS # allow for 3 screen refresh as jitter
t_quiet = meta["VISUAL_STIM_0"]["delay_around"]
spacer_times, _ = _get_spacer_times(
spacer_template=spacer_template, jitter=jitter, ttl_signal=fttl["times"], t_quiet=t_quiet
)
# Check correct number of spacers found
n_exp_spacer = np.sum(np.array(meta["STIM_ORDER"]) == 0) # Hardcoded 0 for spacer
if n_exp_spacer != np.size(spacer_times) / 2:
raise ValueError(
f"The number of expected spacer ({n_exp_spacer}) "
f"is different than the one found on the raw "
f"trace ({np.size(spacer_times)/2})"
)
spacer_times = np.r_[spacer_times.flatten(), sync["times"][-1]]
return spacer_times[0], spacer_times[1::2], spacer_times[2::2]
def extract_camera_sync(sync, chmap=None):
"""
Extract camera timestamps from the sync matrix
:param sync: dictionary 'times', 'polarities' of fronts detected on sync trace
:param chmap: dictionary containing channel indices. Default to constant.
:return: dictionary containing camera timestamps
"""
assert (chmap)
sr = get_sync_fronts(sync, chmap['right_camera'])
sl = get_sync_fronts(sync, chmap['left_camera'])
sb = get_sync_fronts(sync, chmap['body_camera'])
return {
'right': sr.times[::2],
'left': sl.times[::2],
'body': sb.times[::2]
}
def plot_sync_channels(sync, sync_map, ax=None):
# Plot all sync pulses
if ax is None:
f, ax = plt.subplots(1, 1)
for i, device in enumerate(["frame2ttl", "audio", "bpod"]):
sy = ephys_fpga.get_sync_fronts(
sync, sync_map[device]) # , tmin=t_start_passive)
squares(sy["times"],
sy["polarities"],
yrange=[0.1 + i, 0.9 + i],
color="k",
ax=ax)
def compare_camera_timestamps_between_two_probes(sync_right, sync_left):
"""
sync_left has no square signal
"""
# using the probe 3a channel map:
'''
0: Arduino synchronization signal
2: 150 Hz camera
3: 30 Hz camera
4: 60 Hz camera
7: Bpod
11: Frame2TTL
12 & 13: Rotary Encoder
15: Audio
'''
for cam_code in [2, 3, 4]:
cam_times_left = ephys_fpga.get_sync_fronts(sync_left,
cam_code)['times']
cam_times_right = ephys_fpga.get_sync_fronts(sync_right,
cam_code)['times']
assert len(cam_times_left) == len(
cam_times_right), "# time stamps don't match between probes"
D = abs(np.array(cam_times_left) - np.array(cam_times_right))
assert max(D) - min(D) < 0.005, 'cam_code %s; Temporal jitter \
between probes is large!!' % cam_code
print('Sync check for cam %s time stamps \
of left and right probe passed' % cam_code)
print('mean = ', np.round(np.mean(D), 6), 'sec ; std = ',
np.round(np.std(D), 6), 'sec ; max - min = ',
np.round(max(D) - min(D), 6), 'sec')
def compare_bpod_json_with_fpga(sync_test_folder, sync, show_plots=SHOW_PLOTS):
'''
sr, sync=get_ephys_data(sync_test_folder)
'''
# get the bpod signal from the jasonable file
import json
with open(sync_test_folder + '/bpod/_iblrig_taskData.raw.jsonable') as fid:
out = json.load(fid)
ups = out['Events timestamps']['BNC1High']
assert len(ups) == 500, 'not all pulses detected in bpod!'
# get the fpga signal from the sync object
s3 = ephys_fpga.get_sync_fronts(sync, 0)['times'][::2]
assert len(s3) == 500, 'not all fronts detected in fpga signal!'
IntervalDurationDifferences = np.diff(np.array(s3)) - np.diff(
np.array(ups))
R = max(abs(IntervalDurationDifferences))
print('maximal interval duration difference, fpga - bpod, [sec]:', R)
if show_plots:
plt.figure('wavefronts')
plt.plot(s3['times'], s3['polarities'], label='fpga')
plt.plot(ups,
np.ones(len(ups)),
linestyle='',
marker='o',
label='pbod on')
plt.legend()
plt.show()
plt.figure('histogram of wavefront differences, bpod and fpga')
plt.hist(np.array(s3) - np.array(ups))
plt.xlabel('error between fpga fronts and ephys fronts in sec')
plt.show()
def _extract(self,
sync=None,
chmap=None,
video_path=None,
display=False,
extrapolate_missing=True):
"""
The raw timestamps are taken from the FPGA. These are the times of the camera's frame TTLs.
If the pin state file exists, these timestamps are aligned to the video frames using the
audio TTLs. Frames missing from the embedded frame count are removed from the timestamps
array.
If the pin state file does not exist, the left and right camera timestamps may be aligned
using the wheel data.
:param sync: dictionary 'times', 'polarities' of fronts detected on sync trace.
:param chmap: dictionary containing channel indices. Default to constant.
:param video_path: an optional path for fetching the number of frames. If None,
the video is loaded from the session path. If an int is provided this is taken to be
the total number of frames.
:param display: if True, the audio and GPIO fronts are plotted.
:param extrapolate_missing: if True, any missing timestamps at the beginning and end of
the session are extrapolated based on the median frame rate, otherwise they will be NaNs.
:return: a numpy array of camera timestamps
"""
fpga_times = extract_camera_sync(sync=sync, chmap=chmap)
count, (*_,
gpio) = raw.load_embedded_frame_data(self.session_path,
self.label)
raw_ts = fpga_times[self.label]
if video_path is None:
filename = f'_iblrig_{self.label}Camera.raw.mp4'
video_path = self.session_path.joinpath('raw_video_data', filename)
# Permit the video path to be the length for development and debugging purposes
length = (video_path if isinstance(video_path, int) else
get_video_length(video_path))
_logger.debug(f'Number of video frames = {length}')
if gpio is not None and gpio['indices'].size > 1:
_logger.info('Aligning to audio TTLs')
# Extract audio TTLs
audio = get_sync_fronts(sync, chmap['audio'])
_, ts = raw.load_camera_ssv_times(self.session_path, self.label)
try:
"""
NB: Some of the audio TTLs occur very close together, and are therefore not
reflected in the pin state. This function removes those. Also converts frame
times to FPGA time.
"""
gpio, audio, ts = groom_pin_state(gpio,
audio,
ts,
display=display)
"""
The length of the count and pin state are regularly longer than the length of
the video file. Here we assert that the video is either shorter or the same
length as the arrays, and we make an assumption that the missing frames are
right at the end of the video. We therefore simply shorten the arrays to match
the length of the video.
"""
if count.size > length:
count = count[:length]
else:
assert length == count.size, 'fewer counts than frames'
raw_ts = fpga_times[self.label]
assert raw_ts.shape[0] > 0, 'no timestamps found in channel indicated for ' \
f'{self.label} camera'
return align_with_audio(
raw_ts,
audio,
gpio,
count,
display=display,
extrapolate_missing=extrapolate_missing)
except AssertionError as ex:
_logger.critical('Failed to extract using audio: %s', ex)
# If you reach here extracting using audio TTLs was not possible
_logger.warning('Alignment by wheel data not yet implemented')
if length < raw_ts.size:
df = raw_ts.size - length
_logger.info(f'Discarding first {df} pulses')
raw_ts = raw_ts[df:]
return raw_ts
def load_data(self,
download_data: bool = None,
extract_times: bool = False,
load_video: bool = True) -> None:
"""Extract the data from raw data files
Extracts all the required task data from the raw data files.
Data keys:
- count (int array): the sequential frame number (n, n+1, n+2...)
- pin_state (): the camera GPIO pin; records the audio TTLs; should be one per frame
- audio (float array): timestamps of audio TTL fronts
- fpga_times (float array): timestamps of camera TTLs recorded by FPGA
- timestamps (float array): extracted video timestamps (the camera.times ALF)
- bonsai_times (datetime array): system timestamps of video PC; should be one per frame
- camera_times (float array): camera frame timestamps extracted from frame headers
- wheel (Bunch): rotary encoder timestamps, position and period used for wheel motion
- video (Bunch): video meta data, including dimensions and FPS
- frame_samples (h x w x n array): array of evenly sampled frames (1 colour channel)
:param download_data: if True, any missing raw data is downloaded via ONE.
Missing data will raise an AssertionError
:param extract_times: if True, the camera.times are re-extracted from the raw data
:param load_video: if True, calls the load_video_data method
"""
assert self.session_path, 'no session path set'
if download_data is not None:
self.download_data = download_data
if self.download_data and self.eid and self.one and not self.one.offline:
self.ensure_required_data()
_log.info('Gathering data for QC')
# Get frame count and pin state
self.data['count'], self.data['pin_state'] = \
raw.load_embedded_frame_data(self.session_path, self.label, raw=True)
# Load the audio and raw FPGA times
if self.type == 'ephys':
sync, chmap = ephys_fpga.get_main_probe_sync(self.session_path)
audio_ttls = ephys_fpga.get_sync_fronts(sync, chmap['audio'])
self.data['audio'] = audio_ttls['times'] # Get rises
# Load raw FPGA times
cam_ts = extract_camera_sync(sync, chmap)
self.data['fpga_times'] = cam_ts[self.label]
else:
bpod_data = raw.load_data(self.session_path)
_, audio_ttls = raw.load_bpod_fronts(self.session_path, bpod_data)
self.data['audio'] = audio_ttls['times']
# Load extracted frame times
alf_path = self.session_path / 'alf'
try:
assert not extract_times
self.data['timestamps'] = alfio.load_object(
alf_path, f'{self.label}Camera', short_keys=True)['times']
except AssertionError: # Re-extract
kwargs = dict(video_path=self.video_path, labels=self.label)
if self.type == 'ephys':
kwargs = {**kwargs, 'sync': sync, 'chmap': chmap} # noqa
outputs, _ = extract_all(self.session_path,
self.type,
save=False,
**kwargs)
self.data['timestamps'] = outputs[
f'{self.label}_camera_timestamps']
except ALFObjectNotFound:
_log.warning('no camera.times ALF found for session')
# Get audio and wheel data
wheel_keys = ('timestamps', 'position')
try:
self.data['wheel'] = alfio.load_object(alf_path,
'wheel',
short_keys=True)
except ALFObjectNotFound:
# Extract from raw data
if self.type == 'ephys':
wheel_data = ephys_fpga.extract_wheel_sync(sync, chmap)
else:
wheel_data = training_wheel.get_wheel_position(
self.session_path)
self.data['wheel'] = Bunch(zip(wheel_keys, wheel_data))
# Find short period of wheel motion for motion correlation.
if data_for_keys(
wheel_keys,
self.data['wheel']) and self.data['timestamps'] is not None:
self.data['wheel'].period = self.get_active_wheel_period(
self.data['wheel'])
# Load Bonsai frame timestamps
try:
ssv_times = raw.load_camera_ssv_times(self.session_path,
self.label)
self.data['bonsai_times'], self.data['camera_times'] = ssv_times
except AssertionError:
_log.warning('No Bonsai video timestamps file found')
# Gather information from video file
if load_video:
_log.info('Inspecting video file...')
self.load_video_data()
def validate_ttl_test(ses_path, display=False):
"""
For a mock session on the Ephys Choice world task, check the sync channels for all
device properly connected and perform a synchronization if dual probes to check that
all channels are recorded properly
:param ses_path: session path
:param display: show the probe synchronization plot if several probes
:return: True if tests pass, errors otherwise
"""
def _single_test(assertion, str_ok, str_ko):
if assertion:
_logger.info(str_ok)
return True
else:
_logger.error(str_ko)
return False
EXPECTED_RATES_HZ = {'left_camera': 60, 'right_camera': 150, 'body_camera': 30}
SYNC_RATE_HZ = 1
MIN_TRIALS_NB = 6
ok = True
ses_path = Path(ses_path)
if not ses_path.exists():
return False
# get the synchronization fronts (from the raw binary if necessary)
ephys_fpga.extract_sync(session_path=ses_path, overwrite=False)
rawsync, sync_map = ephys_fpga.get_main_probe_sync(ses_path)
last_time = rawsync['times'][-1]
# get upgoing fronts for each
sync = Bunch({})
for k in sync_map:
fronts = ephys_fpga.get_sync_fronts(rawsync, sync_map[k])
sync[k] = fronts['times'][fronts['polarities'] == 1]
wheel = ephys_fpga.extract_wheel_sync(rawsync, chmap=sync_map)
frame_rates = {'right_camera': np.round(1 / np.median(np.diff(sync.right_camera))),
'left_camera': np.round(1 / np.median(np.diff(sync.left_camera))),
'body_camera': np.round(1 / np.median(np.diff(sync.body_camera)))}
# check the camera frame rates
for lab in frame_rates:
expect = EXPECTED_RATES_HZ[lab]
ok &= _single_test(assertion=abs((1 - frame_rates[lab] / expect)) < 0.1,
str_ok=f'PASS: {lab} frame rate: {frame_rates[lab]} = {expect} Hz',
str_ko=f'FAILED: {lab} frame rate: {frame_rates[lab]} != {expect} Hz')
# check that the wheel has a minimum rate of activity on both channels
re_test = abs(1 - sync.rotary_encoder_1.size / sync.rotary_encoder_0.size) < 0.1
re_test &= len(wheel[1]) / last_time > 5
ok &= _single_test(assertion=re_test,
str_ok="PASS: Rotary encoder", str_ko="FAILED: Rotary encoder")
# check that the frame 2 ttls has a minimum rate of activity
ok &= _single_test(assertion=len(sync.frame2ttl) / last_time > 0.2,
str_ok="PASS: Frame2TTL", str_ko="FAILED: Frame2TTL")
# the audio has to have at least one event per trial
ok &= _single_test(assertion=len(sync.bpod) > len(sync.audio) > MIN_TRIALS_NB,
str_ok="PASS: audio", str_ko="FAILED: audio")
# the bpod has to have at least twice the amount of min trial pulses
ok &= _single_test(assertion=len(sync.bpod) > MIN_TRIALS_NB * 2,
str_ok="PASS: Bpod", str_ko="FAILED: Bpod")
try:
# note: tried to depend as little as possible on the extraction code but for the valve...
behaviour = ephys_fpga.extract_behaviour_sync(rawsync, chmap=sync_map)
res = behaviour.valveOpen_times.size > 1
except AssertionError:
res = False
# check that the reward valve is actionned at least once
ok &= _single_test(assertion=res,
str_ok="PASS: Valve open", str_ko="FAILED: Valve open not detected")
_logger.info('ALL CHECKS PASSED !')
# the imec sync is for 3B Probes only
if sync.get('imec_sync') is not None:
ok &= _single_test(assertion=np.all(1 - SYNC_RATE_HZ * np.diff(sync.imec_sync) < 0.1),
str_ok="PASS: imec sync", str_ko="FAILED: imec sync")
# second step is to test that we can make the sync. Assertions are whithin the synch code
if sync.get('imec_sync') is not None:
sync_result, _ = sync_probes.version3B(ses_path, display=display)
else:
sync_result, _ = sync_probes.version3A(ses_path, display=display)
ok &= _single_test(assertion=sync_result, str_ok="PASS: synchronisation",
str_ko="FAILED: probe synchronizations threshold exceeded")
if not ok:
raise ValueError('FAILED TTL test')
return ok
def version3A(ses_path, display=True, type='smooth', tol=2.1):
"""
From a session path with _spikeglx_sync arrays extracted, locate ephys files for 3A and
outputs one sync.timestamps.probeN.npy file per acquired probe. By convention the reference
probe is the one with the most synchronisation pulses.
Assumes the _spikeglx_sync datasets are already extracted from binary data
:param ses_path:
:param type: linear, exact or smooth
:return: bool True on a a successful sync
"""
ephys_files = spikeglx.glob_ephys_files(ses_path,
ext='meta',
bin_exists=False)
nprobes = len(ephys_files)
if nprobes == 1:
timestamps = np.array([[0., 0.], [1., 1.]])
sr = _get_sr(ephys_files[0])
out_files = _save_timestamps_npy(ephys_files[0], timestamps, sr)
return True, out_files
def get_sync_fronts(auxiliary_name):
d = Bunch({'times': [], 'nsync': np.zeros(nprobes, )})
# auxiliary_name: frame2ttl or right_camera
for ind, ephys_file in enumerate(ephys_files):
sync = alfio.load_object(ephys_file.ap.parent,
'sync',
namespace='spikeglx',
short_keys=True)
sync_map = get_ibl_sync_map(ephys_file, '3A')
# exits if sync label not found for current probe
if auxiliary_name not in sync_map:
return
isync = np.in1d(sync['channels'],
np.array([sync_map[auxiliary_name]]))
# only returns syncs if we get fronts for all probes
if np.all(~isync):
return
d.nsync[ind] = len(sync.channels)
d['times'].append(sync['times'][isync])
return d
d = get_sync_fronts('frame2ttl')
if not d:
_logger.warning(
'Ephys sync: frame2ttl not detected on both probes, using camera sync'
)
d = get_sync_fronts('right_camera')
if not min([t[0] for t in d['times']]) > 0.2:
raise (
ValueError('Cameras started before ephys, no sync possible'))
# chop off to the lowest number of sync points
nsyncs = [t.size for t in d['times']]
if len(set(nsyncs)) > 1:
_logger.warning(
"Probes don't have the same number of synchronizations pulses")
d['times'] = np.r_[[t[:min(nsyncs)] for t in d['times']]].transpose()
# the reference probe is the one with the most sync pulses detected
iref = np.argmax(d.nsync)
# islave = np.setdiff1d(np.arange(nprobes), iref)
# get the sampling rate from the reference probe using metadata file
sr = _get_sr(ephys_files[iref])
qc_all = True
# output timestamps files as per ALF convention
for ind, ephys_file in enumerate(ephys_files):
if ind == iref:
timestamps = np.array([[0., 0.], [1., 1.]])
else:
timestamps, qc = sync_probe_front_times(d.times[:, ind],
d.times[:, iref],
sr,
display=display,
type=type,
tol=tol)
qc_all &= qc
out_files = _save_timestamps_npy(ephys_file, timestamps, sr)
return qc_all, out_files
def version3B(ses_path, display=True, type=None, tol=2.5):
"""
From a session path with _spikeglx_sync arrays extraccted, locate ephys files for 3A and
outputs one sync.timestamps.probeN.npy file per acquired probe. By convention the reference
probe is the one with the most synchronisation pulses.
Assumes the _spikeglx_sync datasets are already extracted from binary data
:param ses_path:
:param type: linear, exact or smooth
:return: None
"""
DEFAULT_TYPE = 'smooth'
ephys_files = spikeglx.glob_ephys_files(ses_path,
ext='meta',
bin_exists=False)
for ef in ephys_files:
ef['sync'] = alfio.load_object(ef.path,
'sync',
namespace='spikeglx',
short_keys=True)
ef['sync_map'] = get_ibl_sync_map(ef, '3B')
nidq_file = [ef for ef in ephys_files if ef.get('nidq')]
ephys_files = [ef for ef in ephys_files if not ef.get('nidq')]
# should have at least 2 probes and only one nidq
assert (len(nidq_file) == 1)
nidq_file = nidq_file[0]
sync_nidq = get_sync_fronts(nidq_file.sync,
nidq_file.sync_map['imec_sync'])
qc_all = True
out_files = []
for ef in ephys_files:
sync_probe = get_sync_fronts(ef.sync, ef.sync_map['imec_sync'])
sr = _get_sr(ef)
try:
# we say that the number of pulses should be within 10 %
assert (np.isclose(sync_nidq.times.size,
sync_probe.times.size,
rtol=0.1))
except AssertionError:
raise Neuropixel3BSyncFrontsNonMatching(f"{ses_path}")
# Find the indexes in case the sizes don't match
if sync_nidq.times.size != sync_probe.times.size:
_logger.warning(
f'Sync mismatch by {np.abs(sync_nidq.times.size - sync_probe.times.size)} '
f'NIDQ sync times: {sync_nidq.times.size}, Probe sync times {sync_probe.times.size}'
)
sync_idx = np.min([sync_nidq.times.size, sync_probe.times.size])
# if the qc of the diff finds anomalies, do not attempt to smooth the interp function
qcdiff = _check_diff_3b(sync_probe)
if not qcdiff:
qc_all = False
type_probe = type or 'exact'
else:
type_probe = type or DEFAULT_TYPE
timestamps, qc = sync_probe_front_times(sync_probe.times[:sync_idx],
sync_nidq.times[:sync_idx],
sr,
display=display,
type=type_probe,
tol=tol)
qc_all &= qc
out_files.extend(_save_timestamps_npy(ef, timestamps, sr))
return qc_all, out_files
def evaluate_camera_sync(d, sync, show_plots=SHOW_PLOTS):
# d=get_video_stamps_and_brightness(sync_test_folder)
# sr, sync, rawdata, rawsync=get_ephys_data(sync_test_folder)
# using the probe 3a channel map:
'''
0: Arduino synchronization signal
2: 150 Hz camera
3: 30 Hz camera
4: 60 Hz camera
7: Bpod
11: Frame2TTL
12 & 13: Rotary Encoder
15: Audio
'''
y = {
'_iblrig_bodyCamera.raw.avi': 3,
'_iblrig_rightCamera.raw.avi': 4,
'_iblrig_leftCamera.raw.avi': 2
}
s3 = ephys_fpga.get_sync_fronts(sync, 0) # get arduino sync signal
for vid in d:
# threshold brightness time-series of the camera to have it in {-1,1}
r3 = [1 if x > np.mean(d[vid][0]) else -1 for x in d[vid][0]]
# fpga cam time stamps
cam_times = ephys_fpga.get_sync_fronts(sync, y[vid])['times']
# assuming at the end the frames are dropped
drops = len(cam_times) - len(r3) * 2
# check if an extremely high number of frames is dropped at the end
assert len(cam_times) >= len(r3), 'FPGA should be on before camera!'
assert drops < 500, '%s frames dropped for %s!!!' % (drops, vid)
# get fronts of video brightness square signal
diffr3 = np.diff(r3) # get signal jumps via differentiation
fronts_brightness = []
for i in range(len(diffr3)):
if diffr3[i] != 0:
fronts_brightness.append(cam_times[:-drops][0::2][i])
# check if all 500 square pulses are detected
assert len(fronts_brightness) == len(
s3['times']), 'Not all square signals detected in %s!' % vid
# temporal difference between fpga and brightness ups
D = [fronts_brightness - s3['times']][0][::2] # only get up fronts
assert len(
D) == 500, \
'not all 500 pulses were detected \
by fpga and brightness in %s!' % vid
print(' %s, Wave fronts temp. diff, in sec: \
mean = %s, std = %s, max = %s' %
(vid, np.round(np.mean(abs(D)), 4), np.round(np.std(
abs(D)), 4), np.round(max(abs(D)), 4)))
# check if temporal jitter between fpga and brightness wavefronts is
# below 100 ms
assert max(
abs(D)) < 0.200, \
'Jitter between fpga and brightness fronts is large!!'
if show_plots:
plt.figure('wavefronts, ' + vid)
ibllib.plots.squares(s3['times'],
s3['polarities'],
label='fpga square signal',
marker='o')
plt.plot(cam_times[:-drops][0::2],
r3,
alpha=0.5,
label='thresholded video brightness',
linewidth=2,
marker='x')
plt.legend()
plt.title('wavefronts for fpga and brightness of %s' % vid)
plt.show()
plt.figure('histogram of front differences, %s' % vid)
plt.title('histogram of temporal errors of fronts')
plt.hist(D)
plt.xlabel('error between fpga fronts and ephys fronts in sec')
plt.show()
def event_extraction_and_comparison(sr, sync):
# it took 8 min to run that for 6 min of data, all 300 ish channels
# silent channels for Guido's set:
# [36,75,112,151,188,227,264,303,317,340,379,384]
# sr,sync=get_ephys_data(sync_test_folder)
"""
this function first finds the times of square signal fronts in ephys and
compares them to corresponding ones in the sync signal.
Iteratively for small data chunks
"""
_logger.info('starting event_extraction_and_comparison')
period_duration = 30000 # in observations, 30 kHz
BATCH_SIZE_SAMPLES = period_duration # in observations, 30 kHz
# if the data is needed as well, loop over the file
# raw data contains raw ephys traces, while raw_sync contains the 16 sync
# traces
rawdata, _ = sr.read_samples(0, BATCH_SIZE_SAMPLES)
_, chans = rawdata.shape
chan_fronts = {}
sync_up_fronts = ephys_fpga.get_sync_fronts(sync, 0)['times'][0::2]
sync_up_fronts = np.array(sync_up_fronts) * sr.fs
assert len(sync_up_fronts) == 500, 'There are not all sync pulses'
for j in range(chans):
chan_fronts[j] = {}
chan_fronts[j]['ephys up fronts'] = []
k = 0
# assure there is exactly one pulse per cut segment
for pulse in range(500): # there are 500 square pulses
first = int(sync_up_fronts[pulse] - period_duration / 2)
last = int(first + period_duration / 2)
if k % 100 == 0:
print('segment %s of %s' % (k, 500))
k += 1
rawdata, rawsync = sr.read_samples(first, last)
# get fronts for only one valid ephys channel
obs, chans = rawdata.shape
i = 0 # assume channel 0 is valid (to be generalized maybe)
Mean = np.median(rawdata.T[i])
Std = np.std(rawdata.T[i])
ups = np.invert(rawdata.T[i] > Mean + 2 * Std)
up_fronts = []
# Activity front at least 10 samples long (empirical)
up_fronts.append(first_occ_index(ups, 1) + first)
chan_fronts[i]['ephys up fronts'].append(up_fronts)
return chan_fronts, sync_up_fronts
