def plot_IV(subject_id=454597, cellnum=1, ivnum=0, IVsweepstoplot=None): #% key = {'subject_id': subject_id, 'cell_number': cellnum} sweeps = pd.DataFrame(ephys_patch.Sweep() & key) protocolnames = sweeps['protocol_name'].unique() ivprotocolnames = [i for i in protocolnames if 'iv' in i.lower()] ivprotocolname = ivprotocolnames[ivnum] key['protocol_name'] = ivprotocolname # df_iv = pd.DataFrame() #% if IVsweepstoplot == None: #% ivsweepnums = (ephys_patch.Sweep() & key).fetch('protocol_sweep_number') for iwsweepnum in ivsweepnums: key['protocol_sweep_number'] = iwsweepnum apnum = len(ephysanal.ActionPotential() * ephys_patch.Sweep() & key) if apnum > 2: break IVsweepstoplot = [0, iwsweepnum] for sweepnum in IVsweepstoplot: key['protocol_sweep_number'] = sweepnum df_iv = pd.concat([ df_iv, pd.DataFrame((ephys_patch.Sweep() & key) * (ephys_patch.SweepResponse() & key) * (ephys_patch.SweepStimulus() & key) * (ephys_patch.SweepMetadata() & key)) ]) df_IV = pd.DataFrame() for line in df_iv.iterrows(): linenow = line[1] time = np.arange(0, len( linenow['response_trace'])) / linenow['sample_rate'] linenow['time'] = time df_IV = pd.concat([df_IV, linenow.to_frame().transpose()]) fig = plt.figure() ax_IV = fig.add_subplot(211) #add_axes([0,0,1,1]) ax_stim = fig.add_subplot(212) #.add_axes([0,-.4,1,.2]) for line in df_IV.iterrows(): ax_IV.plot(line[1]['time'], line[1]['response_trace'] * 1000, 'k-') ax_stim.plot(line[1]['time'], line[1]['stimulus_trace'] * 10**12, 'k-') ax_IV.set_xlabel('Time (s)') ax_IV.set_xlim([0, 1]) ax_IV.set_ylabel('mV') ax_IV.set_title('subject: {} cell: {}'.format(subject_id, cellnum)) ax_stim.set_xlabel('Time (s)') ax_stim.set_xlim([0, 1]) ax_stim.set_ylabel('pA') #ax_stim.set_title('Stimulus') return fig
def make(self, key): time_back = .0002 time_capacitance = .0001 time_forward = .0002 df_squarepulse = pd.DataFrame((SquarePulse()&key)*ephys_patch.Sweep()*ephys_patch.SweepResponse()*ephys_patch.SweepMetadata()) stimamplitude = df_squarepulse['square_pulse_amplitude'].values[0] if np.abs(stimamplitude)>=40*10**-12: trace = df_squarepulse['response_trace'].values[0] start_idx = df_squarepulse['square_pulse_start_idx'][0] end_idx = df_squarepulse['square_pulse_end_idx'][0] sr = df_squarepulse['sample_rate'][0] step_back = int(np.round(time_back*sr)) step_capacitance = int(np.round(time_capacitance*sr)) step_forward = int(np.round(time_forward*sr)) v0_start = np.mean(trace[start_idx-step_back:start_idx]) vrs_start = np.mean(trace[start_idx+step_capacitance:start_idx+step_capacitance+step_forward]) v0_end = np.mean(trace[end_idx-step_back:end_idx]) vrs_end = np.mean(trace[end_idx+step_capacitance:end_idx+step_capacitance+step_forward]) dv_start = vrs_start-v0_start RS_start = dv_start/stimamplitude dv_end = vrs_end-v0_end RS_end = dv_end/stimamplitude*-1 RS = np.round(np.mean([RS_start,RS_end])/1000000,2) key['series_resistance_squarepulse'] = RS self.insert1(key,skip_duplicates=True)
def make(self, key): #%% #key = {'subject_id': 454263, 'session': 1, 'cell_number': 1, 'sweep_number': 62} #print(key) keynow = key.copy() if len(ActionPotential() & keynow) == 0: #%% pd_sweep = pd.DataFrame((ephys_patch.Sweep() & key) * (SweepResponseCorrected() & key) * (ephys_patch.SweepStimulus() & key) * (ephys_patch.SweepMetadata() & key)) if len(pd_sweep) > 0: trace = pd_sweep['response_trace_corrected'].values[0] sr = pd_sweep['sample_rate'][0] si = 1 / sr msstep = int(.0005 / si) sigma = .00005 trace_f = ndimage.gaussian_filter(trace, sigma / si) d_trace_f = np.diff(trace_f) / si peaks = d_trace_f > 40 sp_starts, sp_ends = (SquarePulse() & key).fetch( 'square_pulse_start_idx', 'square_pulse_end_idx') squarepulses = np.concatenate([sp_starts, sp_ends]) for sqidx in squarepulses: peaks[sqidx - msstep:sqidx + msstep] = False peaks = ndimage.morphology.binary_dilation( peaks, np.ones(int(round(.002 / si)))) spikemaxidxes = list() while np.any(peaks): spikestart = np.argmax(peaks) spikeend = np.argmin(peaks[spikestart:]) + spikestart if spikestart == spikeend: if sum(peaks[spikestart:]) == len(peaks[spikestart:]): spikeend = len(trace) try: sipeidx = np.argmax( trace[spikestart:spikeend]) + spikestart except: print(key) sipeidx = np.argmax( trace[spikestart:spikeend]) + spikestart spikemaxidxes.append(sipeidx) peaks[spikestart:spikeend] = False #% if len(spikemaxidxes) > 0: spikemaxtimes = spikemaxidxes / sr + float( pd_sweep['sweep_start_time'].values[0]) spikenumbers = np.arange(len(spikemaxidxes)) + 1 keylist = list() for spikenumber, spikemaxidx, spikemaxtime in zip( spikenumbers, spikemaxidxes, spikemaxtimes): keynow = key.copy() keynow['ap_num'] = spikenumber keynow['ap_max_index'] = spikemaxidx keynow['ap_max_time'] = spikemaxtime keylist.append(keynow) #%% self.insert(keylist, skip_duplicates=True)
def make(self, key): #%% #key = {'subject_id':456462,'session':1,'cell_number':3,'sweep_number':24} exposure = (ephys_patch.SweepImagingExposure()&key).fetch('imaging_exposure_trace') if len(exposure)>0: si = 1/(ephys_patch.SweepMetadata()&key).fetch('sample_rate')[0] sweeptime = float((ephys_patch.Sweep()&key).fetch('sweep_start_time')[0]) exposure = np.diff(exposure[0]) peaks = signal.find_peaks(exposure) peaks_idx = peaks[0] key['frame_idx']= peaks_idx key['frame_sweep_time']= peaks_idx*si key['frame_time']= peaks_idx*si + sweeptime self.insert1(key,skip_duplicates=True)
def get_sweep(key_sweep,junction_potential = 13.5, downsampled_rate = 10000): key_sweep['cell_number'] = (imaging_gt.CellMovieCorrespondance()&key_sweep).fetch1('cell_number') #% # ============================================================================= # key_sweep = {'subject_id': 456462,'session' : 1, 'movie_number' : 0, 'cell_number' : 3,'sweep_number':28} # junction_potential = 13.5 #mV # downsampled_rate = 10000 #Hz # ============================================================================= neutralizationenable,e_sr= (ephys_patch.SweepMetadata()&key_sweep).fetch1('neutralizationenable','sample_rate') try: uncompensatedRS = float((ephysanal.SweepSeriesResistance()&key_sweep).fetch1('series_resistance_residual')) except: uncompensatedRS = 0 v = (ephys_patch.SweepResponse()&key_sweep).fetch1('response_trace') i = (ephys_patch.SweepStimulus()&key_sweep).fetch1('stimulus_trace') tau_1_on =.1/1000 t = np.arange(0,.001,1/e_sr) f_on = np.exp(t/tau_1_on) f_on = f_on/np.max(f_on) kernel = np.concatenate([f_on,np.zeros(len(t))])[::-1] kernel = kernel /sum(kernel ) i_conv = np.convolve(i,kernel,'same') v_comp = (v - i_conv*uncompensatedRS*10**6)*1000 - junction_potential i = i * 10**12 sweep_start_time = float((ephys_patch.Sweep()&key_sweep).fetch('sweep_start_time')) trace_t = np.arange(len(v))/e_sr + sweep_start_time downsample_factor = int(np.round(e_sr/downsampled_rate)) #%downsampling v_out = moving_average(v_comp, n=downsample_factor) v_out = v_out[int(downsample_factor/2)::downsample_factor] i_out = moving_average(i, n=downsample_factor) i_out = i_out[int(downsample_factor/2)::downsample_factor] t_out = moving_average(trace_t, n=downsample_factor) t_out = t_out[int(downsample_factor/2)::downsample_factor] return v_out, i_out, t_out
def make(self, key): counter = 0 #%% sigma = .00003 # seconds for filering step_time = .0001 # seconds threshold_value = 5 # mV/ms baseline_length = .01 #s back from threshold #%% # ============================================================================= # key = {'subject_id': 454263, 'session': 1, 'cell_number': 1, 'sweep_number': 56, 'ap_num': 30} # print(key) # ============================================================================= keynow = key.copy() del keynow['ap_num'] pd_sweep = pd.DataFrame( (ephys_patch.Sweep() & key) * (SweepResponseCorrected() & key) * (ephys_patch.SweepStimulus() & key) * (ephys_patch.SweepMetadata() & key)) pd_ap = pd.DataFrame(ActionPotential() & keynow) #%% if len(pd_ap) > 0 and len(ActionPotentialDetails() & dict(pd_ap.loc[0])) == 0: #%% #print(key) trace = pd_sweep['response_trace_corrected'].values[0] sr = pd_sweep['sample_rate'][0] si = 1 / sr step_size = int(np.round(step_time / si)) ms5_step = int(np.round(.005 / si)) trace_f = ndimage.gaussian_filter(trace, sigma / si) d_trace_f = np.diff(trace_f) / si tracelength = len(trace) baseline_step = int(np.round(baseline_length / si)) #%% keylist = list() for ap_now in pd_ap.iterrows(): counter += 1 if counter % 2 == 0: dj.conn().ping() ap_now = dict(ap_now[1]) ap_max_index = ap_now['ap_max_index'] dvmax_index = ap_max_index while dvmax_index > step_size * 2 and trace_f[dvmax_index] > 0: dvmax_index -= step_size while dvmax_index > step_size * 2 and dvmax_index < tracelength - step_size and np.max( d_trace_f[dvmax_index - step_size:dvmax_index] ) > np.max(d_trace_f[dvmax_index:dvmax_index + step_size]): dvmax_index -= step_size if dvmax_index < tracelength - 1: dvmax_index = dvmax_index + np.argmax( d_trace_f[dvmax_index:dvmax_index + step_size]) else: dvmax_index = tracelength - 2 dvmin_index = ap_max_index #% while dvmin_index < tracelength - step_size and ( trace_f[dvmin_index] > 0 or np.min(d_trace_f[np.max([dvmin_index - step_size, 0]):dvmin_index]) > np.min( d_trace_f[dvmin_index:dvmin_index + step_size])): dvmin_index += step_size #% dvmin_index -= step_size dvmin_index = dvmin_index + np.argmin( d_trace_f[dvmin_index:dvmin_index + step_size]) thresh_index = dvmax_index while thresh_index > step_size * 2 and (np.min( d_trace_f[thresh_index - step_size:thresh_index]) > threshold_value): thresh_index -= step_size thresh_index = thresh_index - np.argmax( (d_trace_f[np.max([0, thresh_index - step_size] ):thresh_index] < threshold_value)[::-1]) ap_threshold = trace_f[thresh_index] ap_amplitude = trace_f[ap_max_index] - ap_threshold hw_step_back = np.argmax( trace_f[ap_max_index:np.max([ap_max_index - ms5_step, 0]):-1] < ap_threshold + ap_amplitude / 2) hw_step_forward = np.argmax( trace_f[ap_max_index:ap_max_index + ms5_step] < ap_threshold + ap_amplitude / 2) ap_halfwidth = (hw_step_back + hw_step_forward) * si if ap_amplitude > .01 and ap_halfwidth > .0001: ap_now['ap_real'] = 1 else: ap_now['ap_real'] = 0 ap_now['ap_threshold'] = ap_threshold * 1000 ap_now['ap_threshold_index'] = thresh_index if thresh_index > 10: ap_now['ap_baseline_value'] = np.mean( trace_f[np.max([thresh_index - baseline_step, 0] ):thresh_index]) * 1000 else: ap_now['ap_baseline_value'] = ap_threshold * 1000 ap_now['ap_halfwidth'] = ap_halfwidth * 1000 ap_now['ap_amplitude'] = ap_amplitude * 1000 ap_now['ap_dv_max'] = d_trace_f[dvmax_index] ap_now['ap_dv_max_voltage'] = trace_f[dvmax_index] * 1000 ap_now['ap_dv_min'] = d_trace_f[dvmin_index] ap_now['ap_dv_min_voltage'] = trace_f[dvmin_index] * 1000 del ap_now['ap_max_index'] del ap_now['ap_max_time'] keylist.append(ap_now) #%% self.insert(keylist, skip_duplicates=True)
def populateelphys(): #%% df_subject_wr_sessions = pd.DataFrame(lab.WaterRestriction() * experiment.Session() * experiment.SessionDetails) df_subject_ids = pd.DataFrame(lab.Subject()) if len(df_subject_wr_sessions) > 0: subject_names = df_subject_wr_sessions[ 'water_restriction_number'].unique() subject_names.sort() else: subject_names = list() subject_ids = df_subject_ids['subject_id'].unique() #% sumdata = list() basedir = Path(dj.config['locations.elphysdata_acq4']) for setup_dir in basedir.iterdir(): setup_name = setup_dir.name sessions = np.sort( os.listdir(setup_dir) ) #configfile.readConfigFile(setup_dir.joinpath('.index')) for session_acq in sessions[::-1]: #.keys(): if session_acq != '.' and session_acq != 'log.txt': session_dir = setup_dir.joinpath(session_acq) try: cells = configfile.readConfigFile( session_dir.joinpath('.index')) except: # if there is no file cells = None if cells and 'WR_name/ID' in cells['.'].keys( ): # it needs to have WRname wrname_ephys = cells['.']['WR_name/ID'] wrname = None for wrname_potential in subject_names: # look for water restriction number if wrname_potential.lower() in wrname_ephys.lower(): wrname = wrname_potential subject_id = (df_subject_wr_sessions.loc[ df_subject_wr_sessions[ 'water_restriction_number'] == wrname, 'subject_id']).unique()[0] if wrname == None: # look for animal identifier: for wrname_potential in subject_ids: # look for water restriction number if str(wrname_potential) in wrname_ephys.lower(): subject_id = wrname_potential if len(df_subject_wr_sessions) > 0 and len( (df_subject_wr_sessions.loc[ df_subject_wr_sessions['subject_id'] == subject_id, 'water_restriction_number'] ).unique()) > 0: wrname = (df_subject_wr_sessions.loc[ df_subject_wr_sessions['subject_id'] == subject_id, 'water_restriction_number'] ).unique()[0] else: wrname = 'no water restriction number for this mouse' if wrname: session_date = ( session_acq[0:session_acq.find('_')]).replace( '.', '-') print('animal: ' + str(subject_id) + ' - ' + wrname) ## if setup_name == 'Voltage_rig_1P': setupname = 'Voltage-Imaging-1p' else: print('unkwnown setup, please add') timer.wait(1000) if 'experimenter' in cells['.'].keys(): username = cells['.']['experimenter'] else: username = '******' print( 'username not specified in acq4 file, assuming rozsam' ) ### check if session already exists sessiondata = { 'subject_id': subject_id, #(lab.WaterRestriction() & 'water_restriction_number = "'+df_behavior_session['subject'][0]+'"').fetch()[0]['subject_id'], 'session': np.nan, 'session_date': session_date, 'session_time': np.nan, #session_time.strftime('%H:%M:%S'), 'username': username, 'rig': setupname } for cell in cells.keys(): if cell != '.' and cell != 'log.txt': ephisdata_cell = list() sweepstarttimes = list() cell_dir = session_dir.joinpath(cell) serieses = configfile.readConfigFile( cell_dir.joinpath('.index')) cellstarttime = datetime.datetime.fromtimestamp( serieses['.']['__timestamp__']) for series in serieses.keys(): if series != '.' and series != 'log.txt': series_dir = cell_dir.joinpath(series) sweeps = configfile.readConfigFile( series_dir.joinpath('.index')) if 'Clamp1.ma' in sweeps.keys(): protocoltype = 'single sweep' sweepkeys = [''] else: protocoltype = 'multiple sweeps' sweepkeys = sweeps.keys() for sweep in sweepkeys: if sweep != '.' and '.txt' not in sweep and '.ma' not in sweep: sweep_dir = series_dir.joinpath( sweep) sweepinfo = configfile.readConfigFile( sweep_dir.joinpath( '.index')) if sweep == '': sweep = '0' for file in sweepinfo.keys(): if '.ma' in file: try: # old file version #print('new file version') #% ephysfile = h5.File( sweep_dir. joinpath(file), "r") data = ephysfile[ 'data'][()] metadata_h5 = ephysfile[ 'info'] metadata = read_h5f_metadata( metadata_h5) daqchannels = list( metadata[2] ['DAQ'].keys()) sweepstarttime = datetime.datetime.fromtimestamp( metadata[2] ['DAQ'] [daqchannels[ 0]] ['startTime']) relativetime = ( sweepstarttime - cellstarttime ).total_seconds() if len( ephisdata_cell ) > 0 and ephisdata_cell[ -1]['sweepstarttime'] == sweepstarttime: ephisdata = ephisdata_cell.pop( ) else: ephisdata = dict( ) if 'primary' in daqchannels: # ephys data ephisdata[ 'V'] = data[ 1] ephisdata[ 'stim'] = data[ 0] ephisdata[ 'data'] = data ephisdata[ 'metadata'] = metadata ephisdata[ 'time'] = metadata[ 1]['values'] ephisdata[ 'relativetime'] = relativetime ephisdata[ 'sweepstarttime'] = sweepstarttime ephisdata[ 'series'] = series ephisdata[ 'sweep'] = sweep sweepstarttimes.append( sweepstarttime ) else: # other daq stuff #% for idx, channel in enumerate( metadata[ 0] ['cols']): channelname = channel[ 'name'].decode( ) if channelname[ 0] == 'u': channelname = channelname[ 2: -1] if channelname in [ 'OrcaFlashExposure', 'Temperature', 'LED525', 'FrameCommand', 'NextFileTrigger' ]: ephisdata[ channelname] = data[ idx] #print('{} added'.format(channelname)) else: print( 'waiting in the other daq' ) timer.sleep( 1000 ) ephisdata_cell.append( ephisdata) #% except: # new file version print( 'old version') ephysfile = MetaArray( ) ephysfile.readFile( sweep_dir. joinpath(file)) data = ephysfile.asarray( ) metadata = ephysfile.infoCopy( ) sweepstarttime = datetime.datetime.fromtimestamp( metadata[2] ['startTime']) relativetime = ( sweepstarttime - cellstarttime ).total_seconds() ephisdata = dict() ephisdata[ 'V'] = data[1] ephisdata[ 'stim'] = data[ 0] ephisdata[ 'data'] = data ephisdata[ 'metadata'] = metadata ephisdata[ 'time'] = metadata[ 1]['values'] ephisdata[ 'relativetime'] = relativetime ephisdata[ 'sweepstarttime'] = sweepstarttime ephisdata[ 'series'] = series ephisdata[ 'sweep'] = sweep sweepstarttimes.append( sweepstarttime) ephisdata_cell.append( ephisdata) # ============================================================================ # if wrname == 'FOR04': # ============================================================================= # add session to DJ if not present if len(ephisdata_cell) > 0: # ============================================================================= # print('waiting') # timer.sleep(1000) # ============================================================================= #% if len(experiment.Session() & 'subject_id = "' + str(sessiondata['subject_id']) + '"' & 'session_date = "' + str(sessiondata['session_date']) + '"') == 0: if len(experiment.Session() & 'subject_id = "' + str(sessiondata['subject_id']) + '"') == 0: sessiondata['session'] = 1 else: sessiondata['session'] = len( (experiment.Session() & 'subject_id = "' + str(sessiondata['subject_id']) + '"').fetch()['session']) + 1 sessiondata['session_time'] = ( sweepstarttimes[0] ).strftime( '%H:%M:%S' ) # the time of the first sweep will be the session time experiment.Session().insert1( sessiondata) #% session = ( experiment.Session() & 'subject_id = "' + str(sessiondata['subject_id']) + '"' & 'session_date = "' + str(sessiondata['session_date']) + '"').fetch('session')[0] cell_number = int(cell[cell.find('_') + 1:]) #add cell if not added already celldata = { 'subject_id': subject_id, 'session': session, 'cell_number': cell_number, } #% if len(ephys_patch.Cell() & celldata ) == 0 or len(ephys_patch.Cell() * ephys_patch.Sweep() & celldata) < len( ephisdata_cell): if len(ephys_patch.Cell() * ephys_patch.Sweep() & celldata ) < len(ephisdata_cell): print('finishing a recording:') else: print('adding new recording:') print(celldata) if 'type' in serieses['.'].keys(): if serieses['.'][ 'type'] == 'interneuron': celldata['cell_type'] = 'int' elif serieses['.'][ 'type'] == 'unknown' or serieses[ '.']['type'] == 'fail': celldata[ 'cell_type'] = 'unidentified' else: print('unhandled cell type!!') timer.sleep(1000) else: celldata[ 'cell_type'] = 'unidentified' celldata['cell_recording_start'] = ( sweepstarttimes[0] ).strftime('%H:%M:%S') if 'depth' in serieses['.'].keys( ) and len(serieses['.']['depth']) > 0: celldata['depth'] = int( serieses['.']['depth']) else: celldata['depth'] = -1 try: ephys_patch.Cell().insert1( celldata, allow_direct_insert=True) except dj.errors.DuplicateError: pass #already uploaded if 'notes' in serieses['.'].keys(): cellnotes = serieses['.']['notes'] else: cellnotes = '' cellnotesdata = { 'subject_id': subject_id, 'session': session, 'cell_number': cell_number, 'notes': cellnotes } try: ephys_patch.CellNotes().insert1( cellnotesdata, allow_direct_insert=True) except dj.errors.DuplicateError: pass #already uploaded #% for i, ephisdata in enumerate( ephisdata_cell): #% sweep_number = i print('sweep {}'.format( sweep_number)) sweep_data = { 'subject_id': subject_id, 'session': session, 'cell_number': cell_number, 'sweep_number': sweep_number, 'sweep_start_time': (ephisdata['sweepstarttime'] - sweepstarttimes[0] ).total_seconds(), 'sweep_end_time': (ephisdata['sweepstarttime'] - sweepstarttimes[0] ).total_seconds() + ephisdata['time'][-1], 'protocol_name': ephisdata[ 'series'], #[:ephisdata['series'].find('_')], 'protocol_sweep_number': int(ephisdata['sweep']) } if 'mode' in ephisdata['metadata'][ 2]['ClampState']: # old file version recmode = ephisdata[ 'metadata'][2][ 'ClampState']['mode'] else: recmode = ephisdata[ 'metadata'][2]['Protocol'][ 'mode'] if 'IC' in str(recmode): recording_mode = 'current clamp' else: print( 'unhandled recording mode, please act..' ) timer.sleep(10000) channelnames = list() channelunits = list() for line_now in ephisdata[ 'metadata'][0]['cols']: if type(line_now['name'] ) == bytes: channelnames.append( line_now['name']. decode().strip("'")) channelunits.append( line_now['units']. decode().strip("'")) else: channelnames.append( line_now['name']) channelunits.append( line_now['units']) commandidx = np.where( np.array(channelnames) == 'command')[0][0] dataidx = np.where( np.array(channelnames) == 'primary')[0][0] #% clampparams_data = ephisdata[ 'metadata'][2]['ClampState'][ 'ClampParams'].copy() clampparams_data_new = dict() for clampparamkey in clampparams_data.keys( ): #6004 is true for some reason.. changing it back to 1 if type(clampparams_data[ clampparamkey] ) == np.int32: if clampparams_data[ clampparamkey] > 0: clampparams_data[ clampparamkey] = int( 1) else: clampparams_data[ clampparamkey] = int( 0) else: clampparams_data[ clampparamkey] = float( clampparams_data[ clampparamkey]) clampparams_data_new[ clampparamkey.lower( )] = clampparams_data[ clampparamkey] #% sweepmetadata_data = { 'subject_id': subject_id, 'session': session, 'cell_number': cell_number, 'sweep_number': sweep_number, 'recording_mode': recording_mode, 'sample_rate': np.round(1 / np.median( np.diff( ephisdata['metadata'] [1]['values']))) } sweepmetadata_data.update( clampparams_data_new) sweepdata_data = { 'subject_id': subject_id, 'session': session, 'cell_number': cell_number, 'sweep_number': sweep_number, 'response_trace': ephisdata['data'][dataidx, :], 'response_units': ephisdata['metadata'][0] ['cols'][dataidx]['units'] } sweepstimulus_data = { 'subject_id': subject_id, 'session': session, 'cell_number': cell_number, 'sweep_number': sweep_number, 'stimulus_trace': ephisdata['data'][ commandidx, :], 'stimulus_units': ephisdata['metadata'][0] ['cols'][commandidx]['units'] } #print('waiting') #timer.sleep(10000) try: ephys_patch.Sweep().insert1( sweep_data, allow_direct_insert=True) except dj.errors.DuplicateError: pass #already uploaded try: # maybe it's a duplicate.. ephys_patch.ClampParams( ).insert1( clampparams_data_new, allow_direct_insert=True) except dj.errors.DuplicateError: pass #already uploaded try: ephys_patch.SweepMetadata( ).insert1( sweepmetadata_data, allow_direct_insert=True) except dj.errors.DuplicateError: pass #already uploaded try: ephys_patch.SweepResponse( ).insert1( sweepdata_data, allow_direct_insert=True) except dj.errors.DuplicateError: pass #already uploaded try: ephys_patch.SweepStimulus( ).insert1( sweepstimulus_data, allow_direct_insert=True) except dj.errors.DuplicateError: pass #already uploaded #% if 'OrcaFlashExposure' in ephisdata.keys( ): sweepimagingexposuredata = { 'subject_id': subject_id, 'session': session, 'cell_number': cell_number, 'sweep_number': sweep_number, 'imaging_exposure_trace': ephisdata[ 'OrcaFlashExposure'] } try: ephys_patch.SweepImagingExposure( ).insert1( sweepimagingexposuredata, allow_direct_insert=True ) except dj.errors.DuplicateError: pass #already uploaded if 'Temperature' in ephisdata.keys( ): sweeptemperaturedata = { 'subject_id': subject_id, 'session': session, 'cell_number': cell_number, 'sweep_number': sweep_number, 'temperature_trace': ephisdata['Temperature'] * 10, 'temperature_units': 'degC' } try: ephys_patch.SweepTemperature( ).insert1( sweeptemperaturedata, allow_direct_insert=True ) except dj.errors.DuplicateError: pass #already uploaded if 'LED525' in ephisdata.keys(): sweepLEDdata = { 'subject_id': subject_id, 'session': session, 'cell_number': cell_number, 'sweep_number': sweep_number, 'imaging_led_trace': ephisdata['LED525'] } try: ephys_patch.SweepLED( ).insert1( sweepLEDdata, allow_direct_insert=True ) except dj.errors.DuplicateError: pass #already uploaded
uncompensatedRS = float((ephysanal.SweepSeriesResistance()&key_sweep).fetch1('series_resistance_residual')) except: uncompensatedRS = 0 v = (ephys_patch.SweepResponse()&key_sweep).fetch1('response_trace') i = (ephys_patch.SweepStimulus()&key_sweep).fetch1('stimulus_trace') tau_1_on =.1/1000 t = np.arange(0,.001,1/e_sr) f_on = np.exp(t/tau_1_on) f_on = f_on/np.max(f_on) kernel = np.concatenate([f_on,np.zeros(len(t))])[::-1] kernel = kernel /sum(kernel ) i_conv = np.convolve(i,kernel,'same') v_comp = (v - i*uncompensatedRS*10**6)*1000 - junction_potential i = i * 10**12 sweep_start_time = float((ephys_patch.Sweep()&key_sweep).fetch('sweep_start_time')) trace_t = np.arange(len(v))/e_sr + sweep_start_time downsample_factor = int(np.round(e_sr/downsampled_rate)) #%downsampling v_out = moving_average(v_comp, n=downsample_factor) v_out = v_out[int(downsample_factor/2)::downsample_factor] i_out = moving_average(i, n=downsample_factor) i_out = i_out[int(downsample_factor/2)::downsample_factor] t_out = moving_average(trace_t, n=downsample_factor) t_out = t_out[int(downsample_factor/2)::downsample_factor] sweepdata_out.append(np.asarray([t_out,v_out,i_out])) sweep_dict = dict((ephys_patch.SweepMetadata()*ephys_patch.Sweep()&key_sweep).fetch1()) for keynow in sweep_dict.keys(): if type(sweep_dict[keynow]) == decimal.Decimal:
'cell_number', 'movie_number', 'motion_correction_method', 'roi_type', 'roi_number', as_dict=True) for roi in gtrois: session_time = (experiment.Session() & roi).fetch('session_time')[0] cell_time = (ephys_patch.Cell() & roi).fetch('cell_recording_start')[0] movie_start_time = float( (imaging.Movie() & roi).fetch1('movie_start_time')) movie_start_time = session_time.total_seconds( ) + movie_start_time - cell_time.total_seconds() sweeps = (imaging_gt.ROIEphysCorrelation() & roi).fetch('sweep_number') sweep_now = ephys_patch.Sweep() & roi & 'sweep_number = ' + str(sweeps[0]) trace, sr = ((ephys_patch.SweepResponse() * ephys_patch.SweepMetadata()) & sweep_now).fetch1('response_trace', 'sample_rate') sweep_start_time = float(sweep_now.fetch1('sweep_start_time')) trace_time = np.arange(len(trace)) / sr + sweep_start_time neededidx = (trace_time > movie_start_time - window) & (trace_time < movie_start_time) fig = plt.figure() ax = fig.add_axes([0, 0, .8, .8]) ax.plot(trace_time[neededidx], trace[neededidx]) print(roi) #fig.show() # ============================================================================= # print(key_cell)