示例#1
0
def plot_ephys_ophys_trace(key_cell,time_to_plot=None,trace_window = 1,show_stimulus = False,show_e_ap_peaks = False, show_o_ap_peaks = False):
    #%%
# =============================================================================
#     key_cell = {'session': 1,
#                 'subject_id': 456462,
#                 'cell_number': 3,
#                 'motion_correction_method': 'VolPy',
#                 'roi_type': 'VolPy'}
#     time_to_plot=None
#     trace_window = 100
#     show_stimulus = False
#     show_e_ap_peaks = True
#     show_o_ap_peaks = True
# =============================================================================
    
    
    fig=plt.figure()
    ax_ophys = fig.add_axes([0,0,2,.8])
    ax_ephys = fig.add_axes([0,-1,2,.8])
    if show_stimulus:
        ax_ephys_stim = fig.add_axes([0,-1.5,2,.4])
        
    #%
    session_time, cell_recording_start = (experiment.Session()*ephys_patch.Cell()&key_cell).fetch1('session_time','cell_recording_start')
    first_movie_start_time =  np.min(np.asarray(((imaging.Movie()*imaging_gt.GroundTruthROI())&key_cell).fetch('movie_start_time'),float))
    first_movie_start_time_real = first_movie_start_time + session_time.total_seconds()
    if not time_to_plot:
        time_to_plot = trace_window/2#ephys_matched_ap_times[0]
    session_time_to_plot = time_to_plot+first_movie_start_time  # time relative to session start
    cell_time_to_plot= session_time_to_plot + session_time.total_seconds() -cell_recording_start.total_seconds() # time relative to recording start
    #%
    sweep_start_times,sweep_end_times,sweep_nums = (ephys_patch.Sweep()&key_cell).fetch('sweep_start_time','sweep_end_time','sweep_number')
    needed_start_time = cell_time_to_plot - trace_window/2
    needed_end_time = cell_time_to_plot + trace_window/2
    #%
    sweep_nums = sweep_nums[((sweep_start_times > needed_start_time) & (sweep_start_times < needed_end_time)) |
                            ((sweep_end_times > needed_start_time) & (sweep_end_times < needed_end_time)) | 
                            ((sweep_end_times > needed_end_time) & (sweep_start_times < needed_start_time)) ]

    ephys_traces = list()
    ephys_trace_times = list()
    ephys_sweep_start_times = list()
    ephys_traces_stim = list()
    for sweep_num in sweep_nums:
        sweep = ephys_patch.Sweep()&key_cell&'sweep_number = %d' % sweep_num
        trace,sr= (ephys_patch.SweepMetadata()*ephys_patch.SweepResponse()&sweep).fetch1('response_trace','sample_rate')
        trace = trace*1000
        sweep_start_time  = float(sweep.fetch('sweep_start_time')) 
        trace_time = np.arange(len(trace))/sr + sweep_start_time + cell_recording_start.total_seconds() - first_movie_start_time_real
        
        trace_idx = (time_to_plot-trace_window/2 < trace_time) & (time_to_plot+trace_window/2 > trace_time)
                
        ax_ephys.plot(trace_time[trace_idx],trace[trace_idx],'k-')
        
        ephys_traces.append(trace)
        ephys_trace_times.append(trace_time)
        ephys_sweep_start_times.append(sweep_start_time)
        
        if show_e_ap_peaks:

            ap_max_index = (ephysanal.ActionPotential()&sweep).fetch('ap_max_index')
            aptimes = trace_time[np.asarray(ap_max_index,int)]
            apVs = trace[np.asarray(ap_max_index,int)]
            ap_needed = (time_to_plot-trace_window/2 < aptimes) & (time_to_plot+trace_window/2 > aptimes)
            aptimes  = aptimes[ap_needed]
            apVs  = apVs[ap_needed]
            ax_ephys.plot(aptimes,apVs,'ro')

        
        if show_stimulus:
            trace_stim= (ephys_patch.SweepMetadata()*ephys_patch.SweepStimulus()&sweep).fetch1('stimulus_trace')
            trace_stim = trace_stim*10**12
            ax_ephys_stim.plot(trace_time[trace_idx],trace_stim[trace_idx],'k-')
            ephys_traces_stim.append(trace_stim)
            
        
    ephysdata = {'ephys_traces':ephys_traces,'ephys_trace_times':ephys_trace_times}
    if show_stimulus:
        ephysdata['ephys_traces_stimulus'] = ephys_traces_stim

    movie_nums, movie_start_times,movie_frame_rates,movie_frame_nums = ((imaging.Movie()*imaging_gt.GroundTruthROI())&key_cell).fetch('movie_number','movie_start_time','movie_frame_rate','movie_frame_num')
    movie_start_times = np.asarray(movie_start_times, float)
    movie_end_times = np.asarray(movie_start_times, float)+np.asarray(movie_frame_nums, float)/np.asarray(movie_frame_rates, float)
    needed_start_time = session_time_to_plot - trace_window/2
    needed_end_time = session_time_to_plot + trace_window/2

    movie_nums = movie_nums[((movie_start_times >= needed_start_time) & (movie_start_times <= needed_end_time)) |
                            ((movie_end_times >= needed_start_time) & (movie_end_times <= needed_end_time)) | 
                            ((movie_end_times >= needed_end_time) & (movie_start_times <= needed_start_time)) ]
    dffs=list()
    frametimes = list()
    for movie_num in movie_nums:
    #movie_num = movie_nums[(session_time_to_plot>movie_start_times)&(session_time_to_plot<movie_end_times)][0]
        key_movie = key_cell.copy()
        key_movie['movie_number'] = movie_num

        dff,gt_roi_number = ((imaging.ROI()*imaging_gt.GroundTruthROI())&key_movie).fetch1('roi_dff','roi_number')
        dff_all,roi_number_all = (imaging.ROI()&key_movie).fetch('roi_dff','roi_number')
        dff_all =dff_all[roi_number_all!=gt_roi_number]
        frame_times = ((imaging.MovieFrameTimes()*imaging_gt.GroundTruthROI())&key_movie).fetch1('frame_times') + (session_time).total_seconds() - first_movie_start_time_real #modified to cell time
        frame_idx = (time_to_plot-trace_window/2 < frame_times) & (time_to_plot+trace_window/2 > frame_times)
        
        dff_list = [dff]
        dff_list.extend(dff_all)
        prevminval = 0
        for dff_now,alpha_now in zip(dff_list,np.arange(1,1/(len(dff_list)+1),-1/(len(dff_list)+1))):
            dfftoplotnow = dff_now[frame_idx] + prevminval
            ax_ophys.plot(frame_times[frame_idx],dfftoplotnow,'g-',alpha=alpha_now)
            prevminval = np.min(dfftoplotnow) -.005
        #ax_ophys.plot(frame_times[frame_idx],dff[frame_idx],'g-')
        dffs.append(dff)
        frametimes.append(frame_times)
        if show_o_ap_peaks:
            if 'raw' in key_cell['roi_type']:
                apidxes = ((imaging.ROI()*imaging_gt.GroundTruthROI())&key_movie).fetch1('roi_spike_indices')
            else:
                apidxes = ((imaging.ROI()*imaging_gt.GroundTruthROI())&key_movie).fetch1('roi_spike_indices')-1
            oap_times = frame_times[apidxes]
            oap_vals = dff[apidxes]
            oap_needed = (time_to_plot-trace_window/2 < oap_times) & (time_to_plot+trace_window/2 > oap_times)
            oap_times = oap_times[oap_needed]
            oap_vals = oap_vals[oap_needed]
            ax_ophys.plot(oap_times,oap_vals,'ro')

    ophysdata = {'ophys_traces':dffs,'ophys_trace_times':frametimes}
    ax_ophys.autoscale(tight = True)
    
# =============================================================================
#     dfff = np.concatenate(dffs)
#     dfff[np.argmin(dfff)]=0
#     ax_ophys.set_ylim([min(dfff),max(dfff)])
# =============================================================================
    ax_ophys.set_xlim([time_to_plot-trace_window/2,time_to_plot+trace_window/2])
    ax_ophys.set_ylabel('dF/F')
    ax_ophys.spines["top"].set_visible(False)
    ax_ophys.spines["right"].set_visible(False)
    
    ax_ophys.invert_yaxis()
    
    
    ax_ephys.autoscale(tight = True)
    ax_ephys.set_xlim([time_to_plot-trace_window/2,time_to_plot+trace_window/2])
    ax_ephys.set_ylabel('Vm (mV))')
    ax_ephys.spines["top"].set_visible(False)
    ax_ephys.spines["right"].set_visible(False)
    
    if show_stimulus:
       # ax_ephys_stim.autoscale(tight = True)
        ax_ephys_stim.set_xlim([time_to_plot-trace_window/2,time_to_plot+trace_window/2])
        ax_ephys_stim.set_ylabel('Injected current (pA))')
        ax_ephys_stim.set_xlabel('time from first movie start (s)')
        ax_ephys_stim.spines["top"].set_visible(False)
        ax_ephys_stim.spines["right"].set_visible(False)
    else:
        ax_ephys.set_xlabel('time from first movie start (s)')
    outdict = {'ephys':ephysdata,'ophys':ophysdata,'figure_handle':fig}
#%%
    return outdict
示例#2
0
    def make(self, key):
        #%
        #key = {'subject_id': 454597, 'session': 1, 'cell_number': 0, 'motion_correction_method': 'Matlab', 'roi_type': 'SpikePursuit', 'roi_number': 1}
        #key = {'subject_id': 456462, 'session': 1, 'cell_number': 5, 'movie_number': 3, 'motion_correction_method': 'VolPy', 'roi_type': 'VolPy', 'roi_number': 1}
        if len(
                ROIEphysCorrelation & key
        ) > 0:  #  and key['roi_type'] == 'SpikePursuit' #only spikepursuit for now..
            key_to_compare = key.copy()
            del key_to_compare['roi_number']
            #print(key)
            #%
            roinums = np.unique(
                (ROIEphysCorrelation() & key_to_compare).fetch('roi_number'))
            snratios_mean = list()
            snratios_median = list()
            snratios_first50 = list()
            for roinum_now in roinums:

                snratios = (ROIAPWave() & key_to_compare
                            & 'roi_number = {}'.format(roinum_now)
                            ).fetch('apwave_snratio')
                snratios_mean.append(np.mean(snratios))
                snratios_median.append(np.median(snratios))
                snratios_first50.append(np.mean(snratios[:50]))

            #%%
            if np.max(
                (ROIEphysCorrelation() & key).fetch('roi_number')
            ) == roinums[np.argmax(
                    snratios_first50
            )]:  #np.max((imaging_gt.ROIEphysCorrelation()&key).fetch('roi_number')) == np.min((imaging_gt.ROIEphysCorrelation&key_to_compare).fetch('roi_number')):#np.max(np.abs((ROIEphysCorrelation&key).fetch('corr_coeff'))) == np.max(np.abs((ROIEphysCorrelation&key_to_compare).fetch('corr_coeff'))):
                print('this is it')
                print(key['roi_type'])
                cellstarttime = (ephys_patch.Cell()
                                 & key).fetch1('cell_recording_start')
                sessionstarttime = (experiment.Session()
                                    & key).fetch1('session_time')
                aptimes = np.asarray(
                    (ephysanal.ActionPotential() & key).fetch('ap_max_time'),
                    float) + (cellstarttime -
                              sessionstarttime).total_seconds()
                sweep_start_times, sweep_end_times = (ephys_patch.Sweep()
                                                      & key).fetch(
                                                          'sweep_start_time',
                                                          'sweep_end_time')
                sweep_start_times = np.asarray(sweep_start_times, float) + (
                    cellstarttime - sessionstarttime).total_seconds()
                sweep_end_times = np.asarray(sweep_end_times, float) + (
                    cellstarttime - sessionstarttime).total_seconds()
                frame_timess, roi_spike_indicess = (
                    imaging.MovieFrameTimes() * imaging.Movie() *
                    imaging.ROI() & key).fetch('frame_times',
                                               'roi_spike_indices')
                movie_start_times = list()
                movie_end_times = list()
                roi_ap_times = list()
                for frame_times, roi_spike_indices in zip(
                        frame_timess, roi_spike_indicess):
                    movie_start_times.append(frame_times[0])
                    movie_end_times.append(frame_times[-1])
                    roi_ap_times.append(frame_times[roi_spike_indices])
                movie_start_times = np.sort(movie_start_times)
                movie_end_times = np.sort(movie_end_times)
                roi_ap_times = np.sort(np.concatenate(roi_ap_times))
                #%
                ##delete spikes in optical traces where there was no ephys recording
                for start_t, end_t in zip(
                        np.concatenate([sweep_start_times, [np.inf]]),
                        np.concatenate([[0], sweep_end_times])):
                    idxtodel = np.where((roi_ap_times > end_t)
                                        & (roi_ap_times < start_t))[0]
                    if len(idxtodel) > 0:
                        roi_ap_times = np.delete(roi_ap_times, idxtodel)
                ##delete spikes in ephys traces where there was no imaging
                for start_t, end_t in zip(
                        np.concatenate([movie_start_times, [np.inf]]),
                        np.concatenate([[0], movie_end_times])):
                    idxtodel = np.where((aptimes > end_t)
                                        & (aptimes < start_t))[0]
                    if len(idxtodel) > 0:
                        #print(idxtodel)
                        aptimes = np.delete(aptimes, idxtodel)
                        #%
                D = np.zeros([len(aptimes), len(roi_ap_times)])
                for idx, apt in enumerate(aptimes):
                    D[idx, :] = (roi_ap_times - apt) * 1000
                D_test = np.abs(D)
                D_test[D_test > 15] = 1000
                D_test[D < -1] = 1000
                X = scipy.optimize.linear_sum_assignment(D_test)
                #%
                cost = D_test[X[0], X[1]]
                unmatched = np.where(cost == 1000)[0]
                X0_final = np.delete(X[0], unmatched)
                X1_final = np.delete(X[1], unmatched)
                ephys_ap_times = aptimes[X0_final]
                ophys_ap_times = roi_ap_times[X1_final]
                false_positive_time_imaging = list()
                for roi_ap_time in roi_ap_times:
                    if roi_ap_time not in ophys_ap_times:
                        false_positive_time_imaging.append(roi_ap_time)
                false_negative_time_ephys = list()
                for aptime in aptimes:
                    if aptime not in ephys_ap_times:
                        false_negative_time_ephys.append(aptime)

                key['ephys_matched_ap_times'] = ephys_ap_times
                key['ophys_matched_ap_times'] = ophys_ap_times
                key['ephys_unmatched_ap_times'] = false_negative_time_ephys
                key['ophys_unmatched_ap_times'] = false_positive_time_imaging
                #print(imaging.ROI()&key)
                #print([len(aptimes),'vs',len(roi_ap_times)])
                #%%
                self.insert1(key, skip_duplicates=True)
示例#3
0
#             try:
# =============================================================================
            #%
            movie_dir = os.path.join(ground_truth_basedir , subject_id , cell_id , movie)        
            
            with open(os.path.join(movie_dir,'movie_metadata.json')) as json_file:
                movie_metadata = json.load(json_file)
            frame_times = np.load(os.path.join(movie_dir,'frame_times.npy'))
            pixel_shifts = np.load(os.path.join(movie_dir,'motion_corr_shifts_rigid.npy'))
            key_roi = {'subject_id': movie_metadata['subject_id'],
                       'session': movie_metadata['session'],
                       'movie_number': movie_metadata['movie_number'],
                       'motion_correction_method': 'VolPy',
                       'roi_type': 'VolPy'}
            #%
            dff,gt_roi_num = (imaging.ROI()*imaging_gt.GroundTruthROI()&key_roi).fetch1('roi_dff','roi_number')
            dff_all,roi_number_all = (imaging.ROI()&key_roi).fetch('roi_dff','roi_number')
            dff_all =dff_all[roi_number_all!=gt_roi_num]
            dff_list = [dff]
            dff_list.extend(dff_all)
            ephys_files_dir = os.path.join(movie_dir,'ephys')
            ephys_files = sorted(os.listdir(ephys_files_dir))
            sweep_time = list()
            sweep_response = list()
            sweep_stimulus = list()
            sweep_metadata = list()
            for ephys_file in ephys_files:
                if ephys_file[-3:]=='npz':
                    data_dict = np.load(os.path.join(ephys_files_dir,ephys_file))
                    sweep_time.append(data_dict['time'])
                    sweep_response.append(data_dict['voltage'])
示例#4
0
for movie_number in movie_numbers:
    
    frame_rate = ((imaging.Movie())&key_cell & 'movie_number = '+str(movie_number)).fetch('movie_frame_rate')[0]
    #frame_num = ((imaging.Movie())&key_cell & 'movie_number = '+str(movie_number)).fetch('movie_frame_num')[0]
    movie_start_time = float(((imaging.Movie())&key_cell & 'movie_number = '+str(movie_number)).fetch('movie_start_time')[0])
    movie_start_time = session_time.total_seconds() + movie_start_time - cell_time.total_seconds()
    movie_time = (imaging.MovieFrameTimes()&key_cell & 'movie_number = '+str(movie_number)).fetch('frame_times')[0] -cell_time.total_seconds() +session_time.total_seconds()
    movie_end_time = movie_time[-1]

    sweeps_needed = ephys_patch.Sweep()&key_cell&'sweep_start_time < '+str(movie_end_time) & 'sweep_end_time > '+str(movie_start_time)
    sweep_start_ts, sweep_end_ts, traces,sweep_nums, sample_rates= (sweeps_needed*ephys_patch.SweepResponse()*ephys_patch.SweepMetadata()).fetch('sweep_start_time','sweep_end_time','response_trace','sweep_number','sample_rate')
    trace_times = list()
    for sweep_start_t, sweep_end_t, trace,sample_rate in zip(sweep_start_ts, sweep_end_ts, traces,sample_rates):
        trace_times.append(np.arange(float(sweep_start_t), float(sweep_end_t)+1/sample_rate,1/sample_rate))#np.arange(len(trace))/sample_rate+float(sweep_start_t)
    #%
    dff = (imaging.ROI()*imaging_gt.GroundTruthROI()&key_cell&'movie_number = {}'.format(movie_number)).fetch1('roi_dff')
    for trace,tracetime,sweep_number,sample_rate in zip(traces,trace_times,sweep_nums,sample_rates):  
        #%
        
        start_t = tracetime[0]
        start_t = movie_time[np.argmax(movie_time>=start_t)]
        end_t = np.min([tracetime[-1],movie_time[-1]])
        t = np.arange(0,.01,1/sample_rate)
        
        if convolve_voltron_kinetics:
            f_on = tau_1_ratio_on*np.exp(t/tau_1_on) + (1-tau_1_ratio_on)*np.exp(-t/tau_2_on)
            f_off = tau_1_ratio_off*np.exp(t[::-1]/tau_1_off) + (1-tau_1_ratio_off)*np.exp(-t[::-1]/tau_2_off)
            f_on = f_on/np.max(f_on)
            f_off = f_off/np.max(f_off)
            kernel = np.concatenate([f_on,np.zeros(len(f_off))])[::-1]
            kernel  = kernel /sum(kernel )
示例#5
0
    ) & key_cell & 'sweep_start_time < ' + str(
        movie_end_time) & 'sweep_end_time > ' + str(movie_start_time)
    sweep_start_ts, sweep_end_ts, traces, sweep_nums, sample_rates = (
        sweeps_needed * ephys_patch.SweepResponse() *
        ephys_patch.SweepMetadata()).fetch('sweep_start_time',
                                           'sweep_end_time', 'response_trace',
                                           'sweep_number', 'sample_rate')
    trace_times = list()
    for sweep_start_t, sweep_end_t, trace, sample_rate in zip(
            sweep_start_ts, sweep_end_ts, traces, sample_rates):
        trace_times.append(
            np.arange(float(sweep_start_t),
                      float(sweep_end_t) + 1 / sample_rate, 1 / sample_rate)
        )  #np.arange(len(trace))/sample_rate+float(sweep_start_t)
    #%
    dff = (imaging.ROI() * imaging_gt.GroundTruthROI() & key_cell
           & 'movie_number = {}'.format(movie_number)).fetch1('roi_dff')
    for trace, tracetime, sweep_number, sample_rate in zip(
            traces, trace_times, sweep_nums, sample_rates):
        #%

        start_t = tracetime[0]
        start_t = movie_time[np.argmax(movie_time >= start_t)]
        end_t = np.min([tracetime[-1], movie_time[-1]])
        t = np.arange(0, .01, 1 / sample_rate)

        if convolve_voltron_kinetics:
            f_on = tau_1_ratio_on * np.exp(
                t / tau_1_on) + (1 - tau_1_ratio_on) * np.exp(-t / tau_2_on)
            f_off = tau_1_ratio_off * np.exp(t[::-1] / tau_1_off) + (
                1 - tau_1_ratio_off) * np.exp(-t[::-1] / tau_2_off)