def load_from_filterframework(animal, datatype, filterframework_dir, index_keys=[]): if type(index_keys) != list: index_keys = [ index_keys, ] animal_dict = {} animal_dict[animal] = lfdp.Animal(directory=filterframework_dir, short_name=animal) if datatype == 'ntrodeInfo': out = lfdp.make_tetrode_dataframe(animal_dict) out['subarea'] = out['subarea'].astype(str) elif datatype == 'taskInfo': out = lfdp.make_epochs_dataframe(animal_dict) elif datatype == 'linearcoord' or datatype == 'task_segments': out = lfdp.make_epochs_dataframe(animal_dict) out = _get_linearcoord_tasksegments(out, animal_dict) elif datatype == 'position': if len(index_keys[0]) != 3: print('epoch_keys requred as list of (animal, day, epoch)') return position_dict_df = {} for (animal, day, epoch) in index_keys: epoch_index = (animal, day, epoch) position_dict_df[(animal, day, epoch)] = lfdp.get_position_dataframe( epoch_index, animal_dict) out = pd.concat(position_dict_df).reset_index().rename( { 'level_0': 'animal', 'level_1': 'day', 'level_2': 'epoch' }, axis=1) out['timedelta'] = pd.TimedeltaIndex(out['time'], unit='ns') out.set_index(['animal', 'day', 'epoch', 'timedelta'], inplace=True) out['is_correct'] = out.is_correct.astype('float') elif datatype == 'lfp': if len(index_keys[0]) != 4: print( 'ntrode_keys requred as list of (animal, day, epoch, ntrode)') return out = _load_lfp_from_filterframework(index_keys, animal_dict) if 'tetrode_number' in out.index.names: print('renaming "tetrode_number" to "ntrode" in multiindex') out.index.rename('ntrode', level='tetrode_number', inplace=True) return out
def get_track_segments(epoch_key, animals): ''' Parameters ---------- epoch_key : tuple animals : dict of namedtuples Returns ------- track_segments : ndarray, shape (n_segments, n_nodes, n_space) center_well_position : ndarray, shape (n_space,) ''' environment = np.asarray( make_epochs_dataframe(animals).loc[epoch_key].environment)[0] ENVIRONMENTS = {'lineartrack': 'linearTrack', 'wtrack': 'wTrack'} coordinate_path = os.path.join( animals[epoch_key[0]].directory, f'{ENVIRONMENTS[environment]}_coordinates.mat') linearcoord = loadmat(coordinate_path)['coords'][0] track_segments = [ np.stack(((arm[:-1, :, 0], arm[1:, :, 0])), axis=1) for arm in linearcoord ] track_segments = np.concatenate(track_segments) _, unique_ind = np.unique(track_segments, return_index=True, axis=0) return track_segments[np.sort(unique_ind)]
def main(): # Set the maximum number of threads for openBLAS to use. NUM_THREADS = 16 environ['OPENBLAS_NUM_THREADS'] = str(NUM_THREADS) environ['NUMBA_NUM_THREADS'] = str(NUM_THREADS) environ['OMP_NUM_THREADS'] = str(NUM_THREADS) environ['MKL_NUM_THREADS'] = str(NUM_THREADS) LOG_DIRECTORY = join(getcwd(), 'logs') makedirs(LOG_DIRECTORY, exist_ok=True) python_function = 'run_by_epoch.py' directives = ' '.join( ['-l h_rt=36:00:00', f'-pe omp {NUM_THREADS}', '-P braincom', '-notify', '-l mem_total=125G', '-v OPENBLAS_NUM_THREADS', '-v NUMBA_NUM_THREADS', '-v OMP_NUM_THREADS', '-v MKL_NUM_THREADS']) args = get_command_line_arguments() if args.Animal is None and args.Day is None and args.Epoch is None: epoch_info = make_epochs_dataframe(ANIMALS) neuron_info = make_neuron_dataframe(ANIMALS) n_neurons = (neuron_info .groupby(['animal', 'day', 'epoch']) .neuron_id .agg(len) .rename('n_neurons') .to_frame()) epoch_info = epoch_info.join(n_neurons) is_w_track = (epoch_info.environment .isin(['TrackA', 'TrackB', 'WTrackA', 'WTrackB'])) epoch_keys = epoch_info[is_w_track & (epoch_info.n_neurons > 20)].index else: epoch_keys = [(args.Animal, args.Day, args.Epoch)] for animal, day, epoch in epoch_keys: print(f'Animal: {animal}, Day: {day}, Epoch: {epoch}') log_file = f'{animal}_{day:02d}_{epoch:02d}.log' function_name = python_function.replace('.py', '') job_name = f'{function_name}_{animal}_{day:02d}_{epoch:02d}' python_cmd = f'{python_function} {animal} {day} {epoch}' queue_job(python_cmd, directives=directives, log_file=join(LOG_DIRECTORY, log_file), job_name=job_name)
def main(): # Set the maximum number of threads for openBLAS to use. NUM_THREADS = 16 environ['OPENBLAS_NUM_THREADS'] = str(NUM_THREADS) environ['NUMBA_NUM_THREADS'] = str(NUM_THREADS) environ['OMP_NUM_THREADS'] = str(NUM_THREADS) log_directory = join(getcwd(), 'logs') makedirs(log_directory, exist_ok=True) python_function = 'run_by_epoch.py' directives = ' '.join( ['-l h_rt=1:00:00', '-pe omp {0}'.format(NUM_THREADS), '-P braincom', '-notify', '-l mem_total=125G', '-v OPENBLAS_NUM_THREADS', '-v NUMBA_NUM_THREADS', '-v OMP_NUM_THREADS']) args = get_command_line_arguments() if args.Animal is None and args.Day is None and args.Epoch is None: epoch_info = make_epochs_dataframe(ANIMALS) epoch_keys = epoch_info[(epoch_info.type == 'run') & ( epoch_info.environment != 'lin')].index else: epoch_keys = [(args.Animal, args.Day, args.Epoch)] for (animal, day, epoch_ind) in epoch_keys: print('Animal: {0}, Day: {1}, Epoch: {2}'.format( animal, day, epoch_ind)) log_file = '{animal}_{day:02d}_{epoch:02d}.log'.format( animal=animal, day=day, epoch=epoch_ind) job_name = ( '{function_name}_{animal}_{day:02d}_{epoch:02d}').format( animal=animal, day=day, epoch=epoch_ind, function_name=python_function.replace('.py', '')) python_cmd = '{python_function} {animal} {day} {epoch}'.format( python_function=python_function, animal=animal, day=day, epoch=epoch_ind) queue_job(python_cmd, directives=directives, log_file=join(log_directory, log_file), job_name=job_name)
def get_position_occupancy(epoch_key, animals, extent=(0, 300, 0, 300), gridsize=(30, 30)): position_info = get_interpolated_position_dataframe( epoch_key, animals, max_distance_from_well=5) occupancy = plt.hexbin(position_info.x_position, position_info.y_position, extent=extent, gridsize=gridsize) occupancy_count = pd.DataFrame({ 'occupancy_count': occupancy.get_array(), 'center_x': occupancy.get_offsets()[:, 0], 'center_y': occupancy.get_offsets()[:, 1], 'environment': str(make_epochs_dataframe(animals).xs(epoch_key).environment) }) (occupancy_count['animal'], occupancy_count['day'], occupancy_count['epoch']) = epoch_key return occupancy_count
""" import matplotlib.pyplot as plt import numpy as np import pandas as pd import scipy.signal as scis from loren_frank_data_processing import (get_interpolated_position_dataframe, get_LFP_dataframe, get_spike_indicator_dataframe, make_epochs_dataframe, make_neuron_dataframe, make_tetrode_dataframe) from src.parameters import ANIMALS epoch_info = make_epochs_dataframe(ANIMALS) epoch_key = ('HPa', 3, 2) tetrode_info = make_tetrode_dataframe(ANIMALS).xs(epoch_key, drop_level=False) tetrode_key = ('HPa', 3, 2, 4) neuron_info = make_neuron_dataframe(ANIMALS).xs(epoch_key, drop_level=False) neuron_key = ('HPa', 3, 2, 4, 3) spike = get_spike_indicator_dataframe(neuron_key, ANIMALS) position_info = get_interpolated_position_dataframe(epoch_key, ANIMALS) linear_distance = position_info['linear_distance'] x_pos = position_info['x_position'] y_pos = position_info['y_position'] speed = position_info['speed'] head_direction = position_info['head_direction']
def load_data( epoch_key, position_to_linearize=['nose_x', 'nose_y'], max_distance_from_well=30, min_distance_traveled=50, ): logger.info('Loading position info...') environment = np.asarray( make_epochs_dataframe(ANIMALS).loc[epoch_key].environment)[0] if environment == "lineartrack": edge_order, edge_spacing = LINEAR_EDGE_ORDER, LINEAR_EDGE_SPACING elif environment == "wtrack": edge_order, edge_spacing = WTRACK_EDGE_ORDER, WTRACK_EDGE_SPACING else: edge_order, edge_spacing = None, None position_info = get_interpolated_position_info( epoch_key, position_to_linearize=position_to_linearize, max_distance_from_well=max_distance_from_well, min_distance_traveled=min_distance_traveled, edge_order=edge_order, edge_spacing=edge_spacing, ).dropna(subset=["linear_position"]) tetrode_info = make_tetrode_dataframe(ANIMALS, epoch_key=epoch_key) tetrode_keys = tetrode_info.loc[tetrode_info.area.isin(['ca1R', 'ca1L'])].index logger.info('Loading multiunit...') def _time_function(*args, **kwargs): return position_info.index adhoc_multiunit = get_adhoc_multiunit(position_info, tetrode_keys, _time_function, position_to_linearize) logger.info('Loading spikes...') time = position_info.index try: neuron_info = make_neuron_dataframe( ANIMALS, exclude_animals=['Monty', 'Peanut']).xs(epoch_key, drop_level=False) neuron_info = neuron_info.loc[neuron_info.accepted.astype(bool)] spikes = get_all_spike_indicators(neuron_info.index, ANIMALS, _time_function).reindex(time) except (ValueError, KeyError): neuron_info = None spikes = None logger.info('Finding ripple times...') adhoc_ripple = get_adhoc_ripple(epoch_key, tetrode_info, time, position_to_linearize) track_graph = make_track_graph(epoch_key, ANIMALS) dio = get_DIO(epoch_key, ANIMALS) dio_indicator = get_DIO_indicator(epoch_key, ANIMALS, time_function=_time_function) return { 'position_info': position_info, 'tetrode_info': tetrode_info, 'neuron_info': neuron_info, 'spikes': spikes, 'dio': dio, 'dio_indicator': dio_indicator, 'track_graph': track_graph, 'edge_order': edge_order, 'edge_spacing': edge_spacing, **adhoc_ripple, **adhoc_multiunit, }