Two place cell related additions

- Function for detecting place cells
- Function for quantifying place cell reliability

Author: wmau

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.pythonPath": "C:\\Users\\wm228\\Anaconda3\\envs\\ca_imaging\\python.exe"
+}

CircleTrack/MiniscopeFunctions.py

@@ -26,7 +26,6 @@
     find_members,
 )
 
-
 hv.extension("bokeh")
 from bokeh.plotting import show
 from itertools import product
@@ -41,9 +40,11 @@ def __init__(
         spatial_bin_size_radians=0.05,
         S_std_thresh=1,
         velocity_threshold=7,
+        place_cell_alpha=0.001,
+        place_cell_transient_threshold=40,
         overwrite_synced_data=False,
         overwrite_placefields=False,
-        overwrite_placefield_trials=False,
+        overwrite_placefield_trials=True,
         overwrite_assemblies=False,
         local=True,
     ):
@@ -196,6 +197,11 @@ def __init__(
             with open(fpath, "wb") as file:
                 pkl.dump(self.assemblies, file)
 
+        self.spatial.data['place_cells'] = self.get_place_cells(alpha=place_cell_alpha,
+                                                                transient_threshold=place_cell_transient_threshold)
+        self.spatial.meta['place_cell_pval'] = place_cell_alpha
+        self.spatial.meta['place_cell_transient_threshold'] = place_cell_transient_threshold
+
     def get_pkl_path(self, fname):
         if self.meta["local"]:
             local_path = get_equivalent_local_path(self.meta["folder"])
@@ -367,7 +373,8 @@ def spatial_activity_by_trial(self):
 
             # Get occupancy this trial.
             occupancy = spatial_bin(
-                positions_this_trial, filler, bins=bin_edges, one_dim=True
+                positions_this_trial, filler, bins=bin_edges, one_dim=True,
+                weights=running_this_trial.astype(int)
             )[0]
 
             # Weight position by activity of each neuron.
@@ -386,6 +393,68 @@ def spatial_activity_by_trial(self):
 
         return fields, occ_map_by_trial
 
+    def get_place_cells(self, alpha=0.001, transient_threshold=40):
+        n_transients = np.sum(np.sum(self.spatial.data['rasters'], axis=1), axis=1)
+        place_cells = np.where(np.logical_and(self.spatial.data['spatial_info_pvals'] < alpha,
+                               n_transients> transient_threshold))[0]
+
+        return place_cells
+
+    def placefield_reliability(self, neuron, field_threshold=0.15, even_split=True, split=4,
+                               show_plot=True):
+        """
+        Compute the trial-by-trial in-field consistency of a neuron (whether it fired in field).
+
+        :parameters
+        ---
+        neuron: int
+            Neuron number.
+
+        field_threshold: float
+            Percentage of field peak to be considered part of the field.
+
+        even_split: bool
+            Flag to split trials evenly into n parts (defined by the argument split). If False,
+            instead split is the number of trials in each split.
+
+        split: int
+            If even_split, the number of parts to divide the trial into.
+            If not even_split, the number of trials in each split.
+
+        """
+        raster = self.spatial.data['rasters'][neuron]
+        placefield = self.spatial.data['placefields_normalized'][neuron]
+
+        field_bins = np.where(placefield > max(placefield) * field_threshold)[0]
+        fired_in_field = np.any(raster[:, field_bins], axis=1)
+
+        if not even_split:
+            split = np.arange(split, len(fired_in_field), split)
+
+        split_fired_in_field = np.array_split(fired_in_field, split)
+
+        # Handles cases where you don't actually want to split the reliability across trials.
+        if split == 1 and even_split:
+            reliability = np.sum(split_fired_in_field[0])/len(split_fired_in_field[0])
+        else:
+            reliability = [np.sum(fired_in_field) / len(fired_in_field) for fired_in_field in split_fired_in_field]
+
+        if show_plot and even_split:
+            fig, axs = plt.subplots(1,2)
+            axs[0].imshow(raster > 0, aspect='auto')
+            axs[0].set_xlabel('Position')
+            axs[0].set_ylabel('Trials')
+
+            axs[1].plot(reliability, range(len(reliability)))
+            axs[1].set_xlim([0, 1])
+            axs[1].invert_yaxis()
+            axs[1].set_ylabel(f'Trial block #, {len(split_fired_in_field[0])} trials per block')
+            axs[1].set_xlabel('Proportion of trials with '
+                              '\n in-field calcium transient')
+            fig.tight_layout()
+
+        return reliability
+
     def viz_spatial_trial_activity(self, neurons=range(10), preserve_neuron_idx=True):
         """
         Visualize single cell activity binned in spatial and separated

CircleTrack/scripts.py

@@ -1775,7 +1775,7 @@ def spiralplot_matched_ensembles(
                 ]
 
                 # Make a figure with 2 subplots, one for each session.
-                fig, axs = plt.subplots(2, 1, subplot_kw=dict(polar=True))
+                fig, axs = plt.subplots(2, 1, subplot_kw=dict(polar=True), figsize=(6.4, 10))
                 for ax, activation, t_, lin_pos, assembly_number, session_type in zip(
                     axs,
                     activations,