def list_trials_by_type(self, session=None, include_trials='hits', **kwargs): idx = np.nonzero(self.session_names == session)[0].item() tdf = pandas.load(self.tdf_list[idx]) if include_trials == 'hits': tdf = tdf[(tdf.outcome == 1) & (tdf.nonrandom == 0)] elif include_trials == 'non-hits': tdf = tdf[(tdf.outcome != 1) & (tdf.nonrandom == 0)] elif include_trials == 'all random': tdf = tdf[tdf.nonrandom == 0] else: raise "only hits, non-hits, and all random supported for now" replace_stim_numbers_with_names(tdf) mask = myutils.pick_mask(tdf, **kwargs) return np.asarray(tdf.index[mask], dtype=np.int)
def get_binned_spikes3(self, spike_filter=None, trial_filter=None): """Generic binning function operating on self._fsd spike_filter : dataframe describing how to split fsd The columns are the hierarchy to split on: eg ['session', 'unit'] The items are the ones to include. If no items, then everything is included. If None, then bin over everything except 'adj_time' or 'spike_time' Here we delineate every combination because it's not separable over session and unit (usually). trial_filter : How to do this filtering? For instance: hits only, stim_numbers 1-12, expressed as dicts In this case I wouldn't want to enumerate every combination because I can just take intersection over stim numbers and outcome. Although note we might want to combine errors and wrongports, for instance. It's implicit that we want to do this for each session in spike_filter. First the spikes are grouped over the columns in spike_filter. For each group, the trials are grouped over the columns in trial_filter. This cross-result is histogrammed. All results are concatenated and returned. The actual histogramming is done by myutils.times2bins using self.f_samp, t_start, t_stop, bins """ input = self._fsd # default, use all columns and include all data if spike_filter is None: col_list = input.columns.tolist() remove_cols = ['adj_time', 'spike_time'] for col in remove_cols: if col in col_list: col_list.remove(col) spike_filter = pandas.DataFrame(columns=col_list) # Choose data from `input` by defining the following variables: # `keylist` : a list of keys to include, each separately binned # `grouped_data` : a dict from each key in keylist, to the data # `keynames` : what to call each entry of the key in the result if len(spike_filter) == 0: # use all data keynames = spike_filter.columns.tolist() keylist = [tuple([myutils.only_one(input[col]) for col in keynames])] val = input grouped_data = {keylist[0]: val} elif len(spike_filter) == 1: # Optimized for the case of selecting a single unit d = {} for col in spike_filter: d[col] = spike_filter[col][0] mask = myutils.pick_mask(input, **d) keylist = spike_filter.to_records(index=False) # length 1 keynames = spike_filter.columns.tolist() grouped_data = {keylist[0] : input.ix[mask]} else: # standard case g = input.groupby(spike_filter.columns.tolist()) grouped_data = g.groups keylist = spike_filter.to_records(index=False) keynames = spike_filter.columns.tolist() # Now group the trials att = self.all_trials.reset_index().set_index(['session', 'trial'], drop=False) g2 = att.groupby(trial_filter.columns.tolist()) #g2 = self.all_trials.groupby(trial_filter.columns.tolist()) # Now iterate through the keys in keylist and the corresponding values # in grouped_data. rec_l = [] for key in keylist: # Take the data from this group subdf = grouped_data[key] for g2k, g2v in g2: # count trials of this type from this session session = myutils.only_one(subdf.session) n_trials = len(g2v.ix[session]) if n_trials == 0: # for example if a possible combination never actually # occurred continue # Join the spikes on the columns of trial filter subsubdf = subdf.join(g2v[trial_filter.columns], on=['session', 'trial'], how='inner', rsuffix='rrr') # check for already-joined columns for col in trial_filter.columns: if col+'rrr' in subsubdf.columns: assert (subsubdf[col] == subsubdf[col+'rrr']).all() subsubdf.pop(col + 'rrr') # histogramming counts, t_vals = myutils.times2bins( np.asarray(subsubdf.adj_time), return_t=True, f_samp=self.f_samp, t_start=self.t_start, t_stop=self.t_stop, bins=self.bins) # Add in the keyed info (session etc), plus # n_counts, n_trials, and bin frame_label = list(key) + list(np.array([g2k]).flatten()) this_frame = [frame_label + [count, n_trials, t_val, bin] for bin, (count, t_val) in enumerate(zip(counts, t_vals))] # append to growing list rec_l += this_frame # convert to new data frame, using same keyed columns plus our new ones cols = keynames + trial_filter.columns.tolist() + [ 'counts', 'trials', 'time', 'bin'] newdf = pandas.DataFrame(rec_l, columns=cols) # drop the combinations that never actually occurred (future trials) return newdf