code for the publication

Author: EloyPB

README.md

@@ -1 +1,30 @@
-# models-and-analysis-of-theta-phase-coding
+Created by Eloy Parra Barrero; [email protected]; 2021-05-21
+
+Code for the analyses included in:
+### Neuronal sequences during theta rely on behavior-dependent spatial maps
+### (Parra-Barrero, E., Diba, K., Cheng, S., 2021)
+
+The files in the main folder define the classes used for the analyses included in the paper (and a bit more).
+The files in ./analyze run the analyses. ./analyze also contains the following folders:
+
+- parameters - contains parameter files (paper.json defines the parameters used in the paper)
+- fields - contains the info defining the manually screened place fields
+- sessions - contains files with general info / parameters specific to each experimental session
+
+#### Usage:
+1. Download the datasets hc-3 and hc-11 from crncs.org
+1. Change the paths defined in ./analyze/config.py
+1. Run individual analyses (e.g., ./analyze/run_firing_fields.py) or run a batch of analyses.
+
+For running a batch of analyses, first choose what to analyze in ./analyze/batch_config.py,
+then run ./analyze/batch_analyses.py and plot the results with ./analyze/batch_plots.py.
+batch_plots.py produces all of the summary figures of the paper.
+
+Some of the objects created for the analyses require a lot of computation, so they are saved as pickles and loaded again
+when required, unless the code or the parameters of the object or one of its dependencies has changed, in which case
+a new object is created.
+
+To discard the manually screened fields and screen them again, delete the corresponding file(s) in ./analyze/fields and
+run any code that will initialize a FiringFields instance (e.g., ./analyze/batch_analyses.py). However, this will not
+work if an old pickle of FiringFields will be loaded, so delete the pickles or introduce some dummy change in the code
+or in the parameters to trigger a new instance of FiringFields to be initialized.

analyze/batch_analyses.py

@@ -0,0 +1,63 @@
+import os
+import json
+from data_analysis.initializer import initialize
+from data_analysis.analyze.batch_config import sessions, group_names, experimental_group_name
+from data_analysis.analyze.run_tracking import run_tracking, Tracking
+from data_analysis.lfp import LFP
+from data_analysis.analyze.run_firing_fields import run_firing_fields, FiringFields
+from data_analysis.analyze.run_phase_vs_position import run_phase_vs_position, PhaseVsPosition
+from data_analysis.analyze.run_decoder import run_path_lengths, PathLengths
+from data_analysis.analyze.run_cell_coordination import run_cell_coordination, CellCoordination
+
+
+def analyze(session, group_name):
+
+    if group_name == experimental_group_name:
+        tracking = initialize((Tracking,), session, group_name)['Tracking']
+        run_tracking(tracking)
+        del tracking
+
+    # place field sizes and skews
+    firing_fields = initialize((FiringFields,), session, group_name)['FiringFields']
+    run_firing_fields(firing_fields)
+    del firing_fields
+
+    # phase precession slopes
+    phase_vs_position = initialize((PhaseVsPosition,), session, group_name)['PhaseVsPosition']
+    run_phase_vs_position(phase_vs_position)
+    del phase_vs_position
+
+    # theta trajectory lengths
+    path_lengths = initialize((PathLengths,), session, group_name)['PathLengths']
+    run_path_lengths(path_lengths)
+    del path_lengths
+
+    # variance in pairwise spike phases
+    cell_coordination = initialize((CellCoordination,), session, group_name)['CellCoordination']
+    run_cell_coordination(cell_coordination)
+    del cell_coordination
+
+
+for session in sessions:
+    # check that there are fields defined for all sessions
+    for group_name in group_names:
+        if not os.path.exists(f"fields/{session}.{group_name}.json"):
+            firing_fields = initialize((FiringFields,), session, group_name)
+            del firing_fields
+    # check that a best phase shift has been calculated
+    with open(f"sessions/{session}.json", 'r') as f:
+        session_dict = json.load(f)
+    if 'phase_shift' not in session_dict:
+        phase_vs_position = initialize((PhaseVsPosition, ), session, experimental_group_name)['PhaseVsPosition']
+        phase_vs_position.find_theta_0(min_shift=-60, max_shift=60, num_shifts=61)
+
+# run analyses and plot results
+for session in sessions:
+    print(f"\nAnalyzing session {session}...")
+
+    for group_name in group_names:
+        analyze(session, group_name)
+
+
+
+

analyze/batch_config.py

@@ -0,0 +1,72 @@
+import os
+from data_analysis.analyze.config import experimental_group_name, figures_path
+
+
+# select which sessions to analyze
+sessions = [
+    "ec013.156",
+    "ec013.206",
+    "ec013.374",
+    "ec013.386",
+    "ec013.388",
+    "ec013.395",
+    "ec013.412",
+    "ec013.413",
+    "ec013.440",
+    "ec013.454",
+    "ec013.466",
+    "ec013.469",
+    "ec013.502",
+    "ec013.531",
+    # only these three sessions were used in the models for ec013:
+    "ec013.555",
+    "ec013.556",
+    "ec013.574",
+
+    "ec014.468",
+    "ec014.639",
+
+    "ec016.233",
+    "ec016.234",
+    "ec016.269",
+
+    # These discard the first 5 minutes of the recordings:
+    "Achilles.10252013_alt",
+    "Buddy.06272013_alt",
+    "Cicero.09012014_alt",
+    "Cicero.09172014_alt",
+
+    # Original:
+    # "Achilles.10252013",
+    # "Buddy.06272013",
+    # "Cicero.09012014",
+    # "Cicero.09172014",
+    # "Gatsby.08022013"  # No phase precession
+
+    # "vvp01.1021",
+    # "vvp01.1815",
+    # "gor01.1315"
+]
+
+rats = []
+for session in sessions:
+    rat = session.split('.')[0]
+    if rat not in rats:
+        rats.append(rat)
+
+# select what to analyze: experimental data and/or models
+group_names = [
+    experimental_group_name,  # experimental data
+    # 'Time',  # temporal sweep model
+    # 'Position',  # spatial sweep model
+    # 'SpeedDep57',  # behavior-dependent sweep model
+    # 'VariableNoise'  # variable noise model
+]
+
+figures_path = f"{figures_path}/ALL"
+for group_name in group_names:
+    path = f"{figures_path}/{group_name}"
+    if not os.path.isdir(path):
+        os.makedirs(path)
+
+