def load_align_data(args, options, config):
# Load raw data and calculate behaviours
behaviour_data = behaviour.get_behaviour(
args.dlc_files,
config.meters_per_pixel,
config.camera_frames_per_sec,
options,
)
num_behaviour_measurements = len(behaviour_data.index)
# Load spiking data
spike_data = spikes.get_spikes(
args.spike_time_file,
args.spike_clusters_file,
args.cluster_groups_file,
args.sync_param_file,
num_behaviour_measurements,
config.camera_frames_per_sec,
config.probe_samples_per_sec,
)
# Align spiking data and behavioural data to a single dataframe
total_df = combine.make_combined_df(spike_data, behaviour_data)
# Remove any frames based on global conditions
total_df = clean.clean_df(total_df, speed_cutoff=options.speed_cut_off)
# Align data with externally supplied conditions
total_df = condition_select.add_conditions(total_df, config)
return total_df
def __init__(self, cell_specific_data, df, place, cell_name, options,
config):
df = clean_df(df, speed_cutoff=options.place_speed_cut_off, copy=True)
idx = get_idx(cell_specific_data, cell_name)
self._smoothing = options.place_firing_smooth_width
self._min_time_in_spatial_bin = options.min_time_in_spatial_bin
self.place_peak_magnitude = []
self.peak_percentile = []
self.place_firing = cell_specific_data.place_cell_spikes_freq[idx]
self.get_peak_firing_magnitude()
if options.place_shuffle_test:
self.get_place_cell_sig(
df,
place,
cell_name,
options,
config,
min_shuffle_dist_time=options.place_shuffle_min_magnitude,
max_shuffle_dist_time=options.place_shuffle_max_magnitude,
num_iterations=options.place_shuffle_iterations,
camera_frames_per_sec=config.camera_frames_per_sec,
num_processes=options.num_processes,
parallel=options.parallel,
)
def calc_hd(self, df, hd, options):
df = clean_df(df, speed_cutoff=options.hd_speed_cut_off, copy=True)
self.get_firing_directions(df)
self.get_direction_firing_rates_bins(
hd, smooth_width=options.hd_smooth_sigma
)
self.direction_firing_kde(kappa=options.hd_kde_kappa)
self.kde_normalise(hd.time_spent_each_head_angle_kde)
def __init__(self, cell_specific_data, df, hd_behaviour, cell_name,
options, config):
df = clean_df(df, speed_cutoff=options.hd_speed_cut_off, copy=True)
self.mean_vec_percentile = []
self.hd_stability_percentile = []
self.rayleigh_test_p = []
self.rayleigh_test_z = []
self.omnibus_test_p = []
self.omnibus_test_m = []
self.mean_vec_length = []
self.mean_direction = []
self.hd_background_hz = []
self.hd_peak_hz = []
self.hd_preferred_firing_angle = []
self.hd_snr = []
self.stability_index = []
self.cell_name = cell_name
idx = get_idx(cell_specific_data, cell_name)
bins, spikes_per_bin = self.get_angles(cell_specific_data, idx)
head_angle_sampling = hd_behaviour.time_spent_each_head_angle_hist
bin_spacing_rad = np.deg2rad(options.direction_bin)
self.descriptive(bins, spikes_per_bin, bin_spacing_rad)
self.firing(
cell_specific_data,
idx,
df,
options,
config,
calc_hd_peak_method=options.calc_hd_peak_method,
smooth_width=options.calc_hd_hist_smooth_width,
baseline_bin=options.direction_baseline_bin,
bin_size=options.direction_bin,
)
self.directionality(bins, spikes_per_bin)
self.calc_stability_index(
df,
cell_name,
config.camera_frames_per_sec,
bin_width=options.direction_bin,
smooth_width=options.hd_smooth_sigma,
)
if options.hd_shuffle_test:
self.hd_shuffled_stats(
df,
cell_name,
head_angle_sampling,
min_shuffle_dist_time=options.hd_shuffle_min_magnitude,
max_shuffle_dist_time=options.hd_shuffle_max_magnitude,
num_iterations=options.hd_shuffle_iterations,
bin_spacing=bin_spacing_rad,
camera_frames_per_sec=config.camera_frames_per_sec,
num_processes=options.num_processes,
parallel=options.parallel,
smooth_width=options.hd_smooth_sigma,
)
def __init__(self, cell_specific_data, df, cell_name, options, config):
df = clean_df(df, speed_cutoff=options.ahv_speed_cut_off, copy=True)
self.cell_name = cell_name
self.ahv_baseline_hz = []
self.ahv_peak_hz = []
self.ahv_pearson_r_neg = []
self.ahv_pearson_p_neg = []
self.ahv_pearson_r_pos = []
self.ahv_pearson_p_pos = []
self.ahv_fit_intercept_neg = []
self.ahv_fit_intercept_pos = []
self.ahv_fit_slope_neg = []
self.ahv_fit_slope_pos = []
self.pearson_neg_percentile = []
self.pearson_pos_percentile = []
self.ahv_stability_index = []
self.ahv_r_percentile_first_half_neg = []
self.ahv_r_percentile_first_half_pos = []
self.ahv_r_percentile_second_half_neg = []
self.ahv_r_percentile_second_half_pos = []
self.ahv_pearson_r_first_half_neg = []
self.ahv_pearson_r_first_half_pos = []
self.ahv_pearson_r_second_half_neg = []
self.ahv_pearson_r_second_half_pos = []
self.ahv_null_correlation_percentile = []
self.__shuffled_binned_data = []
idx = get_idx(cell_specific_data, cell_name)
cw_ccw_firing = GetCWandCCW(cell_specific_data, idx)
self.firing(df, cw_ccw_firing, options, config)
self.get_correlation(cw_ccw_firing)
self.get_fit(cw_ccw_firing)
if options.ahv_shuffle_test:
self.get_ahv_cell_sig(
cell_specific_data,
df,
cell_name,
min_shuffle_dist_time=options.ahv_shuffle_min_magnitude,
max_shuffle_dist_time=options.ahv_shuffle_max_magnitude,
num_iterations=options.ahv_shuffle_iterations,
camera_frames_per_sec=config.camera_frames_per_sec,
num_processes=options.num_processes,
correlation_mag_force=options.ahv_correlation_magnitude,
parallel=options.parallel,
)
def __init__(self, df, options, camera_frames_per_sec):
df = clean_df(df,
speed_cutoff=options.velocity_speed_cut_off,
copy=True)
self.velocity = df["total_speed"]
self.camera_frames_per_sec = camera_frames_per_sec
self.bin_size = options.velocity_bin_size
self.bins = []
self.velocity_hist_seconds = []
self.velocity_hist_centers = []
self.min_velocity = 0
self.max_velocity = options.max_velocity
self.velocity_hist()
def __init__(self, df, options, config):
df = clean_df(df, speed_cutoff=options.place_speed_cut_off, copy=True)
self.x = []
self.y = []
self.x_max = config.camera_x
self.y_max = config.camera_y
self.x_bins = []
self.y_bins = []
self.x_bin_centers = []
self.y_bin_centers = []
self.place_hist_seconds = []
self.camera_frames_per_sec = config.camera_frames_per_sec
self.bin_size = options.spatial_bin_size
self.x, self.y = get_positions(
df, use_head_as_position=options.spatial_position_head)
self.convert_positions_to_m(config.meters_per_pixel)
self.get_bins()
self.place_hist()
def __init__(self, df, options, camera_frames_per_sec):
df = clean_df(df, speed_cutoff=options.hd_speed_cut_off, copy=True)
self.camera_frames_per_sec = camera_frames_per_sec
self.bin_size = options.direction_bin
self.kde_kappa = options.hd_kde_kappa
self.time_spent_each_head_angle_hist = []
self.hd_bin_centers_hist = []
self.time_spent_each_head_angle_kde = []
self.hd_bin_centers_kde = []
self.angles = column_as_array(df, "absolute_head_angle")
# todo: combine bin centers (standardise to a range) ???
# i.e. combine kde and hist bin numbers?
self.hd_hist(
bin_size=options.direction_bin,
smooth_width=options.hd_smooth_sigma,
)
self.hd_kde(kappa=self.kde_kappa)
def __init__(self,
df,
options,
camera_frames_per_sec,
border_choice="max"):
df = clean_df(df, speed_cutoff=options.ahv_speed_cut_off, copy=True)
self.ang_vel = df["angular_head_velocity"]
self.camera_frames_per_sec = camera_frames_per_sec
self.bin_size = options.ang_vel_bin_size
self.central_ahv_fraction = options.central_ahv_fraction
self.border_choice = border_choice
self.max_ahv = options.max_ahv
self.min_ahv = []
self.bins = []
self.ahv_hist_seconds = []
self.ahv_hist_centers = []
self.retained_ahv_timepoint_fraction = []
self.dp = 2 # decimal points for reporting values
self.ahv_hist()
self.calculate_ahc_cutoffs()
self.calculate_retained_timepoints()
def __init__(self, cell_specific_data, df, cell_name, options, config):
df = clean_df(df,
speed_cutoff=options.velocity_speed_cut_off,
copy=True)
self.velocity_pearson_r = []
self.velocity_pearson_p = []
self.pearson_percentile = []
self.velocity_fit_intercept = []
self.velocity_fit_slope = []
self.velocity_stability_index = []
self.velocity_r_percentile_first_half = []
self.velocity_r_percentile_second_half = []
self.velocity_pearson_r_first_half = []
self.velocity_pearson_r_second_half = []
self.velocity_null_correlation_percentile = []
self.__shuffled_binned_data = []
idx = get_idx(cell_specific_data, cell_name)
self.get_correlations(idx, cell_specific_data)
self.get_fit(idx, cell_specific_data)
if options.velocity_shuffle_test:
self.get_velocity_cell_sig(
cell_specific_data,
df,
cell_name,
min_shuffle_dist_time=options.velocity_shuffle_min_magnitude,
max_shuffle_dist_time=options.velocity_shuffle_max_magnitude,
num_iterations=options.velocity_shuffle_iterations,
camera_frames_per_sec=config.camera_frames_per_sec,
num_processes=options.num_processes,
parallel=options.parallel,
correlation_mag_force=options.velocity_correlation_magnitude,
)
def calc_place(self, df, place, options):
df = clean_df(df, speed_cutoff=options.place_speed_cut_off, copy=True)
self.get_place_firing_bins(
df, place, min_time_in_spatial_bin=options.min_time_in_spatial_bin
)
def calc_velocity(self, df, velocity, options):
df = clean_df(
df, speed_cutoff=options.velocity_speed_cut_off, copy=True
)
self.get_velocity_firing_rates_bins(df, velocity)
def calc_ahv(self, df, ahv, options):
df = clean_df(df, speed_cutoff=options.ahv_speed_cut_off, copy=True)
self.get_ahv_firing_rates_bins(df, ahv)
