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 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, bin_exists=False) for ef in ephys_files: ef['sync'] = alf.io.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: assert (sync_nidq.times.size == sync_probe.times.size) except AssertionError: raise Neuropixel3BSyncFrontsNonMatching(f"{ses_path}") # 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_nidq.times, 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 _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) 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, output_path=None, save=False, chmap=None): """ Extract camera timestamps from the sync matrix :param sync: dictionary 'times', 'polarities' of fronts detected on sync trace :param output_path: where to save the data :param save: True/False :param chmap: dictionary containing channel indices. Default to constant. :return: dictionary containing camera timestamps """ if chmap == None: chmap = { 'trial_start': 0, 'sample': 1, 'delay': 2, 'choice': 3, 'outcome': 4, 'opto': 5, 'right_lever': 6, 'imec': 7, 'nosepoke': 22, 'reward_pump': 21, 'reward_port': 23, 'camera': 16 } output_path = Path(output_path) if not output_path.exists(): output_path.mkdir() s = _get_sync_fronts(sync, chmap['camera']) np.save(output_path / '_Camera.times.npy', s.times[::2])
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!' D = np.array(s3) - np.array(ups) offset_on = np.mean(D) jitter_on = np.std(D) ipi_bpod = np.abs(np.diff(ups)) # inter pulse interval = ipi ipi_fpga = np.abs(np.diff(s3)) print('maximal bpod jitter in sec: ', np.round(np.max(ipi_bpod) - np.min(ipi_bpod), 6)) print('maximal fpga jitter in sec: ', np.round(np.max(ipi_fpga) - np.min(ipi_fpga), 6)) print('maximal bpod-fpga in sec: ', np.round(np.max(np.abs(D)) - np.min(np.abs(D)), 6)) print('fpga and bpod signal offset in sec: ', np.round(offset_on, 6)) print('std of fpga and bpod difference in sec: ', np.round(jitter_on, 6)) 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_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 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]) 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) audio = ephys_fpga._get_sync_fronts(sync, sync_map["audio"], tmin=treplay[0]) passiveTone_intervals, passiveNoise_intervals = _extract_passiveAudio_intervals( audio) 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 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 version3B(ses_path, display=True, linear=False, 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: :return: None """ ephys_files = spikeglx.glob_ephys_files(ses_path) for ef in ephys_files: ef['sync'] = alf.io.load_object(ef.path, '_spikeglx_sync', 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')] nprobes = len(ephys_files) # should have at least 2 probes and only one nidq if nprobes <= 1: return True 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 for ef in ephys_files: sync_probe = _get_sync_fronts(ef.sync, ef.sync_map['imec_sync']) sr = _get_sr(ef) assert (sync_nidq.times.size == sync_probe.times.size) timestamps, qc = sync_probe_front_times(sync_probe.times, sync_nidq.times, sr, display=display, linear=linear, tol=tol) qc_all &= qc _save_timestamps_npy(ef, timestamps) return qc_all
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]) 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 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 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 rawsync, sync_map = 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 = fpga._get_sync_fronts(rawsync, sync_map[k]) sync[k] = fronts['times'][fronts['polarities'] == 1] wheel = fpga.extract_wheel_sync(rawsync, chmap=sync_map, save=False) 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['re_pos']) / 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 = fpga.extract_behaviour_sync(rawsync, save=False, chmap=sync_map) res = behaviour.valve_open.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 _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) 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) """ 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 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 count.size > length: count = count[:length] else: assert length == count.size, 'fewer counts than frames' raw_ts = fpga_times[self.label] timestamps = align_with_audio( raw_ts, audio, gpio, count, display=display, extrapolate_missing=extrapolate_missing) else: _logger.warning('Alignment by wheel data not yet implemented') timestamps = fpga_times[self.label] return timestamps
def extract_behaviour_sync(sync, output_path=None, save=False, chmap=None): """ Extract wheel positions and times from sync fronts dictionary :param sync: dictionary 'times', 'polarities' of fronts detected on sync trace for all 16 chans :param output_path: where to save the data :param save: True/False :param chmap: dictionary containing channel index. Default to constant. :return: trials dictionary """ if chmap == None: chmap = { 'trial_start': 0, 'sample': 1, 'delay': 2, 'choice': 3, 'outcome': 4, 'opto': 5, 'right_lever': 6, 'imec': 7, 'nosepoke': 22, 'reward_pump': 21, 'reward_port': 23, 'camera': 16 } # Get fronts trial = _get_sync_fronts(sync, chmap['trial_start']) sample = _get_sync_fronts(sync, chmap['sample']) delay = _get_sync_fronts(sync, chmap['delay']) choice = _get_sync_fronts(sync, chmap['choice']) outcome = _get_sync_fronts(sync, chmap['outcome']) opto = _get_sync_fronts(sync, chmap['opto']) right_lever = _get_sync_fronts(sync, chmap['right_lever']) nosepoke = _get_sync_fronts(sync, chmap['nosepoke']) reward_pump = _get_sync_fronts(sync, chmap['reward_pump']) reward_port = _get_sync_fronts(sync, chmap['reward_port']) # Fix for unfinished trials if np.count_nonzero(trial['times']) % 2 != 0: print('Warning: Unfinished trial, cutting last trial') new_end = trial['times'][-2] trial = cut_odd_events(new_end, trial) sample = cut_odd_events(new_end, sample) delay = cut_odd_events(new_end, delay) choice = cut_odd_events(new_end, choice) outcome = cut_odd_events(new_end, outcome) opto = cut_odd_events(new_end, opto) right_lever = cut_odd_events(new_end, right_lever) nosepoke = cut_odd_events(new_end, nosepoke) reward_pump = cut_odd_events(new_end, reward_pump) reward_port = cut_odd_events(new_end, reward_port) #Assertion QC assert np.count_nonzero( trial['times']) % 2 == 0, 'ERROR: Uneven trial fronts' assert np.count_nonzero( trial['times']) % 2 == 0, 'ERROR: Uneven trial fronts' # Divide by on and off trial_on = trial[ 'times'][:: 2] # {'times' : trial['times'][::2], 'polarities' : trial['polarities'][::2]} trial_off = trial['times'][1::2] sample_on = sample['times'][::2] sample_off = sample['times'][1::2] delay_on = delay['times'][::2] delay_off = delay['times'][1::2] choice_on = choice['times'][::2] choice_off = choice['times'][1::2] outcome_on = outcome['times'][::2] outcome_off = outcome['times'][1::2] opto_on = opto['times'][::2] opto_off = opto['times'][1::2] right_lever_on = right_lever['times'][::2] right_lever_off = right_lever['times'][1::2] nosepoke_on = nosepoke['times'][::2] nosepoke_off = nosepoke['times'][1::2] reward_pump_on = reward_pump['times'][::2] reward_pump_off = reward_pump['times'][1::2] # Calculate some trial variables trial_trial_on = np.empty(len(trial_on)) trial_trial_off = np.empty(len(trial_on)) trial_opto_trial = np.empty(len(trial_on)) trial_sample_on = np.empty(len(trial_on)) trial_sample_off = np.empty(len(trial_on)) trial_delay_on = np.empty(len(trial_on)) trial_delay_off = np.empty(len(trial_on)) trial_choice_on = np.empty(len(trial_on)) trial_choice_off = np.empty(len(trial_on)) trial_right_lever_on = np.empty(len(trial_on)) trial_right_lever_off = np.empty(len(trial_on)) trial_reward_pump_on = np.empty(len(trial_on)) trial_reward_pump_off = np.empty(len(trial_on)) trial_completed = np.empty(len(trial_on)) trial_correct = np.empty(len(trial_on)) trial_outcome_first = np.empty(len(trial_on)) trial_outcome_last = np.empty(len(trial_on)) trial_nosepoke_first = np.empty(len(trial_on)) trial_nosepoke_last = np.empty(len(trial_on)) trial_opto_first = np.empty(len(trial_on)) trial_opto_last = np.empty(len(trial_on)) trial_completed[:] = np.nan trial_correct[:] = np.nan trial_outcome_first[:] = np.nan trial_outcome_last[:] = np.nan trial_nosepoke_first[:] = np.nan trial_nosepoke_last[:] = np.nan trial_opto_first[:] = np.nan trial_opto_last[:] = np.nan trial_trial_on[:] = np.nan trial_trial_side = ['' for x in range(len(trial_on))] trial_opto_event = ['' for x in range(len(trial_on))] trial_opto_trial[:] = np.nan trial_trial_off[:] = np.nan trial_sample_on[:] = np.nan trial_sample_off[:] = np.nan trial_delay_on[:] = np.nan trial_delay_off[:] = np.nan trial_choice_on[:] = np.nan trial_choice_off[:] = np.nan trial_right_lever_on[:] = np.nan trial_right_lever_off[:] = np.nan trial_reward_pump_on[:] = np.nan trial_reward_pump_off[:] = np.nan #Empty matrix for variables with variable length per trial trial_outcome_on = [] trial_outcome_off = [] trial_opto_on = [] trial_opto_off = [] trial_nosepoke_on = [] trial_nosepoke_off = [] # Fill trial vectors trial_trial_on = trial_on trial_trial_off = trial_off #assert len(trial_on) == len(trial_off) == len(sample_on) == len(sample_off) \ # , 'ERROR: Samples and trials dont match!' # Fill in trial vectors that require computation, giving 0.001 leeway for # some variables for t in range(len(trial_on)): #Variables that can only have one value per trial trial_sample_on[t] = sample_on[np.logical_and( sample_on >= trial_on[t], sample_on <= trial_off[t])] if any( np.logical_and(sample_on >= trial_on[t], sample_on <= trial_off[t])) else np.nan trial_sample_off[t] = sample_off[np.logical_and( sample_off >= trial_on[t], sample_off <= trial_off[t])] if any( np.logical_and(sample_off >= trial_on[t], sample_off <= trial_off[t])) else np.nan trial_delay_on[t] = delay_on[np.logical_and( delay_on >= trial_on[t], delay_on <= trial_off[t])] if any( np.logical_and(delay_on >= trial_on[t], delay_on <= trial_off[t])) else np.nan trial_delay_off[t] = delay_off[np.logical_and( delay_off >= trial_on[t], delay_off <= trial_off[t])] if any( np.logical_and(delay_off >= trial_on[t], delay_off <= trial_off[t])) else np.nan trial_choice_on[t] = choice_on[np.logical_and( choice_on >= trial_on[t], choice_on <= trial_off[t])] if any( np.logical_and(choice_on >= trial_on[t], choice_on <= trial_off[t])) else np.nan trial_choice_off[t] = choice_off[np.logical_and( choice_off >= trial_on[t], choice_off <= trial_off[t])] if any( np.logical_and(choice_off >= trial_on[t], choice_off <= trial_off[t])) else np.nan trial_reward_pump_on[t] = reward_pump_on[np.logical_and( reward_pump_on >= trial_on[t], reward_pump_on <= trial_off[t])] if any( np.logical_and(reward_pump_on >= trial_on[t], reward_pump_on <= trial_off[t])) else np.nan trial_reward_pump_off[t] = reward_pump_off[np.logical_and( reward_pump_off >= trial_on[t], reward_pump_off <= trial_off[t])] if any( np.logical_and(reward_pump_off >= trial_on[t], reward_pump_off <= trial_off[t])) else np.nan # Variables that can have more than on value per trial trial_outcome_on.append(outcome_on[np.logical_and( outcome_on >= trial_on[t], outcome_on <= trial_off[t])] if any( np.logical_and(outcome_on >= trial_on[t], outcome_on <= trial_off[t])) else np.nan) trial_outcome_off.append(outcome_off[np.logical_and( outcome_off >= trial_on[t], outcome_off <= trial_off[t])] if any( np.logical_and(outcome_off >= trial_on[t], outcome_off <= trial_off[t])) else np.nan) trial_opto_on.append(opto_on[np.logical_and( opto_on >= trial_on[t], opto_on <= trial_off[t])] if any( np.logical_and(opto_on >= trial_on[t], opto_on <= trial_off[t]) ) else np.nan) trial_opto_off.append(opto_off[np.logical_and( opto_off >= trial_on[t], opto_off <= trial_off[t])] if any( np.logical_and(opto_off >= trial_on[t], opto_off <= trial_off[t])) else np.nan) trial_nosepoke_on.append(nosepoke_on[np.logical_and( nosepoke_on >= trial_on[t], nosepoke_on <= trial_off[t])] if any( np.logical_and(nosepoke_on >= trial_on[t], nosepoke_on <= trial_off[t])) else np.nan) trial_nosepoke_off.append(nosepoke_off[np.logical_and( nosepoke_off >= trial_on[t], nosepoke_off <= trial_off[t])] if any( np.logical_and(nosepoke_off >= trial_on[t], nosepoke_off <= trial_off[t])) else np.nan) # Giving 1 ms leeway for syncing pulse error # Variables that require logic computation if math.isnan(trial_sample_on[t]) == True: trial_trial_side[t] = '' else: trial_trial_side[t] = 'R' if any( np.logical_and( right_lever_on >= trial_sample_on[t] - 0.001, right_lever_on <= trial_sample_off[t] + 0.001)) else 'L' trial_opto_trial[t] = True if any( np.logical_and(opto_on >= trial_on[t], opto_on <= trial_off[t])) else False if trial_opto_trial[t] == True: if any( np.logical_and(opto_on >= trial_sample_on[t], opto_on <= trial_sample_off[t])): trial_opto_event[t] = 'S' if any( np.logical_and(opto_on >= trial_delay_on[t], opto_on <= trial_delay_off[t])): trial_opto_event[t] = 'D' if any( np.logical_and(opto_on >= trial_choice_on[t], opto_on <= trial_choice_off[t])): trial_opto_event[t] = 'C' # Calculate vector of completed trials trial_completed[t] = not math.isnan(trial_choice_on[t]) # Calculates vector of correct trials trial_correct[t] = not math.isnan(trial_reward_pump_on[t]) # Calculate vector with extremes of outcome,opto and nosepoke trial_outcome_first[t] = min(trial_outcome_on[t]) if not np.mean( np.isnan(trial_outcome_on[t])) else np.nan trial_outcome_last[t] = min(trial_outcome_off[t]) if not np.mean( np.isnan(trial_outcome_on[t])) else np.nan trial_nosepoke_first[t] = min(trial_nosepoke_on[t]) if not np.mean( np.isnan(trial_nosepoke_on[t])) else np.nan trial_nosepoke_last[t] = min(trial_nosepoke_off[t]) if not np.mean( np.isnan(trial_nosepoke_on[t])) else np.nan trial_opto_first[t] = min(trial_opto_on[t]) if not np.mean( np.isnan(trial_opto_on[t])) else np.nan trial_opto_last[t] = min(trial_opto_off[t]) if not np.mean( np.isnan(trial_opto_on[t])) else np.nan if save == True: np.save(output_path + '/' + '_trial_on.npy', trial_trial_on) np.save(output_path + '/' + '_trial_off.npy', trial_trial_off) np.save(output_path + '/' + '_trial_sample_on.npy', trial_sample_on) np.save(output_path + '/' + '_trial_sample_off.npy', trial_sample_off) np.save(output_path + '/' + '_trial_delay_on.npy', trial_delay_on) np.save(output_path + '/' + '_trial_delay_off.npy', trial_delay_off) np.save(output_path + '/' + '_trial_choice_on.npy', trial_choice_on) np.save(output_path + '/' + '_trial_choice_off.npy', trial_choice_off) np.save(output_path + '/' + '_trial_reward_pump_on.npy', trial_reward_pump_on) np.save(output_path + '/' + '_trial_reward_pump_off.npy', trial_reward_pump_off) np.save(output_path + '/' + '_trial_outcome_on.npy', trial_outcome_on) np.save(output_path + '/' + '_trial_outcome_off.npy', trial_outcome_off) np.save(output_path + '/' + '_trial_opto_on.npy', trial_opto_on) np.save(output_path + '/' + '_trial_opto_off.npy', trial_opto_off) np.save(output_path + '/' + '_trial_nosepoke_on.npy', trial_nosepoke_on) np.save(output_path + '/' + '_trial_nosepoke_off.npy', trial_nosepoke_off) np.save(output_path + '/' + '_trial_trial_side.npy', trial_trial_side) np.save(output_path + '/' + '_trial_opto_trial.npy', trial_opto_trial) np.save(output_path + '/' + '_trial_completed.npy', trial_completed) np.save(output_path + '/' + '_trial_correct.npy', trial_correct) np.save(output_path + '/' + '_trial_outcome_first.npy', trial_outcome_first) np.save(output_path + '/' + '_trial_outcome_last.npy', trial_outcome_last) np.save(output_path + '/' + '_trial_nosepoke_first.npy', trial_nosepoke_first) np.save(output_path + '/' + '_trial_nosepoke_last.npy', trial_nosepoke_last) np.save(output_path + '/' + '_trial_opto_first.npy', trial_opto_first) np.save(output_path + '/' + '_trial_opto_last.npy', trial_opto_last)
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
# load session fixtures settings = rawio.load_settings(session_path) ses_nb = settings['SESSION_ORDER'][settings['SESSION_IDX']] path_fixtures = Path(ephys_fpga.__file__).parent.joinpath('ephys_sessions') fixture = {'pcs': np.load(path_fixtures.joinpath(f'session_{ses_nb}_passive_pcs.npy')), 'delays': np.load(path_fixtures.joinpath(f'session_{ses_nb}_passive_stimDelays.npy')), 'ids': np.load(path_fixtures.joinpath(f'session_{ses_nb}_passive_stimIDs.npy'))} # load general metadata with open(path_fixtures.joinpath('passive_stim_meta.json'), 'r') as f: meta = json.load(f) t_end_ephys = passive.ephysCW_end(session_path=session_path) # load stimulus sequence sync, sync_map = ephys_fpga.get_main_probe_sync(session_path, bin_exists=False) fpga_sync = ephys_fpga._get_sync_fronts(sync, sync_map['frame2ttl']) fttl = ephys_fpga._get_sync_fronts(sync, sync_map['frame2ttl'], tmin=t_end_ephys) def get_spacers(): """ load and get spacer information, do corr to find spacer timestamps returns t_passive_starts, t_starts, t_ends """ 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, _ = passive.get_spacer_times(spacer_template=spacer_template, jitter=jitter, ttl_signal=fttl['times'], t_quiet=t_quiet)
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) audio = ephys_fpga._get_sync_fronts(sync, sync_map["audio"], tmin=treplay[0]) passiveTone_intervals, passiveNoise_intervals = _extract_passiveAudio_intervals( audio) 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 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. :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.eid and self.one and not isinstance(self.one, OneOffline): 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.side, 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.side] 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.side}Camera')['times'] except AssertionError: # Re-extract kwargs = dict(video_path=self.video_path, labels=self.side) 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.side}_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') 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. For speed start with the # fist 2 minutes (nearly always enough), extract wheel movements and pick one. # TODO Pick movement towards the end of the session (but not right at the end as some # are extrapolated). Make sure the movement isn't too long. 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.side) 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 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) ins = out['Events timestamps']['BNC1High'] outs = out['Events timestamps']['BNC1Low'] assert len(ins) == 500, 'not all pulses detected in bpod!' assert len(ins) == len(outs), 'not all fronts detected in bpod signal!' # get the fpga signal from the sync object s3 = ephys_fpga._get_sync_fronts(sync, 0) # 3b channel map assert len(s3['times']) == 1000, 'not all fronts detected in fpga signal!' offset_on = np.mean(np.array(s3['times'][1::2]) - np.array(outs)) # get delay offset_off = np.mean(np.array(s3['times'][0::2]) - np.array(ins)) jitter_on = np.std(np.array(s3['times'][1::2]) - np.array(outs)) # get jitter jitter_off = np.std(np.array(s3['times'][0::2]) - np.array(ins)) inter_pulse_interval_bpod = np.abs(np.array(ins) - np.array(outs)) inter_pulse_interval_fpga = np.abs( np.array(s3['times'][1::2]) - np.array(s3['times'][0::2])) print( 'maximal bpod jitter in sec: ', np.round( np.max(inter_pulse_interval_bpod) - np.min(inter_pulse_interval_bpod), 6)) print( 'maximal fpga jitter in sec: ', np.round( np.max(inter_pulse_interval_fpga) - np.min(inter_pulse_interval_fpga), 6)) print( 'maximal bpod-fpga in sec: ', np.round( np.max(np.abs(np.array(s3['times'][1::2]) - np.array(outs))) - np.min(np.abs(np.array(s3['times'][1::2]) - np.array(outs))), 6)) print( 'The fpga 500 ms square signal and \ the bpod 500 ms square signal are offset', 'by %s sec and the difference between them has std %s sec' % (np.round(np.mean([offset_on, offset_off]), 6), np.round(np.mean([jitter_on, jitter_off]), 6))) if show_plots: plt.figure('wavefronts') plt.plot(s3['times'], s3['polarities'], label='fpga') plt.plot(ins, np.ones(len(ins)), linestyle='', marker='o', label='pbod on') plt.plot(outs, np.ones(len(outs)), linestyle='', marker='x', label='bpod off') plt.legend() plt.show() plt.figure('histogram of wavefront differences, bpod and fpga') plt.hist(np.array(s3['times'][1::2]) - np.array(outs)) plt.xlabel('error between fpga fronts and ephys fronts in sec') plt.show()