def load_stim(rec): try: # data already loaded? stim = rec.stim except :# load data infofile = os.path.join(rec.i.stim_path,'stim_info.inf') info = D.Info(filename=infofile,translation=translation) # load and parse meta data filename_prefix = info.get('filename_prefix','.+\.s') # load all stimuli if no prefix given infofiles = U.parse_dir(rec.i.stim_path,prefix=filename_prefix,suffix='inf') infofile = os.path.join(rec.i.stim_path,infofiles[rec.i.cond_id]) moreinfo = D.Info(filename=infofile,translation=translation) info.update(moreinfo) # # this is incomplete; the parser has to deal with vision egg files # and extract i.t_trial, i.t_start, i.start_times # # start_times = frm.select(rec.info["frm_ind"],rec.info["frm_skip"]) # if hasattr(rec.info,"t_trial"): # if len(start_times) > 1: # rec.info["t_trial"] = round(N.diff(start_times)[0]) # rec.info["t_start"] = start_times[0] # rec.info["start_times"] = start_times # load raw stimulus data fn_stim = os.path.join(rec.i.stim_path,info.frm_filename) stim = D.Stimulus(DL.load_events(fn_stim,dtype_t=info.timestamp_datatype, dtype_v=info.value_datatype)) # convert data into SI units if hasattr(info,'units'): DL.raw_to_SI(stim,scalefactor=info.units_multiplier,offset=0) else: info.units = 'raw' # cut din if (hasattr(rec.i,'t_start') & hasattr(rec.i,'t_stop')): stim = stim[D.Epochs((rec.i.t_start,rec.i.t_stop))] stim.i.update(info) stim.i.id = rec.i.cond_id # in case of movies with identical repeats: change frame index if hasattr(stim.i,'nrepeats'): if stim.i.nrepeats != stim.i.nruns: max_frm = stim.i.nsweeps/stim.i.nrepeats stim.v = N.mod(stim.v,max_frm) else: stim.i.nrepeats = stim.i.nruns # compute framerate if stim.i.has_key('sweeptimeMsec'): # temporary - all exported times should be in s stim.i.framerate = 1000./stim.i.sweeptimeMsec else: stim.i.framerate = 1./stim.i.sweeptimeSec rec.stim = stim return stim
def load_m(rec): import re params = D.Info() fn = os.path.join(rec.i.rec_path,rec.i.rec_id+'.m') matchstr = re.compile(r"""\s*(\w+)\s*=\s*([\d\.-]+)\s*;""",re.VERBOSE) fil = open(fn,'r') for key,value in matchstr.findall(fil.read()): if int(float(value))==float(value): params[key] = int(value) else: params[key] = float(value) params.is_movie = ('startfilen' in params.keys()) params.is_discs = ('out_diameter' in params.keys()) params.year = int('20'+rec.i.cell_id[:2]) if params.is_movie: params.in_terms = params.endfilen-params.startfilen+1 params.out_terms = params.preterm params.f_rate = get_framerate(params.refreshrate,params.frmperterm) params.lost_time = float(1./params.f_rate) params.trial_terms = params.in_terms+params.out_terms params.start_terms = params.out_terms params.t_trial = float(params.trial_terms)/params.f_rate params.t_start = float(params.start_terms)/params.f_rate if params.is_discs: params.in_terms = params.sigtime params.out_terms = params.pretime params.lost_time = float(params.out_terms) params.t_trial = float(params.in_terms+2*params.out_terms) params.t_start = float(params.out_terms) return params
def __init__(self, celldate=None, cellid=None, ch_ret=None): self.i = D.Info() self.i.celldate = celldate self.i.cellid = cellid self.i.ch_ret = ch_ret self.i.t_frame = 0.007139184 # set path variables self.i.data_path = os.path.join(datapath) self.i.rec_path = os.path.join(self.i.data_path, 'OpticTractData', celldate) self.i.rec_filenames = U.parse_dir(self.i.rec_path, suffix='mat', key_type=str) self.i.movie_path = os.path.join(self.i.data_path, 'stimulus') # find recording id rec_ids = filter(lambda k: cellid in k, self.i.rec_filenames.keys()) if len(rec_ids) != 1: print '%d recordings found' % len(rec_ids) self.i.rec_id = None else: self.i.rec_id = rec_ids[0] # create empty containers for spikes, lfps, etc. # self.spks=D.Container() # dict contains spike timings # self.frm=D.Container() # dict contains auditory stimuli if self.i.rec_id != None: self.load()
def load_movie(rec, filename=None, varname=None): # load m-sequence movie try: # data already loaded? movie = rec.movie except: # load data import scipy.io as io fn_movie = os.path.join(rec.i.movie_path, filename) mat = io.loadmat(fn_movie) # self.mat = mat info = D.Info() for key in ['__header__', '__version__']: info[key] = mat[key] movie = D.Image(mat[varname]) nframes = movie.shape[0] if len(movie.shape) == 2: nx = int(N.sqrt(movie.shape[1])) movie = N.reshape(movie, (nframes, nx, nx)) nframes, nx, ny = movie.shape # update movie info movie.i.update(info) movie.i.nx = nx movie.i.ny = ny movie.i.nframes = nframes movie.i.filename = fn_movie rec.movie = movie return movie
def load_lfp(rec,id_lfp=None): try: filenames = rec.lfp.filenames info = rec.lfp.i except: # parse directory infofile = os.path.join(rec.i.lfp_path,'lfp_info.inf') info = D.Info(filename=infofile,translation=translation) # default parameters params = dict(filename_prefix=None,filename_suffix='lfp') params.update(info) # get filenames filenames = U.parse_dir(rec.i.lfp_path, prefix=params['filename_prefix'], suffix=params['filename_suffix']) rec.lfp.filenames = filenames rec.lfp.i = info if id_lfp != None: try: # data already loaded? lfp = rec.lfp[id_lfp] except: # load data fn_lfp = os.path.join(rec.i.lfp_path,filenames[id_lfp]) # load raw data lfp = DL.load_time_series(fn_lfp,samplingrate=info.samplingrate, dtype=info.datatype, nsamples=info['nsamples']) # convert data into SI units if hasattr(info,'units'): zero = 2**(info.resolution-1) lfp_key = re.sub('\.\w+$','',filenames[id_lfp]) if isinstance(info.units_multiplier,dict): units_multiplier = info.units_multiplier[lfp_key] else: units_multiplier = info.units_multiplier DL.raw_to_SI(lfp,scalefactor=units_multiplier,offset=zero) else: info.units = 'raw' # cut lfp if (hasattr(rec.i,'t_start') & hasattr(rec.i,'t_stop')): lfp = lfp[D.Epochs((rec.i.t_start,rec.i.t_stop))] lfp.i.update(info) lfp.i.id_lfp=id_lfp if info.units != 'raw': lfp.i.units_multiplier = units_multiplier rec.lfp[id_lfp] = lfp return lfp else: # load all of them id_lfp = filenames.keys() for i in id_lfp: rec.load_lfp(i)
def routes(): import data p = paths() endpoints = data.Endpoints() id_delete = data.IDDelete() id_files = data.IDFiles() id_results = data.IDResults() ids = data.IDs() info = data.Info() logs = data.Logs() funcs = [endpoints, id_delete, id_files, id_results, ids, info, logs] return dict(zip(p, funcs))
def __init__(self,cat_id,track_id,rec_id,cond_id=0): info = D.Info() info.cond_id = cond_id # stimulus condition info.cat_id = cat_id info.track_id = track_id info.rec_id = rec_id info.cond_id = cond_id # set path variables info.rec_path = os.path.join(datapath,'cat_%s','track_%s','rec_%s')%( cat_id,track_id,rec_id) info.rec_name = 'cat_%s-track_%s-rec_%s-%d'%( cat_id,track_id,rec_id,cond_id) #unique name info.infofile = os.path.join(info.rec_path,'rec_info.inf') info.cache_path = os.path.join(cachepath,info.rec_name) info.spk_path = os.path.join(info.rec_path,'spk_data') info.lfp_path = os.path.join(info.rec_path,'lfp_data') info.stim_path = os.path.join(info.rec_path,'stim_data') info.fig_path = os.path.join(info.rec_path,'figures') info.res_path = os.path.join(info.rec_path,'results') # parse rec_info file self.i = D.Info(filename=info.infofile,translation=translation) # add path variables self.i.update(info) if hasattr(self.i,'rec_epochs'): (self.i.t_start,self.i.t_stop) = self.i.rec_epochs[cond_id] # create empty containers for spikes, lfps, etc. self.spk=D.Container() # dict contains spike timings self.lfp=D.Container() # dict contains LFPs self.comments={} # dict contains comments during data collection # intialize cache try: U.make_dir(cachepath) except: assert 0, "could not create cache dir %s"%cachepath
def __init__(self, cellid=None): self.i = D.Info() # set path variables self.i.rec_path = os.path.join(datapath, 'birdsong', 'fieldL_data') self.i.rec_filenames = U.parse_dir(self.i.rec_path, suffix='mat', key_type=str) # create empty containers for spikes, lfps, etc. self.spks = D.Container() # dict contains spike timings self.resp = D.Container() # dict contains averaged response self.stim = D.Container() # dict contains auditory stimuli if cellid != None: self.load(cellid)
def routes(): import data endpoints = data.Endpoints() p = paths() id_files = data.Id() ids = data.Ids() info = data.Info() raw = data.Raw() results = data.Results() status = data.Status() stop = data.Stop() upload = data.Upload() tools = data.Tools() funcs = [endpoints, id_files, ids, info, raw, results, status, stop, tools, upload] return dict(zip(p, funcs))
def load_spk(rec,id_spk): try: filenames = rec.spk.filenames info = rec.spk.i except: # parse directory infofile = os.path.join(rec.i.spk_path,'spk_info.inf') info = D.Info(filename=infofile,translation=translation) # default parameters params = dict(filename_prefix=None,filename_suffix='spk') params.update(info) # get filenames filenames = U.parse_dir(rec.i.spk_path, prefix=params['filename_prefix'], suffix=params['filename_suffix']) rec.spk.i = info rec.spk.i.update(filenames) if id_spk != None: try: # data already loaded? spk = rec.spk[id_spk] except: # load data fn_spk = os.path.join(rec.i.spk_path,filenames[id_spk]) # load raw data spk = DL.load_event_timings(fn_spk,dtype=info.datatype) # convert data into SI units if hasattr(info,'units'): DL.raw_to_SI(spk,scalefactor=info.units_multiplier,offset=0) else: info.units = 'raw' # cut spk if (hasattr(rec.i,'t_start') & hasattr(rec.i,'t_stop')): spk = spk[D.Epochs((rec.i.t_start,rec.i.t_stop))] spk.i.update(info) spk.i.id = id_spk rec.spk[id_spk] = spk return spk else: # load all of them id_spk = filenames.keys() for i in id_spk: rec.load_spk(i)
def __init__(self,cell_id,rec_id,**kargs): defaultargs = dict(load_tic=True,load_tmg=True,load_sig=False,split=True, neg=False,version=0,cc=True) defaultargs.update(kargs) self.i = D.Info(defaultargs) self.i.rec_id = rec_id self.i.cell_id = cell_id self.i.rec_path = os.path.join(datapath,cell_id) try: self.i.update(load_m(self)) except: print 'coul not load m-file' if self.i.load_tic: try: load_tic(self) except: print "warning: could not stimulus time stamps" if self.i.load_tmg: try: self.load_spk() except: print "warning: could not load spk timings" if self.i.cc: try: self.load_psp() except: print "warning: could not load epsp timings" else: try: self.load_psc() except: print "warning: could not load epsc timings" if self.i.load_sig: try: self.load_sig() except: print "warning: could not load signal" if self.i.split: try: self.split_trials() except: print "warning: could not split trials"
def load(self): ''' loads spike and stimulus data ''' import scipy.io as io fn = os.path.join(self.i.rec_path, self.i.rec_filenames[self.i.rec_id]) mat = io.loadmat(fn) self.mat = mat info = D.Info() for key in ['__header__', '__version__']: info[key] = mat[key] self.i.update(info) self.i.event_ids = filter(lambda k: self.i.rec_id in k, mat.keys()) for event_id in self.i.event_ids: evt = D.Events(mat[event_id].times) evt.i.units = 's' # retina if self.i.ch_ret != None: if re.match('.*Ch%d$' % self.i.ch_ret, event_id): self.ret = evt else: if 'Cortex' in mat[event_id].title: self.ret = evt # stimulus if 'Trigger' in mat[event_id].title: self.frm = evt # fix trigger in case of m_sequence if len(self.frm) == 327669: # 10 m-sequences print 'adding trigger t0' self.frm = D.Events(N.concatenate(([0], evt)), i=evt.i) if len(self.frm) == 10: print 'inserting triggers' t_frame = self.i.t_frame self.frm = D.Events(N.concatenate( [N.arange(32767) * t_frame + ti for ti in evt]), i=evt.i) self.i.start_times = self.frm[::32767] self.i.t_trial = N.diff(self.i.start_times)[0] self.i.epochs = DL.epochs_from_onsets(self.i.start_times, self.i.t_trial)
def denoise_time_series(rec, id_lfp=None): # load stimulus in order to get framerate etc. rec.load_stim() freqs_refresh = [rec.stim.i.refreshrate] print freqs_refresh freqs_frame = [rec.stim.i.framerate,2*rec.stim.i.framerate,3*rec.stim.i.framerate] print freqs_frame noise = D.Info(freqs_line=[60,120,180,240,300,360],sf_line=.075, freqs_refresh=freqs_refresh,sf_refresh=.01, freqs_frame=freqs_frame,sf_frame=.025) if id_lfp==None: ids = rec.lfp.keys() # denoise all lfp channels else: ids = [id_lfp] for id_lfp in ids: rec.lfp[id_lfp] = DSP.denoise_time_series(rec.lfp[id_lfp],**noise) if id_lfp != None: return rec.lfp[id_lfp]
def load(self): ''' loads spike and stimulus data ''' import scipy.io as io fn = os.path.join(self.i.rec_path, self.i.rec_filenames[self.i.rec_id]) mat = io.loadmat(fn) # self.mat = mat info = D.Info() for key in ['__header__', '__version__']: info[key] = mat[key] self.i.update(info) self.i.event_ids = filter(lambda k: self.i.rec_id in k, mat.keys()) for event_id in self.i.event_ids: evt = D.Events(mat[event_id].times) evt.i.units = 's' # lgn if self.i.ch_lgn != None: if re.match('.*Ch%d$' % self.i.ch_lgn, event_id): self.lgn = evt else: if 'LGN' in mat[event_id].title: self.lgn = evt # retina if self.i.ch_ret != None: if re.match('.*Ch%d$' % self.i.ch_ret, event_id): self.ret = evt else: if 'Cortex' in mat[event_id].title: self.ret = evt # stimulus if 'Trigger' in mat[event_id].title: self.frm = evt
def load(self, cellid=None): ''' loads stimulus timing data Input: id_spk - an id that identifies the spike recording ''' import scipy.io as io fn_stim = os.path.join(self.i.rec_path, self.i.rec_filenames[cellid]) mat = io.loadmat(fn_stim) info = D.Info() for key in ['__header__', '__version__', 'cellid']: info[key] = mat[key] self.i.update(info) self.vstim = D.TimeSeries(mat['vstim'], 32 * 10**3, info=info) i = 0 for trial in mat['est_data']: self.stim[i] = D.TimeSeries(trial.stim, 32 * 10**3, info=info) self.spks[i] = D.TimeSeries(trial.resp_raw.T, 10**3, info=info) self.resp[i] = D.TimeSeries(trial.resp, 10**3, info=info) i += 1