OSCR

GluN2A Enables Noradrenergic Control of Prefrontal Oscillations and Cognitive Flexibility.

Code ↔ Paper

2 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 2 matches
  1. [1] § Materials and Methods › Multielectrode array (MEA) recordings ↔ MEA LFP _ Open OnDemand_LC_mPFC.ipynb, lines 375–439 · score 0.69 · power spectral density, Absolute power, Multitaper, windows, band, gamma
  2. [2] § Materials and Methods › Multielectrode array (MEA) recordings ↔ MEA LFP _ Open OnDemand_NE_Pharmacology.ipynb, lines 374–438 · score 0.69 · power spectral density, Absolute power, Multitaper, windows, band, gamma

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Jupyter notebook · 1,495 lines · 52 KB · no license · 1 match

  1. # %%
  2. from scipy.signal import butter, lfilter
  3. from scipy import signal
  4. import numpy as np
  5. import matplotlib.pyplot as plt
  6. import seaborn as sns
  7. import sklearn as sk
  8. import h5py
  9. import os.path
  10. import pandas as pd
  11. from sklearn.decomposition import PCA
  12. from sklearn.cluster import KMeans
  13. from sklearn.cluster import MiniBatchKMeans
  14. from sklearn.metrics import silhouette_score
  15. from sklearn.cluster import DBSCAN
  16. from sklearn import metrics
  17. import librosa.display
  18. # from kneed import KneeLocator
  19. import os
  20. import urllib
  22. import numpy as np
  23. from scipy.io import loadmat
  25. from tensorpac import Pac, EventRelatedPac, PreferredPhase
  26. from tensorpac.utils import PeakLockedTF, PSD, ITC, BinAmplitude
  27. from tensorpac.signals import pac_signals_wavelet
  29. import matplotlib.pyplot as plt
  30. plt.style.use('seaborn-poster')
  32. # %%
  33. save_path = "/home/hosseini/Desktop/2024/07.08.2024/Preprocessed/Output"
  34. save_pathh = "/home/hosseini/Desktop/2024/07.08.2024/Preprocessed/Output/mPFC_Slice2_Multitaper"
  35. save_path_coherence = "/home/hosseini/Desktop/2024/07.08.2024/Preprocessed/Output/mPFC_coherence_Slice2"
  36. name = '\_07082024_mPFC_Slice2'
  37. name2 = str('_07082024_mPFC_Slice2')
  38. strain = 'WT'
  42. # filenames
  43. data_path = "/home/hosseini/Desktop/2024/07.08.2024/Preprocessed"
  44. file_xtrain_vehicle = data_path + r"/2024-07-08mPFC_Slice2_LC_to_mPFC_CAG_ChR2_eYFP_10Second_Stim_A_Baseline__0002.h5" #### Vehicle
  45. file_xtrain_GFC = data_path + r"/2024-07-08mPFC_Slice2_LC_to_mPFC_CAG_ChR2_eYFP_10Second_Stim_A_Stimulation_.h5" #### NE
  46. file_xtrain_GFC_DOB = data_path + r"/2024-07-08mPFC_Slice2_LC_to_mPFC_CAG_ChR2_eYFP_10Second_Stim_A_Yohimbine+Stimulation__0002.h5" #### NE + DRUG
  47. # file_xtrain_vehicle2 = data_path + r"/2024-06-17__Slice2_WT_mPFC_NE2__0001.h5" #### NE2
  48. ################################################################### Baseline
  49. with h5py.File(file_xtrain_vehicle, 'r') as hdf:
  50. dt1 = hdf.get('Data/Recording_0/AnalogStream/Stream_0')
  51. dt1_items = list(dt1.items())
  52. ChannelData_vehicle = np.array(dt1.get('ChannelData'))
  53. print(ChannelData_vehicle.shape)
  54. ################################################################### Kanaite
  55. with h5py.File(file_xtrain_GFC, 'r') as hdf:
  56. dt1 = hdf.get('Data/Recording_0/AnalogStream/Stream_0')
  57. dt1_items = list(dt1.items())
  58. ChannelData_GFC = np.array(dt1.get('ChannelData'))
  59. print(ChannelData_GFC.shape)
  60. ################################################################### Kanaite + Bicuculline
  61. with h5py.File(file_xtrain_GFC_DOB, 'r') as hdf:
  62. dt1 = hdf.get('Data/Recording_0/AnalogStream/Stream_0')
  63. dt1_items = list(dt1.items())
  64. ChannelData_GFC_DOB = np.array(dt1.get('ChannelData'))
  65. print(ChannelData_GFC_DOB.shape)
  66. sf = 20000 # sampling requency
  67. print(f'time recorded in min: {((len(ChannelData_vehicle[1])/sf)/60)}')
  70. # %%
  71. # dim_x=60 # number of electrodes
  72. # dim_y=2401980 # time in seconds with fs 20k
  73. data_concat = np.concatenate((ChannelData_vehicle[:,:],
  74. ChannelData_GFC[:,:],
  75. ChannelData_GFC_DOB[:,:],
  76. # ChannelData_vehicle2[:,:],
  77. ), axis=1)
  78. np.shape(data_concat)
  80. # %% [markdown]
  81. # # Lowpass filter & downsample the data
  83. # %%
  84. def filter_data(data, low, high, sf, order=2):
  85. # Determine Nyquist frequency
  86. nyq = sf/2
  88. # Set bands
  89. low = low/nyq
  90. high = high/nyq
  92. # Calculate coefficients
  93. b, a = butter(order, [low, high], btype='bandpass',)
  95. # Filter signal
  96. filtered_data = lfilter(b, a, data)
  98. return filtered_data
  101. def downsample_data(data, sf, target_sf):
  102. # Calculate the initial downsampling factor
  103. factor = int(sf / target_sf)
  105. # Check if downsampling is necessary
  106. if factor < 1:
  107. raise ValueError("Target sampling frequency must be less than original sampling frequency.")
  109. # Downsample using multiple steps if necessary
  110. data_down = data
  111. while factor > 1:
  112. # Apply decimation in chunks to avoid excessive decimation
  113. step_factor = min(factor, 10) # Decimate in steps of max 10 to avoid aliasing
  114. data_down = signal.decimate(data_down, step_factor, ftype='fir')
  115. sf = sf / step_factor # Update the sampling rate after each decimation
  116. factor = int(sf / target_sf) # Recalculate the factor for the next iteration
  118. return data_down, int(sf)
  120. # %% [markdown]
  121. # # Apply the eprevious steps (notch 60, filter, downsample) to Combined data
  123. # %%
  124. from scipy import signal
  125. from scipy.signal import butter, lfilter
  126. sf = 20000 # sampling frequency
  127. target_sf = 2000 # target frequency for downsampling
  128. f0 = 60.0 # Frequency to be removed from signal (Hz)
  129. w0 = f0/(target_sf/2) # Normalized Frequency
  130. Q = 30 # Quality factor
  131. # Design notch filter
  132. b, a = signal.iirnotch(w0, Q)
  135. start = 0
  136. end = int(len(data_concat[0])/sf)
  137. ################################################### all data comined
  138. clean_data = []
  139. lfp_power = []
  140. # clean_data_power = []
  141. for chanlNo in range(len(data_concat)):
  142. data = data_concat[chanlNo].ravel()
  143. # compare the raw data with the filtered signal
  144. spike_data = filter_data(data[start*sf:end*sf], low=4, high=400, sf=sf) # Band pass filter the data for LFP analysis
  145. # Now we use the above function to downsample the signal.
  146. lfp_data, sf_lfp = downsample_data(spike_data, sf=sf, target_sf=target_sf)
  147. lfp_power.append(signal.welch(lfp_data, fs=sf_lfp, window='hamming', nperseg=1024, scaling='spectrum'))
  148. clean_data.append(signal.lfilter(b, a, lfp_data))
  150. # %% [markdown]
  151. # # Multitaper Spectrogram
  153. # %%
  154. %run /home/hosseini/Desktop/multitaper_spectrogram.py
  156. # %%
  157. # from multitaper_spectrogram_python import multitaper_spectrogram # import multitaper_spectrogram function from the multitaper_spectrogram_python.py file
  158. # Set spectrogram params
  159. fs = 2000 # Sampling Frequency
  160. frequency_range = [1, 250] # Limit frequencies from 0 to 25 Hz
  161. time_bandwidth = 5 # Set time-half bandwidth
  162. num_tapers = 8 # Set number of tapers (optimal is time_bandwidth*2 - 1)
  163. window_params = [4, 1] # Window size is 4s with step size of 1s
  164. min_nfft = 0 # No minimum nfft
  165. detrend_opt = 'constant' # detrend each window by subtracting the average
  166. multiprocess = True # use multiprocessing
  167. n_jobs = -1 # use 3 cores in multiprocessing
  168. weighting = 'unity' # weight each taper at 1
  169. plot_on = True # plot spectrogram
  170. clim_scale = False # do not auto-scale colormap
  171. verbose = False # print extra info
  172. xyflip = False # do not transpose spect output matrix
  174. # %%
  175. import warnings
  176. warnings.filterwarnings('ignore')
  177. import os.path
  178. #first we filter the raw data and then downsample the raw data
  179. from matplotlib.backends.backend_pdf import PdfPages
  180. pdf_pages = PdfPages(os.path.join(save_pathh,'Multitaper.pdf'))
  181. for i in range (len(clean_data)):
  182. spect, stimes, sfreqs = multitaper_spectrogram(clean_data[i],
  183. fs,
  184. frequency_range,
  185. time_bandwidth,
  186. num_tapers,
  187. window_params, min_nfft, detrend_opt,
  188. multiprocess, n_jobs,
  189. weighting,
  190. # plot_on,
  191. clim_scale,
  192. verbose, xyflip)
  193. # For saving the graphs
  194. spect_data = spect
  195. clim = np.percentile(spect_data, [5, 95]) # Scale colormap from 5th percentile to 95th
  197. # freqs, times, spectrogram = signal.spectrogram(data)#######
  198. fig = plt.figure(figsize=(10, 5))
  199. librosa.display.specshow(librosa.amplitude_to_db(spect, ref=np.max), x_axis='time', y_axis='linear',
  200. x_coords=stimes, y_coords=sfreqs, shading='auto',
  201. cmap= "jet"
  202. )
  203. plt.colorbar(label='Power [dB]')
  204. plt.xlabel("Time [MM:SS]")
  205. plt.ylabel("Frequency [Hz]")
  206. if clim_scale:
  207. plt.clim(clim) # actually change colorbar scale
  209. plt.title(f'Electrod No. : {i}')
  210. plt.axhline(y = 4, color = 'w', linestyle = '--', linewidth= 1.0 )
  211. plt.axhline(y = 10, color = 'w', linestyle = '--', linewidth= 1.0 )
  212. plt.axhline(y = 30, color = 'w', linestyle = '--', linewidth= 1.0 )
  214. plt.axvline(x = 5*60, color = 'w', linestyle = '--', linewidth= 2.0 ) # 5 mins
  215. plt.axvline(x = 10*60, color = 'w', linestyle = '--', linewidth= 2.0 )
  216. # plt.axvline(x = 15*60, color = 'w', linestyle = '--', linewidth= 2.0 )
  220. pdf_pages.savefig(fig)
  221. ######## Saving
  222. # plt.savefig(os.path.join(save_pathh , 'ElectrodeNo{}.svg'.format(i)),bbox_inches = 'tight')
  223. pdf_pages.close()
  226. # %% [markdown]
  227. # # STOP! DELETE UNWANTED CHANNELS
  229. # %%
  230. unwanted_num = [0,1,2,3,4,5,6,7,10,11,12,13,15,19,20,23,27,32,35,38,51,54,
  232. ]# channels to be removed
  237. # List of numbers with corresponding indices as shown in the image
  238. numbers_dict = {
  239. 54: 0, 56: 1, 55: 2, 46: 3, 45: 4, 44: 5, 36: 6, 35: 7, 34: 8, 26: 9,
  240. 16: 10, 25: 11, 15: 12, 24: 13, 14: 14, 13: 15, 23: 16, 12: 17, 22: 18,
  241. 11: 19, 21: 20, 33: 21, 32: 22, 31: 23, 43: 24, 42: 25, 41: 26, 52: 27,
  242. 51: 28, 53: 29, 63: 30, 61: 31, 62: 32, 71: 33, 72: 34, 73: 35, 81: 36,
  243. 82: 37, 83: 38, 91: 39, 101: 40, 92: 41, 102: 42, 93: 43, 103: 44,
  244. 104: 45, 94: 46, 105: 47, 95: 48, 106: 49, 96: 50, 84: 51, 85: 52,
  245. 86: 53, 74: 54, 75: 55, 76: 56, 65: 57, 66: 58, 64: 59
  246. }
  247. # Function to get corresponding indices, excluding unwanted numbers
  248. def get_corresponding_values(selected_nums):
  249. filtered_values = [num for num in selected_nums if num in unwanted_num]
  250. return filtered_values
  251. # L2/3
  252. L_2_3 = get_corresponding_values([
  253. 19, 20, 23, 26, 28, 31, 33, 36, 39, 40,
  254. # 10, 9, 6, 3, 1, 58, 56, 53, 50, 49
  255. ])
  256. # L5
  257. L_5 = get_corresponding_values([
  258. # 19, 20, 23, 26, 28, 31, 33, 36, 39, 40,
  259. 17, 18, 22, 25, 27, 32, 34, 41, 42,
  260. 15, 16, 24, 29, 30, 35, 38, 43, 44,
  261. 13, 8, 0, 59, 54, 51, 46, 45, 12,
  262. 12, 11, 7, 4, 2, 57, 55, 52, 48, 47,
  263. 10, 9, 6, 3, 1, 58, 56, 53, 50, 49
  264. ]
  265. )
  266. print(L_2_3, L_5)
  268. # %%
  269. layer ='Layer2_3'
  272. import warnings
  273. warnings.filterwarnings('ignore')
  274. import os.path
  275. #first we filter the raw data and then downsample the raw data
  276. from matplotlib.backends.backend_pdf import PdfPages
  277. pdf_pages = PdfPages(os.path.join(save_pathh,'Multitaper_Layer2_3.pdf'))
  278. for i in L_2_3:
  279. spect, stimes, sfreqs = multitaper_spectrogram(clean_data[i],
  280. fs,
  281. frequency_range,
  282. time_bandwidth,
  283. num_tapers,
  284. window_params, min_nfft, detrend_opt,
  285. multiprocess, n_jobs,
  286. weighting,
  287. # plot_on,
  288. clim_scale,
  289. verbose, xyflip)
  290. # For saving the graphs
  291. spect_data = spect
  292. clim = np.percentile(spect_data, [5, 95]) # Scale colormap from 5th percentile to 95th
  294. # freqs, times, spectrogram = signal.spectrogram(data)#######
  295. fig = plt.figure(figsize=(10, 5))
  296. librosa.display.specshow(librosa.amplitude_to_db(spect, ref=np.max), x_axis='time', y_axis='linear',
  297. x_coords=stimes, y_coords=sfreqs, shading='auto',
  298. cmap= "jet"
  299. )
  300. # plt.colorbar(label='Power [dB]')
  301. plt.xlabel("Time [MM:SS]")
  302. plt.ylabel("Frequency [Hz]")
  304. plt.title(f'Electrod No. : {i}')
  305. plt.axhline(y = 4, color = 'w', linestyle = '--', linewidth= 2.0 )
  306. plt.axhline(y = 10, color = 'w', linestyle = '--', linewidth= 2.0 )
  307. plt.axhline(y = 25, color = 'w', linestyle = '--', linewidth= 2.0 )
  310. plt.axvline(x = 5*60 ,color = 'w', linestyle = '--', linewidth= 2.0 ) #
  311. plt.axvline(x = 10*60 ,color = 'w', linestyle = '--', linewidth= 2.0 ) #
  315. pdf_pages.savefig(fig)
  316. ######## Saving
  317. plt.savefig(os.path.join(save_pathh , 'ElectrodeNo{}_Layer2_3.svg'.format(i)),bbox_inches = 'tight')
  318. pdf_pages.close()
  320. # %%
  321. layer ='Layer5'
  324. import warnings
  325. warnings.filterwarnings('ignore')
  326. import os.path
  327. #first we filter the raw data and then downsample the raw data
  328. from matplotlib.backends.backend_pdf import PdfPages
  329. pdf_pages = PdfPages(os.path.join(save_pathh,'Multitaper_Layer5.pdf'))
  330. for i in L_5:
  331. spect, stimes, sfreqs = multitaper_spectrogram(clean_data[i],
  332. fs,
  333. frequency_range,
  334. time_bandwidth,
  335. num_tapers,
  336. window_params, min_nfft, detrend_opt,
  337. multiprocess, n_jobs,
  338. weighting,
  339. # plot_on,
  340. clim_scale,
  341. verbose, xyflip)
  342. # For saving the graphs
  343. spect_data = spect
  344. clim = np.percentile(spect_data, [5, 95]) # Scale colormap from 5th percentile to 95th
  346. # freqs, times, spectrogram = signal.spectrogram(data)#######
  347. fig = plt.figure(figsize=(10, 5))
  348. librosa.display.specshow(librosa.amplitude_to_db(spect, ref=np.max), x_axis='time', y_axis='linear',
  349. x_coords=stimes, y_coords=sfreqs, shading='auto',
  350. cmap= "jet"
  351. )
  352. # plt.colorbar(label='Power [dB]')
  353. plt.xlabel("Time [MM:SS]")
  354. plt.ylabel("Frequency [Hz]")
  356. plt.title(f'Electrod No. : {i}')
  357. plt.axhline(y = 4, color = 'w', linestyle = '--', linewidth= 2.0 )
  358. plt.axhline(y = 10, color = 'w', linestyle = '--', linewidth= 2.0 )
  359. plt.axhline(y = 25, color = 'w', linestyle = '--', linewidth= 2.0 )
  362. plt.axvline(x = 5*60 ,color = 'w', linestyle = '--', linewidth= 2.0 ) #
  363. plt.axvline(x = 10*60 ,color = 'w', linestyle = '--', linewidth= 2.0 ) #
  367. pdf_pages.savefig(fig)
  368. ######## Saving
  369. plt.savefig(os.path.join(save_pathh , 'ElectrodeNo{}_Layer5.svg'.format(i)),bbox_inches = 'tight')
  370. pdf_pages.close()
  372. # %%
  375. # %%
  376. # delta = [1, 4]
  377. # theta = [4, 10]
  378. # beta = [10, 30]
  379. # gamma = [30, 80]
  380. # ref = https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4009705/
  381. def bandpower(data, sf, band, method='welch', window_sec=None, relative=False):
  382. """Compute the average power of the signal x in a specific frequency band.
  384. Requires MNE-Python >= 0.14.
  386. Parameters
  387. ----------
  388. data : 1d-array
  389. Input signal in the time-domain.
  390. sf : float
  391. Sampling frequency of the data.
  392. band : list
  393. Lower and upper frequencies of the band of interest.
  394. method : string
  395. Periodogram method: 'welch' or 'multitaper'
  396. window_sec : float
  397. Length of each window in seconds. Useful only if method == 'welch'.
  398. If None, window_sec = (1 / min(band)) * 2.
  399. relative : boolean
  400. If True, return the relative power (= divided by the total power of the signal).
  401. If False (default), return the absolute power.
  403. Return
  404. ------
  405. bp : float
  406. Absolute or relative band power.
  407. """
  408. from scipy.signal import welch
  409. from scipy.integrate import simps
  410. from mne.time_frequency import psd_array_multitaper
  412. band = np.asarray(band)
  413. low, high = band
  415. # Compute the modified periodogram (Welch)
  416. if method == 'welch':
  417. if window_sec is not None:
  418. nperseg = window_sec * sf
  419. else:
  420. nperseg = (2 / low) * sf
  422. freqs, psd = welch(data, sf, nperseg=nperseg)
  424. elif method == 'multitaper':
  425. psd, freqs = psd_array_multitaper(data, sf, adaptive=False,
  426. normalization='full', verbose=0, n_jobs=-1)
  428. # Frequency resolution
  429. freq_res = freqs[1] - freqs[0]
  431. # Find index of band in frequency vector
  432. idx_band = np.logical_and(freqs >= low, freqs <= high)
  434. # Integral approximation of the spectrum using parabola (Simpson's rule)
  435. bp = simps(psd[idx_band], dx=freq_res)
  437. if relative:
  438. bp /= simps(psd, dx=freq_res)
  439. return bp
  441. # %% [markdown]
  442. # # Layer 2/3
  444. # %%
  445. from scipy import signal
  446. from scipy.signal import butter, lfilter
  447. sf = 20000 # sampling frequency
  448. target_sf = 1000 # target frequency for downsampling
  449. f0 = 60.0 # Frequency to be removed from signal (Hz)
  450. w0 = f0/(target_sf/2) # Normalized Frequency
  451. Q = 30 # Quality factor
  452. # Design notch filter
  453. b, a = signal.iirnotch(w0, Q)
  455. start = 0
  456. end = int(len(ChannelData_vehicle[0])/sf)
  460. ################################################### baseline
  461. clean_data_vehicle = []
  463. for chanlNo in (L_2_3):
  464. data = ChannelData_vehicle[chanlNo].ravel()
  465. spike_data = filter_data(data[start*sf:end*sf], low=1, high= 500, sf=sf) # Band pass filter the data for LFP analysis
  466. # Now we use the above function to downsample the signal.
  467. lfp_data, sf_lfp = downsample_data(spike_data, sf=sf, target_sf=target_sf)
  468. clean_data_vehicle.append(signal.lfilter(b, a, lfp_data))
  471. ################################################### kainate
  472. end = int(len(ChannelData_GFC[0])/sf)
  473. clean_data_GFC = []
  475. for chanlNo in (L_2_3):
  476. data = ChannelData_GFC[chanlNo].ravel()
  477. spike_data = filter_data(data[start*sf:end*sf], low=1, high= 500, sf=sf) # Band pass filter the data for LFP analysis
  478. # Now we use the above function to downsample the signal.
  479. lfp_data, sf_lfp = downsample_data(spike_data, sf=sf, target_sf=target_sf)
  480. clean_data_GFC.append(signal.lfilter(b, a, lfp_data))
  483. # ################################################### kainate + bicuculine
  484. end = int(len(ChannelData_GFC_DOB[0])/sf)
  485. clean_data_GFC_DOB = []
  487. for chanlNo in (L_2_3):
  488. data = ChannelData_GFC_DOB[chanlNo].ravel()
  489. spike_data = filter_data(data[start*sf:end*sf], low=1, high= 500, sf=sf) # Band pass filter the data for LFP analysis
  490. # Now we use the above function to downsample the signal.
  491. lfp_data, sf_lfp = downsample_data(spike_data, sf=sf, target_sf=target_sf)
  492. clean_data_GFC_DOB.append(signal.lfilter(b, a, lfp_data))
  498. # %% [markdown]
  499. # # stop ! Change the NAME of the drug
  501. # %%
  502. import warnings
  503. warnings.filterwarnings('ignore')
  504. import numpy as np
  505. import pandas as pd
  506. import os
  508. layer = 'L_2_3'
  509. # Frequency bands and data groupings
  510. freq_bands = {
  511. 'delta': [1, 4],
  512. 'theta': [4, 10],
  513. 'beta': [10, 25],
  514. 'lowgamma': [30, 60],
  515. 'highgamma': [60, 100],
  516. 'gamma': [30, 100],
  517. 'ripple': [100, 200]
  518. }
  520. data_groups = {
  521. 'vehicle': clean_data_vehicle,
  522. 'NE ': clean_data_GFC,
  523. 'NE_YHM': clean_data_GFC_DOB,
  524. }
  526. # Time segments
  527. time_segments = {
  528. '_immediate': (38, 43),
  529. '_delayed': (38, 98),
  530. }
  532. # Function to compute band power for each time segment
  533. def compute_band_power(data, fs, freq_band, start, end):
  534. return bandpower(data[start * fs:end * fs], fs, freq_band, 'welch')
  536. # Initialize results dictionary for band power per time segment
  537. band_results = {band: {group: {segment: [] for segment in time_segments} for group in data_groups} for band in freq_bands}
  539. # Main loop for bandpower calculation with time segments
  540. for i in range(len(L_2_3)):
  541. for band_name, band_range in freq_bands.items():
  542. for group_name, group_data in data_groups.items():
  543. for segment_name, (start, end) in time_segments.items():
  544. # Compute band power for the specific time segment
  545. bp = compute_band_power(group_data[i], target_sf, band_range, start, end)
  546. band_results[band_name][group_name][segment_name].append(bp)
  548. # Prepare data for export, now considering time segments
  549. export_data = {}
  550. for band in freq_bands:
  551. concatenated_data = []
  552. for group in data_groups:
  553. for segment in time_segments:
  554. segment_data = band_results[band][group][segment]
  556. # Ensure the segment data is not empty and contains valid arrays
  557. if len(segment_data) > 0:
  558. # Convert any zero-dimensional arrays into one-dimensional ones
  559. segment_data = [np.atleast_1d(data) for data in segment_data]
  560. concatenated_data.append(np.concatenate(segment_data))
  562. # Only concatenate if we have non-empty arrays
  563. if len(concatenated_data) > 0:
  564. export_data[band] = np.concatenate(concatenated_data)
  565. else:
  566. export_data[band] = np.array([]) # Handle case where there's no data
  568. # Create conditions list, including the data groups and time segments
  569. conditions = np.concatenate([
  570. len(band_results['delta'][group][segment]) * [f"{group}_{segment}"]
  571. for group in data_groups for segment in time_segments if len(band_results['delta'][group][segment]) > 0
  572. ])
  574. # Calculate average band power for each condition
  575. average_cols = {}
  576. for band in freq_bands:
  577. if len(export_data[band]) > 0:
  578. # Split data for the band into separate arrays by condition (group + segment)
  579. data_per_condition = np.array_split(export_data[band], len(data_groups) * len(time_segments))
  580. avg_per_condition = [np.mean(segment) for segment in data_per_condition]
  582. # Create a column repeating the average value for alignment with the DataFrame length
  583. average_col = np.concatenate([[avg] * len(segment) for avg, segment in zip(avg_per_condition, data_per_condition)])
  584. average_cols[f'Average {band}'] = average_col
  585. else:
  586. average_cols[f'Average {band}'] = np.array([]) # Handle empty case
  588. # Metadata (modify or add actual values as needed)
  589. layer_col = [layer] * len(conditions) # Replace with actual data if available
  590. id_col = [name] * len(conditions) # Replace with actual data if available
  591. strain_col = [strain] * len(conditions) # Replace with actual data if available
  593. # Create DataFrame for export, now including time segments
  594. df_export = pd.DataFrame({
  595. **export_data,
  596. 'condition': conditions,
  597. **average_cols,
  598. 'Layer': layer_col,
  599. 'ID': id_col,
  600. 'strain': strain_col
  601. })
  603. # Export to Excel
  604. file_name = f"{name}_BandPower_{layer}.xlsx"
  605. save_path_full = os.path.join(save_path, file_name)
  607. with pd.ExcelWriter(save_path_full, engine='xlsxwriter') as writer:
  608. df_export.to_excel(writer, sheet_name='BandPower', index=False)
  610. print("Data exported successfully.")
  613. # %%
  614. import seaborn as sns
  615. import matplotlib.pyplot as plt
  617. # Load the exported data from the previous code
  618. df = pd.read_excel(os.path.join(save_path, file_name))
  620. # Frequency bands and titles
  621. bands = ['delta', 'theta', 'beta', 'lowgamma', 'highgamma', 'ripple']
  622. titles = [
  623. r'[$\delta$] Power', r'[$\theta$] Power', r'[$\beta$] Power',
  624. r'low [$\gamma$] Power', r'high [$\gamma$] Power', r'Cortical Ripple Power'
  625. ]
  627. # Updated condition labels based on time segments and groups
  628. xticklabels = [
  629. 'Vehicle_immediate', 'Vehicle_delayed',
  630. 'NE_immediate', 'NE_delayed',
  631. 'NE_YHM_immediate', 'NE_YHM_delayed'
  632. ]
  634. # Create subplots for each frequency band
  635. fig, ax = plt.subplots(nrows=2, ncols=3, figsize=(15, 5))
  637. # Loop over each frequency band and create a plot
  638. for i, band in enumerate(bands):
  639. row, col = divmod(i, 3) # Determine row and column for each subplot
  641. # Create boxplot for each condition and frequency band
  642. sns.boxplot(data=df, x='condition', y=band, ax=ax[row, col], showfliers=False)
  644. # Create swarmplot (or stripplot) to show individual points on top of the boxplot
  645. sns.stripplot(data=df, x='condition', y=band, color='k', ax=ax[row, col], dodge=True)
  647. # Set the x-axis labels to the updated condition names
  648. ax[row, col].set_xticklabels(xticklabels)
  649. ax[row, col].tick_params(axis='x', rotation=90, size= 2) # Rotate x-axis labels for readability
  651. # Set title for each subplot based on the band
  652. ax[row, col].set_title(titles[i])
  654. # Set y-axis to log scale for better visualization of power values
  655. ax[row, col].set_yscale("log")
  657. # Remove top and right spines to make the plot look cleaner
  658. ax[row, col].spines['top'].set_visible(False)
  659. ax[row, col].spines['right'].set_visible(False)
  661. # Set y-axis label for the first subplot
  662. if band == 'delta':
  663. ax[row, col].set_ylabel('Power [\u03bc$V^2$]')
  665. # Adjust the layout for better spacing
  666. plt.tight_layout()
  668. # Save the figure as a PDF
  669. plt.savefig(os.path.join(save_path, name + 'BandPower_L2_3.pdf'), bbox_inches='tight')
  671. # Show the plot
  672. plt.show()
  675. # %%
  676. import numpy as np
  677. from scipy import signal
  678. import matplotlib.pyplot as plt
  679. import os
  680. import seaborn as sns
  682. # Helper function to append suffix to filenames
  683. def save_figure_with_suffix(filename_base, suffix='_L2_3', save_path='.', ext='svg'):
  684. filename = f"{filename_base}{suffix}.{ext}"
  685. plt.savefig(os.path.join(save_path, filename), bbox_inches='tight')
  687. # Coherence calculation for data within layer 2/3
  688. def calculate_coherence(data_list, sf, freq_range=None):
  689. num_channels = len(data_list)
  690. coherence_matrix = np.zeros((num_channels, num_channels))
  692. # Loop through all pairs of channels
  693. for i in range(num_channels):
  694. for j in range(i + 1, num_channels):
  695. f, Cxy = signal.coherence(data_list[i], data_list[j], fs=sf, nperseg=1024)
  697. if freq_range:
  698. # Find indices within the desired frequency range
  699. freq_indices = np.where((f >= freq_range[0]) & (f <= freq_range[1]))
  700. coherence_matrix[i, j] = np.mean(Cxy[freq_indices])
  701. else:
  702. coherence_matrix[i, j] = np.mean(Cxy)
  704. return coherence_matrix
  706. def plot_coherence_matrix(matrix, title='', vmin=None, vmax=None):
  707. plt.figure(figsize=(7, 5))
  708. ax = sns.heatmap(matrix, annot=False, cmap='hot', vmin=vmin, vmax=vmax, cbar_kws={'label': 'Coherence'})
  709. ax.set_title(title)
  710. ax.set_xlabel('Channel')
  711. ax.set_ylabel('Channel')
  713. # Define start and end times for base and stim32 separately
  714. intervals = [(38, 98)]
  716. fs = target_sf
  717. # Extract data segments for baseline and stimulation
  718. clean_data_Vehicle = [data[start * fs:end * fs] for data in clean_data_vehicle for start, end in intervals]
  719. clean_data_NE = [data[start * fs:end * fs] for data in clean_data_GFC for start, end in intervals]
  720. clean_data_NE_YHM = [data[start * fs:end * fs] for data in clean_data_GFC_DOB for start, end in intervals]
  723. # Calculate coherence matrices
  724. coherence_matrix_Vehicle = calculate_coherence(clean_data_Vehicle, sf=target_sf, freq_range=(30, 80))
  725. coherence_matrix_NE = calculate_coherence(clean_data_NE, sf=target_sf, freq_range=(30, 80))
  726. coherence_matrix_NE_YHM = calculate_coherence(clean_data_NE_YHM, sf=target_sf, freq_range=(30, 80))
  729. # Find global min and max values for the color scale
  730. min_coherence = min(coherence_matrix_Vehicle.min(), coherence_matrix_NE.min(),
  731. coherence_matrix_NE_YHM.min(), )
  732. max_coherence = max(coherence_matrix_Vehicle.max(), coherence_matrix_NE.max(),
  733. coherence_matrix_NE_YHM.max(), )
  735. # Plot and save coherence matrices
  736. for matrix, label in zip([coherence_matrix_Vehicle, coherence_matrix_NE, coherence_matrix_NE_YHM],
  737. ["Vehicle", "NE", "NE_YHM"]):
  738. plot_coherence_matrix(matrix, title=f"Coherence Matrix - {label}", vmin=min_coherence, vmax=max_coherence)
  739. save_figure_with_suffix(f'coherence_matrix_{label}', save_path=save_path_coherence)
  740. plt.show()
  742. # Calculate and print average coherence for quantification
  743. coherence_avgs = {
  744. "Vehicle": np.mean(coherence_matrix_Vehicle[coherence_matrix_Vehicle > 0]),
  745. "NE": np.mean(coherence_matrix_NE[coherence_matrix_NE > 0]),
  746. "NE_YHM": np.mean(coherence_matrix_NE_YHM[coherence_matrix_NE_YHM > 0]),
  748. }
  750. for label, avg in coherence_avgs.items():
  751. print(f"Average Coherence - {label}:", avg)
  754. # %%
  755. data_vehicle= []
  756. data_GFC= []
  757. data_GFC_DOB= []
  759. start = 38
  760. end = 98
  761. fs = target_sf
  763. for i in range(len(clean_data_vehicle)):
  764. data_vehicle.append(downsample_data(clean_data_vehicle[i][start * fs:end * fs], sf, target_sf)[0]) # [::10] is used for downsampling and faster process
  765. data_GFC.append(downsample_data(clean_data_GFC[i][start * fs:end * fs], sf, target_sf)[0])
  766. data_GFC_DOB.append(downsample_data(clean_data_GFC_DOB[i][start * fs:end * fs], sf, target_sf)[0])
  771. # %%
  772. sf = target_sf
  773. p_obj = Pac(idpac=(4, 0, 0), f_pha=(1, 30, 1, .2), f_amp=(1, 200, 1, 2)) # 1-30 DTAB
  774. pha = p_obj.filter(sf, np.array(data_vehicle), ftype='phase', n_jobs=-1)
  775. amp = p_obj.filter(sf, np.array(data_vehicle), ftype='amplitude', n_jobs=-1)
  776. pac_vehicle = p_obj.fit(pha, amp)
  778. pha = p_obj.filter(sf, np.array(data_GFC), ftype='phase', n_jobs=-1)
  779. amp = p_obj.filter(sf, np.array(data_GFC), ftype='amplitude', n_jobs=-1)
  780. pac_GFC = p_obj.fit(pha, amp)
  782. pha = p_obj.filter(sf, np.array(data_GFC_DOB), ftype='phase', n_jobs=-1)
  783. amp = p_obj.filter(sf, np.array(data_GFC_DOB), ftype='amplitude', n_jobs=-1)
  784. pac_GFC_DOB = p_obj.fit(pha, amp)
  791. # ################# saving ndarrays
  792. import numpy as np
  793. from pathlib import Path
  795. path = Path(save_path).expanduser()
  796. path.mkdir(parents=True, exist_ok=True)
  798. np.save(path/(name + layer + '_pac_vehicle'), pac_vehicle)
  799. np.save(path/(name + layer + '_pac_NE'), pac_GFC)
  800. np.save(path/(name + layer + '_pac_NE_YHM'), pac_GFC_DOB)
  807. # %%
  808. import matplotlib.pyplot as plt
  809. import numpy as np
  811. condition= ['Vehicle', 'NE',
  812. 'NE_YHM',
  813. ]
  814. pac = [pac_vehicle, pac_GFC,
  815. pac_GFC_DOB,
  816. ]
  818. # Set up the figure size for the plot
  819. plt.figure(figsize=(12, 9))
  821. # Initialize variable to store the global vmax
  822. global_vmax = -np.inf # Start with a very low value
  824. # First loop to determine global vmax
  825. for k in pac:
  826. pacc = k.mean(axis=1) # Compute the mean across time points/trials
  827. global_vmax = max(global_vmax, pacc.max()) # Update global vmax with the max value across all conditions
  829. # Loop through each condition and its corresponding PAC
  830. for i, (k, cond) in enumerate(zip(pac, condition)):
  831. pacc = k.mean(axis=-1)
  833. # Check the shape of pacc after mean calculation
  834. print(f"Shape of pacc for {cond}: {pacc.shape}")
  836. # Set up the color scaling using the global vmax
  837. kw = dict(vmax=global_vmax, vmin=0, cmap='jet')
  839. # Plotting the comodulogram
  840. plt.subplot(2, 2, i + 1)
  841. p_obj.comodulogram(pacc, title=f"PAC {cond}", **kw)
  843. # Adding vertical lines at specific points for reference
  844. plt.axvline(x=4, color='k', linestyle='--', linewidth=2.0)
  845. plt.axvline(x=10, color='k', linestyle='--', linewidth=2.0)
  847. # Adjust layout for better spacing
  848. plt.tight_layout()
  850. ####### Saving
  851. import os.path
  852. fileName = name2
  853. plt.savefig(os.path.join(save_path , fileName + layer + '_PAC.svg'),bbox_inches = 'tight')
  854. plt.savefig(os.path.join(save_path , fileName + layer + '_PAC.pdf'), bbox_inches = 'tight')
  856. # %%
  857. # define the preferred phase object
  858. sf = target_sf
  859. # pp_obj = PreferredPhase(f_pha=[1, 4], f_amp=(30, 100, 2, 2)) # alpha (1-4 Hz)
  860. pp_obj = PreferredPhase(f_pha=[4,8], f_amp=(30, 200, 2, 2)) # THETA (4-8 Hz)
  861. n_jobs = -1
  862. # compute the preferred phase (reuse the amplitude computed above)
  863. pha_vehicle = pp_obj.filter(sf, np.array(data_vehicle), ftype='phase', n_jobs=n_jobs)
  864. amp_vehicle = pp_obj.filter(sf, np.array(data_vehicle), ftype='amplitude', n_jobs=n_jobs)
  865. pha_GFC = pp_obj.filter(sf, np.array(data_GFC), ftype='phase', n_jobs=n_jobs)
  866. amp_GFC = pp_obj.filter(sf, np.array(data_GFC), ftype='amplitude', n_jobs=n_jobs)
  867. pha_GFC_DOB = pp_obj.filter(sf, np.array(data_GFC_DOB), ftype='phase', n_jobs=n_jobs)
  868. amp_GFC_DOB = pp_obj.filter(sf, np.array(data_GFC_DOB), ftype='amplitude', n_jobs=n_jobs)
  873. ampbin_vehicle, _, vecbin = pp_obj.fit(pha_vehicle, amp_vehicle, n_bins=72)
  874. ampbin_GFC, _, vecbin = pp_obj.fit(pha_GFC, amp_GFC, n_bins=72)
  875. ampbin_GFC_DOB, _, vecbin = pp_obj.fit(pha_GFC_DOB, amp_GFC_DOB, n_bins=72)
  879. # mean binned amplitude across trials
  880. ampbin_vehicle = np.squeeze(ampbin_vehicle).mean(-1).T
  881. ampbin_GFC = np.squeeze(ampbin_GFC).mean(-1).T
  882. ampbin_GFC_DOB = np.squeeze(ampbin_GFC_DOB).mean(-1).T
  887. ################# saving ndarrays theta
  888. import numpy as np
  889. from pathlib import Path
  891. path.mkdir(parents=True, exist_ok=True)
  893. np.save(path/(name2 + layer + '_ampbin_vehicle'), ampbin_vehicle)
  894. np.save(path/(name2 + layer + '_ampbin_NE'), ampbin_GFC)
  895. np.save(path/(name2 + layer + '_ampbin_NE_YHM'), ampbin_GFC_DOB)
  902. # %%
  903. import numpy as np
  904. import matplotlib.pyplot as plt
  906. # List of all the amplitude bins (all frequency conditions)
  907. ampbins = [ampbin_vehicle, ampbin_GFC, ampbin_GFC_DOB, ]
  909. # Find the global minimum and maximum values across all amplitude bins
  910. global_min = np.min([np.min(amp) for amp in ampbins])
  911. global_max = np.max([np.max(amp) for amp in ampbins])
  913. # Now set vmin and vmax to these global values
  914. vmin_value = global_min
  915. vmax_value = global_max
  917. # Define the plotting dictionary with consistent color range
  918. kw_plt = dict(cmap='RdBu_r', interp=0.1, cblabel='Bins Amplitude',
  919. colorbar=True, y=1.3, fz_title=20, plotas='contour',
  920. vmin=vmin_value, vmax=vmax_value)
  922. # Create the figure
  923. plt.figure(figsize=(27, 23))
  925. # Plot the data for each frequency condition using the updated kw_plt dictionary
  926. pp_obj.polar(ampbin_vehicle, vecbin, pp_obj.yvec, subplot=331, title='vehicle', **kw_plt)
  927. pp_obj.polar(ampbin_GFC, vecbin, pp_obj.yvec, subplot=332, title='NE', **kw_plt)
  928. pp_obj.polar(ampbin_GFC_DOB, vecbin, pp_obj.yvec, subplot=333, title='NE_YHM', **kw_plt)
  932. # Adjust layout to prevent overlapping elements
  933. plt.tight_layout()
  935. ########### Saving
  936. import os.path
  937. fileName = name2
  938. plt.savefig(os.path.join(save_path , fileName + layer + '_PreferredPhase_ThetaGamma.pdf'), bbox_inches = 'tight')
  940. # %%
  943. # %% [markdown]
  944. # # Layer 5
  946. # %%
  947. from scipy import signal
  948. from scipy.signal import butter, lfilter
  949. sf = 20000 # sampling frequency
  950. target_sf = 1000 # target frequency for downsampling
  951. f0 = 60.0 # Frequency to be removed from signal (Hz)
  952. w0 = f0/(target_sf/2) # Normalized Frequency
  953. Q = 30 # Quality factor
  954. # Design notch filter
  955. b, a = signal.iirnotch(w0, Q)
  957. start = 0
  958. end = int(len(ChannelData_vehicle[0])/sf)
  962. ################################################### baseline
  963. clean_data_vehicle = []
  965. for chanlNo in (L_5):
  966. data = ChannelData_vehicle[chanlNo].ravel()
  967. spike_data = filter_data(data[start*sf:end*sf], low=1, high= 500, sf=sf) # Band pass filter the data for LFP analysis
  968. # Now we use the above function to downsample the signal.
  969. lfp_data, sf_lfp = downsample_data(spike_data, sf=sf, target_sf=target_sf)
  970. clean_data_vehicle.append(signal.lfilter(b, a, lfp_data))
  973. ################################################### kainate
  974. end = int(len(ChannelData_GFC[0])/sf)
  975. clean_data_GFC = []
  977. for chanlNo in (L_5):
  978. data = ChannelData_GFC[chanlNo].ravel()
  979. spike_data = filter_data(data[start*sf:end*sf], low=1, high= 500, sf=sf) # Band pass filter the data for LFP analysis
  980. # Now we use the above function to downsample the signal.
  981. lfp_data, sf_lfp = downsample_data(spike_data, sf=sf, target_sf=target_sf)
  982. clean_data_GFC.append(signal.lfilter(b, a, lfp_data))
  985. # ################################################### kainate + bicuculine
  986. end = int(len(ChannelData_GFC_DOB[0])/sf)
  987. clean_data_GFC_DOB = []
  989. for chanlNo in (L_5):
  990. data = ChannelData_GFC_DOB[chanlNo].ravel()
  991. spike_data = filter_data(data[start*sf:end*sf], low=1, high= 500, sf=sf) # Band pass filter the data for LFP analysis
  992. # Now we use the above function to downsample the signal.
  993. lfp_data, sf_lfp = downsample_data(spike_data, sf=sf, target_sf=target_sf)
  994. clean_data_GFC_DOB.append(signal.lfilter(b, a, lfp_data))
  998. # %%
  999. import warnings
  1000. warnings.filterwarnings('ignore')
  1001. import numpy as np
  1002. import pandas as pd
  1003. import os
  1005. layer = 'L_5'
  1006. # Frequency bands and data groupings
  1007. freq_bands = {
  1008. 'delta': [1, 4],
  1009. 'theta': [4, 10],
  1010. 'beta': [10, 25],
  1011. 'lowgamma': [30, 60],
  1012. 'highgamma': [60, 100],
  1013. 'gamma': [30, 100],
  1014. 'ripple': [100, 200]
  1015. }
  1017. data_groups = {
  1018. 'vehicle': clean_data_vehicle,
  1019. 'NE ': clean_data_GFC,
  1020. 'NE_YHM': clean_data_GFC_DOB,
  1021. }
  1023. # Time segments
  1024. time_segments = {
  1025. '_immediate': (38, 43),
  1026. '_delayed': (38, 98),
  1027. }
  1029. # Function to compute band power for each time segment
  1030. def compute_band_power(data, fs, freq_band, start, end):
  1031. return bandpower(data[start * fs:end * fs], fs, freq_band, 'welch')
  1033. # Initialize results dictionary for band power per time segment
  1034. band_results = {band: {group: {segment: [] for segment in time_segments} for group in data_groups} for band in freq_bands}
  1036. # Main loop for bandpower calculation with time segments
  1037. for i in range(len(L_5)):
  1038. for band_name, band_range in freq_bands.items():
  1039. for group_name, group_data in data_groups.items():
  1040. for segment_name, (start, end) in time_segments.items():
  1041. # Compute band power for the specific time segment
  1042. bp = compute_band_power(group_data[i], target_sf, band_range, start, end)
  1043. band_results[band_name][group_name][segment_name].append(bp)
  1045. # Prepare data for export, now considering time segments
  1046. export_data = {}
  1047. for band in freq_bands:
  1048. concatenated_data = []
  1049. for group in data_groups:
  1050. for segment in time_segments:
  1051. segment_data = band_results[band][group][segment]
  1053. # Ensure the segment data is not empty and contains valid arrays
  1054. if len(segment_data) > 0:
  1055. # Convert any zero-dimensional arrays into one-dimensional ones
  1056. segment_data = [np.atleast_1d(data) for data in segment_data]
  1057. concatenated_data.append(np.concatenate(segment_data))
  1059. # Only concatenate if we have non-empty arrays
  1060. if len(concatenated_data) > 0:
  1061. export_data[band] = np.concatenate(concatenated_data)
  1062. else:
  1063. export_data[band] = np.array([]) # Handle case where there's no data
  1065. # Create conditions list, including the data groups and time segments
  1066. conditions = np.concatenate([
  1067. len(band_results['delta'][group][segment]) * [f"{group}_{segment}"]
  1068. for group in data_groups for segment in time_segments if len(band_results['delta'][group][segment]) > 0
  1069. ])
  1071. # Calculate average band power for each condition
  1072. average_cols = {}
  1073. for band in freq_bands:
  1074. if len(export_data[band]) > 0:
  1075. # Split data for the band into separate arrays by condition (group + segment)
  1076. data_per_condition = np.array_split(export_data[band], len(data_groups) * len(time_segments))
  1077. avg_per_condition = [np.mean(segment) for segment in data_per_condition]
  1079. # Create a column repeating the average value for alignment with the DataFrame length
  1080. average_col = np.concatenate([[avg] * len(segment) for avg, segment in zip(avg_per_condition, data_per_condition)])
  1081. average_cols[f'Average {band}'] = average_col
  1082. else:
  1083. average_cols[f'Average {band}'] = np.array([]) # Handle empty case
  1085. # Metadata (modify or add actual values as needed)
  1086. layer_col = [layer] * len(conditions) # Replace with actual data if available
  1087. id_col = [name] * len(conditions) # Replace with actual data if available
  1088. strain_col = [strain] * len(conditions) # Replace with actual data if available
  1090. # Create DataFrame for export, now including time segments
  1091. df_export = pd.DataFrame({
  1092. **export_data,
  1093. 'condition': conditions,
  1094. **average_cols,
  1095. 'Layer': layer_col,
  1096. 'ID': id_col,
  1097. 'strain': strain_col
  1098. })
  1100. # Export to Excel
  1101. file_name = f"{name}_BandPower_{layer}.xlsx"
  1102. save_path_full = os.path.join(save_path, file_name)
  1104. with pd.ExcelWriter(save_path_full, engine='xlsxwriter') as writer:
  1105. df_export.to_excel(writer, sheet_name='BandPower', index=False)
  1107. print("Data exported successfully.")
  1110. # %%
  1111. import seaborn as sns
  1112. import matplotlib.pyplot as plt
  1114. # Load the exported data from the previous code
  1115. df = pd.read_excel(os.path.join(save_path, file_name))
  1117. # Frequency bands and titles
  1118. bands = ['delta', 'theta', 'beta', 'lowgamma', 'highgamma', 'ripple']
  1119. titles = [
  1120. r'[$\delta$] Power', r'[$\theta$] Power', r'[$\beta$] Power',
  1121. r'low [$\gamma$] Power', r'high [$\gamma$] Power', r'Cortical Ripple Power'
  1122. ]
  1124. # Updated condition labels based on time segments and groups
  1125. xticklabels = [
  1126. 'Vehicle_immediate', 'Vehicle_delayed',
  1127. 'NE_immediate', 'NE_delayed',
  1128. 'NE_YHM_immediate', 'NE_YHM_delayed'
  1129. ]
  1131. # Create subplots for each frequency band
  1132. fig, ax = plt.subplots(nrows=2, ncols=3, figsize=(15, 5))
  1134. # Loop over each frequency band and create a plot
  1135. for i, band in enumerate(bands):
  1136. row, col = divmod(i, 3) # Determine row and column for each subplot
  1138. # Create boxplot for each condition and frequency band
  1139. sns.boxplot(data=df, x='condition', y=band, ax=ax[row, col], showfliers=False)
  1141. # Create swarmplot (or stripplot) to show individual points on top of the boxplot
  1142. sns.stripplot(data=df, x='condition', y=band, color='k', ax=ax[row, col], dodge=True)
  1144. # Set the x-axis labels to the updated condition names
  1145. ax[row, col].set_xticklabels(xticklabels)
  1146. ax[row, col].tick_params(axis='x', rotation=90, size= 2) # Rotate x-axis labels for readability
  1148. # Set title for each subplot based on the band
  1149. ax[row, col].set_title(titles[i])
  1151. # Set y-axis to log scale for better visualization of power values
  1152. ax[row, col].set_yscale("log")
  1154. # Remove top and right spines to make the plot look cleaner
  1155. ax[row, col].spines['top'].set_visible(False)
  1156. ax[row, col].spines['right'].set_visible(False)
  1158. # Set y-axis label for the first subplot
  1159. if band == 'delta':
  1160. ax[row, col].set_ylabel('Power [\u03bc$V^2$]')
  1162. # Adjust the layout for better spacing
  1163. plt.tight_layout()
  1165. # Save the figure as a PDF
  1166. plt.savefig(os.path.join(save_path, name + 'BandPower_L5.pdf'), bbox_inches='tight')
  1168. # Show the plot
  1169. plt.show()
  1173. # %%
  1174. import numpy as np
  1175. from scipy import signal
  1176. import matplotlib.pyplot as plt
  1177. import os
  1178. import seaborn as sns
  1180. # Helper function to append suffix to filenames
  1181. def save_figure_with_suffix(filename_base, suffix='_L5', save_path='.', ext='svg'):
  1182. filename = f"{filename_base}{suffix}.{ext}"
  1183. plt.savefig(os.path.join(save_path, filename), bbox_inches='tight')
  1185. # Coherence calculation for data within layer 2/3
  1186. def calculate_coherence(data_list, sf, freq_range=None):
  1187. num_channels = len(data_list)
  1188. coherence_matrix = np.zeros((num_channels, num_channels))
  1190. # Loop through all pairs of channels
  1191. for i in range(num_channels):
  1192. for j in range(i + 1, num_channels):
  1193. f, Cxy = signal.coherence(data_list[i], data_list[j], fs=sf, nperseg=1024)
  1195. if freq_range:
  1196. # Find indices within the desired frequency range
  1197. freq_indices = np.where((f >= freq_range[0]) & (f <= freq_range[1]))
  1198. coherence_matrix[i, j] = np.mean(Cxy[freq_indices])
  1199. else:
  1200. coherence_matrix[i, j] = np.mean(Cxy)
  1202. return coherence_matrix
  1204. def plot_coherence_matrix(matrix, title='', vmin=None, vmax=None):
  1205. plt.figure(figsize=(7, 5))
  1206. ax = sns.heatmap(matrix, annot=False, cmap='hot', vmin=vmin, vmax=vmax, cbar_kws={'label': 'Coherence'})
  1207. ax.set_title(title)
  1208. ax.set_xlabel('Channel')
  1209. ax.set_ylabel('Channel')
  1211. # Define start and end times for base and stim32 separately
  1212. intervals = [(0, -1)]
  1214. fs = target_sf
  1215. # Extract data segments for baseline and stimulation
  1216. clean_data_Vehicle = [data[start * fs:end * fs] for data in clean_data_vehicle for start, end in intervals]
  1217. clean_data_NE = [data[start * fs:end * fs] for data in clean_data_GFC for start, end in intervals]
  1218. clean_data_NE_YHM = [data[start * fs:end * fs] for data in clean_data_GFC_DOB for start, end in intervals]
  1221. # Calculate coherence matrices
  1222. coherence_matrix_Vehicle = calculate_coherence(clean_data_Vehicle, sf=target_sf, freq_range=(30, 80))
  1223. coherence_matrix_NE = calculate_coherence(clean_data_NE, sf=target_sf, freq_range=(30, 80))
  1224. coherence_matrix_NE_YHM = calculate_coherence(clean_data_NE_YHM, sf=target_sf, freq_range=(30, 80))
  1227. # Find global min and max values for the color scale
  1228. min_coherence = min(coherence_matrix_Vehicle.min(), coherence_matrix_NE.min(),
  1229. coherence_matrix_NE_YHM.min(), )
  1230. max_coherence = max(coherence_matrix_Vehicle.max(), coherence_matrix_NE.max(),
  1231. coherence_matrix_NE_YHM.max())
  1233. # Plot and save coherence matrices
  1234. for matrix, label in zip([coherence_matrix_Vehicle, coherence_matrix_NE, coherence_matrix_NE_YHM, ],
  1235. ["Vehicle", "NE", "NE_YHM", ]):
  1236. plot_coherence_matrix(matrix, title=f"Coherence Matrix - {label}", vmin=min_coherence, vmax=max_coherence)
  1237. save_figure_with_suffix(f'coherence_matrix_{label}', save_path=save_path_coherence)
  1238. plt.show()
  1240. # Calculate and print average coherence for quantification
  1241. coherence_avgs = {
  1242. "Vehicle": np.mean(coherence_matrix_Vehicle[coherence_matrix_Vehicle > 0]),
  1243. "NE": np.mean(coherence_matrix_NE[coherence_matrix_NE > 0]),
  1244. "NE_YHM": np.mean(coherence_matrix_NE_YHM[coherence_matrix_NE_YHM > 0]),
  1246. }
  1248. for label, avg in coherence_avgs.items():
  1249. print(f"Average Coherence - {label}:", avg)
  1252. # %% [markdown]
  1253. # # Preferred Phase
  1255. # %%
  1256. # The preferred phase is given by the phase bin at which the amplitude is maximum. Said differently,
  1257. # the gamma amplitude is binned according to the alpha phase. The preferred-phase is computed as the
  1258. # maximum of this histogram. To identify this preferred-phase, we propose here a polar plotting method to
  1259. # visualize retrieve the previous result using the histogram method
  1261. # %%
  1262. data_vehicle= []
  1263. data_GFC= []
  1264. data_GFC_DOB= []
  1266. start = 38
  1267. end = 98
  1268. fs = target_sf
  1270. for i in range(len(clean_data_vehicle)):
  1271. data_vehicle.append(downsample_data(clean_data_vehicle[i][start * fs:end * fs], sf, target_sf)[0]) # [::10] is used for downsampling and faster process
  1272. data_GFC.append(downsample_data(clean_data_GFC[i][start * fs:end * fs], sf, target_sf)[0])
  1273. data_GFC_DOB.append(downsample_data(clean_data_GFC_DOB[i][start * fs:end * fs], sf, target_sf)[0])
  1278. # %% [markdown]
  1279. # # PAC (Phase-amplitude coupling) Theta-Gamma
  1281. # %% [markdown]
  1282. # # stop ! Change the NAME of the drug
  1284. # %%
  1285. sf = target_sf
  1286. p_obj = Pac(idpac=(4, 0, 0), f_pha=(1, 30, 1, .2), f_amp=(1, 200, 1, 2)) # 1-30 DTAB
  1287. pha = p_obj.filter(sf, np.array(data_vehicle), ftype='phase', n_jobs=-1)
  1288. amp = p_obj.filter(sf, np.array(data_vehicle), ftype='amplitude', n_jobs=-1)
  1289. pac_vehicle = p_obj.fit(pha, amp)
  1291. pha = p_obj.filter(sf, np.array(data_GFC), ftype='phase', n_jobs=-1)
  1292. amp = p_obj.filter(sf, np.array(data_GFC), ftype='amplitude', n_jobs=-1)
  1293. pac_GFC = p_obj.fit(pha, amp)
  1295. pha = p_obj.filter(sf, np.array(data_GFC_DOB), ftype='phase', n_jobs=-1)
  1296. amp = p_obj.filter(sf, np.array(data_GFC_DOB), ftype='amplitude', n_jobs=-1)
  1297. pac_GFC_DOB = p_obj.fit(pha, amp)
  1303. # ################# saving ndarrays
  1304. import numpy as np
  1305. from pathlib import Path
  1307. path = Path(save_path).expanduser()
  1308. path.mkdir(parents=True, exist_ok=True)
  1310. np.save(path/(name + layer + '_pac_vehicle'), pac_vehicle)
  1311. np.save(path/(name + layer + '_pac_NE'), pac_GFC)
  1312. np.save(path/(name + layer + '_pac_NE_YHM'), pac_GFC_DOB)
  1319. # %%
  1320. import matplotlib.pyplot as plt
  1321. import numpy as np
  1323. condition= ['Vehicle', 'NE',
  1324. 'NE_YHM',
  1325. ]
  1326. pac = [pac_vehicle, pac_GFC,
  1327. pac_GFC_DOB,
  1328. ]
  1330. # Set up the figure size for the plot
  1331. plt.figure(figsize=(12, 9))
  1333. # Initialize variable to store the global vmax
  1334. global_vmax = -np.inf # Start with a very low value
  1336. # First loop to determine global vmax
  1337. for k in pac:
  1338. pacc = k.mean(axis=1) # Compute the mean across time points/trials
  1339. global_vmax = max(global_vmax, pacc.max()) # Update global vmax with the max value across all conditions
  1341. # Loop through each condition and its corresponding PAC
  1342. for i, (k, cond) in enumerate(zip(pac, condition)):
  1343. pacc = k.mean(axis=-1)
  1345. # Check the shape of pacc after mean calculation
  1346. print(f"Shape of pacc for {cond}: {pacc.shape}")
  1348. # Set up the color scaling using the global vmax
  1349. kw = dict(vmax=global_vmax, vmin=0, cmap='jet')
  1351. # Plotting the comodulogram
  1352. plt.subplot(2, 2, i + 1)
  1353. p_obj.comodulogram(pacc, title=f"PAC {cond}", **kw)
  1355. # Adding vertical lines at specific points for reference
  1356. plt.axvline(x=4, color='k', linestyle='--', linewidth=2.0)
  1357. plt.axvline(x=10, color='k', linestyle='--', linewidth=2.0)
  1359. # Adjust layout for better spacing
  1360. plt.tight_layout()
  1362. ####### Saving
  1363. import os.path
  1364. fileName = name2
  1365. plt.savefig(os.path.join(save_path , fileName + layer + '_PAC.svg'),bbox_inches = 'tight')
  1366. plt.savefig(os.path.join(save_path , fileName + layer + '_PAC.pdf'), bbox_inches = 'tight')
  1368. # %%
  1371. # %% [markdown]
  1372. # # Preferred Phase Theta-Gamma
  1374. # %% [markdown]
  1375. # # stop ! Change the NAME of the drug
  1377. # %%
  1378. # define the preferred phase object
  1379. sf = target_sf
  1380. # pp_obj = PreferredPhase(f_pha=[1, 4], f_amp=(30, 100, 2, 2)) # alpha (1-4 Hz)
  1381. pp_obj = PreferredPhase(f_pha=[4,8], f_amp=(30, 200, 2, 2)) # THETA (4-8 Hz)
  1382. n_jobs = -1
  1383. # compute the preferred phase (reuse the amplitude computed above)
  1384. pha_vehicle = pp_obj.filter(sf, np.array(data_vehicle), ftype='phase', n_jobs=n_jobs)
  1385. amp_vehicle = pp_obj.filter(sf, np.array(data_vehicle), ftype='amplitude', n_jobs=n_jobs)
  1386. pha_GFC = pp_obj.filter(sf, np.array(data_GFC), ftype='phase', n_jobs=n_jobs)
  1387. amp_GFC = pp_obj.filter(sf, np.array(data_GFC), ftype='amplitude', n_jobs=n_jobs)
  1388. pha_GFC_DOB = pp_obj.filter(sf, np.array(data_GFC_DOB), ftype='phase', n_jobs=n_jobs)
  1389. amp_GFC_DOB = pp_obj.filter(sf, np.array(data_GFC_DOB), ftype='amplitude', n_jobs=n_jobs)
  1394. ampbin_vehicle, _, vecbin = pp_obj.fit(pha_vehicle, amp_vehicle, n_bins=72)
  1395. ampbin_GFC, _, vecbin = pp_obj.fit(pha_GFC, amp_GFC, n_bins=72)
  1396. ampbin_GFC_DOB, _, vecbin = pp_obj.fit(pha_GFC_DOB, amp_GFC_DOB, n_bins=72)
  1400. # mean binned amplitude across trials
  1401. ampbin_vehicle = np.squeeze(ampbin_vehicle).mean(-1).T
  1402. ampbin_GFC = np.squeeze(ampbin_GFC).mean(-1).T
  1403. ampbin_GFC_DOB = np.squeeze(ampbin_GFC_DOB).mean(-1).T
  1408. ################# saving ndarrays theta
  1409. import numpy as np
  1410. from pathlib import Path
  1412. path.mkdir(parents=True, exist_ok=True)
  1414. np.save(path/(name2 + layer + '_ampbin_vehicle'), ampbin_vehicle)
  1415. np.save(path/(name2 + layer + '_ampbin_NE'), ampbin_GFC)
  1416. np.save(path/(name2 + layer + '_ampbin_NE_YHM'), ampbin_GFC_DOB)
  1423. # %%
  1424. import numpy as np
  1425. import matplotlib.pyplot as plt
  1427. # List of all the amplitude bins (all frequency conditions)
  1428. ampbins = [ampbin_vehicle, ampbin_GFC, ampbin_GFC_DOB, ]
  1430. # Find the global minimum and maximum values across all amplitude bins
  1431. global_min = np.min([np.min(amp) for amp in ampbins])
  1432. global_max = np.max([np.max(amp) for amp in ampbins])
  1434. # Now set vmin and vmax to these global values
  1435. vmin_value = global_min
  1436. vmax_value = global_max
  1438. # Define the plotting dictionary with consistent color range
  1439. kw_plt = dict(cmap='RdBu_r', interp=0.1, cblabel='Bins Amplitude',
  1440. colorbar=True, y=1.3, fz_title=20, plotas='contour',
  1441. vmin=vmin_value, vmax=vmax_value)
  1443. # Create the figure
  1444. plt.figure(figsize=(27, 23))
  1446. # Plot the data for each frequency condition using the updated kw_plt dictionary
  1447. pp_obj.polar(ampbin_vehicle, vecbin, pp_obj.yvec, subplot=331, title='vehicle', **kw_plt)
  1448. pp_obj.polar(ampbin_GFC, vecbin, pp_obj.yvec, subplot=332, title='NE', **kw_plt)
  1449. pp_obj.polar(ampbin_GFC_DOB, vecbin, pp_obj.yvec, subplot=333, title='NE_YHM', **kw_plt)
  1453. # Adjust layout to prevent overlapping elements
  1454. plt.tight_layout()
  1456. # ########### Saving
  1457. # import os.path
  1458. # fileName = name2
  1459. # plt.savefig(os.path.join(save_path , fileName + layer + '_PreferredPhase_ThetaGamma.pdf'), bbox_inches = 'tight')
  1461. # %%
  1464. # %%
  1467. # %%
  1470. # %%
  1473. # %%
  1476. # %%
  1479. # %%
  1482. # %%
  1485. # %%
  1488. # %%
  1491. # %%
  1494. # %%

MEA LFP _ Open OnDemand_LC_mPFC.ipynb at commit 29e3811, no license · at the source

Overview

Authors: Hassan Hosseini1, Sky Evans-Martin1, Emma Bogomilsky1, Kevin S Jones1,2
ORCID iDs: Kevin S Jones
  1. Department of Pharmacology, University of Michigan Medical School, Ann Arbor, Michigan 48109
  2. Neuroscience Graduate Program, University of Michigan Medical School, Ann Arbor, Michigan 48109
Institutions: University of Michigan (United States); Michigan Medicine (United States)
Journal: eNeuro, volume 13, issue 8, pages ENEURO.0050-26.2026
Dates: received 7 February 2026; accepted 17 June 2026; published online 4 August 2026; in print August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1523/eneuro.0050-26.2026 · PMID 42498666 · PMCID PMC13456957 · OpenAlex W7170856490
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: mouse (organism)
Methods: Spectral & time-frequency, Preprocessing, Connectivity, Statistics, fMRI & imaging
Keywords: cognitive flexibility, gamma oscillations, locus ceruleus, medial prefrontal cortex, NMDA receptor GluN2A, norepinephrine
MeSH: Cognitive Flexibility*, Locus Coeruleus*, Norepinephrine*, Prefrontal Cortex*, Receptors, N-Methyl-D-Aspartate*, Animals, Male, Mice, Inbred C57BL, Mice, Knockout, Neural Pathways, Optogenetics, Reversal Learning (* major topic)
Topic: Neuroscience and Neuropharmacology Research (Cellular and Molecular Neuroscience, Neuroscience), according to OpenAlex
Funding: BI | Stanley Center for Psychiatric Research, Broad Institute
Citations: not cited yet (Europe PMC); 33 references in the paper

Abstract

Cognitive flexibility—the ability to adapt behavior when contingencies change—is impaired in psychiatric disorders involving prefrontal dysfunction. The medial prefrontal cortex (mPFC) relies on noradrenergic input from the locus ceruleus (LC), yet the molecular mechanisms enabling this neuromodulatory control remain unclear. Here we show that GluN2A-containing NMDA receptors are required for LC–mPFC regulation of network dynamics and reversal learning in male mice. Optogenetic activation of LC→mPFC projections enhanced reversal learning in wild-type (WT) and heterozygous mice but not in global Grin2a knock-outs, whereas LC inhibition impaired performance only in WT animals. In slices, norepinephrine (NE) and LC stimulation induced gamma and high-frequency oscillations in WT mPFC that were blocked by α2-adrenergic antagonism, but these oscillatory responses were undetectable in Grin2a mutants. Grin2a mutants also exhibited increased LC axonal density and elevated NE transporter expression in the prelimbic cortex, consistent with enhanced noradrenergic clearance capacity. Together, these findings identify GluN2A as a key determinant of LC–prefrontal circuit function supporting cognitive flexibility. They suggest that functional deficits in these mutants should be interpreted within the context of compensatory structural hyperinnervation resulting from global GluN2A deficiency, which may reflect a developmental adaptation rather than acute signaling loss. Furthermore, these results promote α2-adrenergic pathways as potential entry points for restoring prefrontal network coordination.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repositories

Its files are read in the Code ↔ Paper reader above, with 2 matches between paragraphs and lines of code.

NeuroDataa/PatchClampAnalysis

License: none: the authors keep all their rights
State: the link is dead, verified on 27 September 2026
Evidence: found in the paper
Software Heritage: not archived
Found in: the text, “Patch-clamp data analysis”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 27 September 2026: the link is dead
  • 27 September 2026: the link is dead
At the source: github.com/NeuroDataa/PatchClampAnalysis

NeuroDataa/Grin2a_LC_mPFC_pMEA_Analysis

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 29e3811b47f2151df71c5dd3445ada824d04a819, 13 May 2025
Languages: Jupyter (2)
Size: 2 files, 2 scripts
Software Heritage: not archived
Found in: the text, “Multielectrode array (MEA) recordings”
Holds: 2 notebooks
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: h5py (2 files), Matplotlib (2 files), MNE-Python (2 files), NumPy (2 files), pandas (2 files), scikit-learn (2 files), SciPy (2 files), seaborn (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
2 files
At the source: github.com/NeuroDataa/Grin2a_LC_mPFC_pMEA_Analysis

NeuroData/PatchClampAnalysis

License: none: the authors keep all their rights
State: the link is dead, verified on 27 September 2026
Evidence: found in the paper
Software Heritage: not archived
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 27 September 2026: the link is dead
  • 27 September 2026: the link is dead
At the source: github.com/NeuroData/PatchClampAnalysis

NeuroDataa/MEA_Analysis

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 0 files, 0 scripts
Software Heritage: not archived
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
At the source: github.com/NeuroDataa/MEA_Analysis

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 4 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 2 scripts, each with its path and the digest of its content;
  • 2 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data and code availability

All original analysis code generated for this study has been deposited in publicly accessible GitHub repositories:

https://github.com/NeuroData/PatchClampAnalysis https://github.com/NeuroDataa/MEA_Analysis

This study did not generate new or unique reagents.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 6 keywords, 12 MeSH terms, 1 funder, 33 references.

Cite

This paper

Hosseini, H., Evans-Martin, S., Bogomilsky, E., & Jones, K. S. (2026). GluN2A Enables Noradrenergic Control of Prefrontal Oscillations and Cognitive Flexibility. eNeuro, 13(8), ENEURO.0050-26.2026. https://doi.org/10.1523/eneuro.0050-26.2026

BibTeX

@article{hosseini2026glun2a,
author = {Hosseini, Hassan and Evans-Martin, Sky and Bogomilsky, Emma and Jones, Kevin S},
title = {{GluN2A Enables Noradrenergic Control of Prefrontal Oscillations and Cognitive Flexibility}},
journal = {eNeuro},
year = {2026},
month = aug,
volume = {13},
number = {8},
pages = {ENEURO.0050--26.2026},
publisher = {Society for Neuroscience},
issn = {2373-2822},
doi = {10.1523/eneuro.0050-26.2026},
url = {https://doi.org/10.1523/eneuro.0050-26.2026},
pmid = {42498666},
pmcid = {PMC13456957}
}

RIS

TY - JOUR
AU - Hosseini, Hassan
AU - Evans-Martin, Sky
AU - Bogomilsky, Emma
AU - Jones, Kevin S
TI - GluN2A Enables Noradrenergic Control of Prefrontal Oscillations and Cognitive Flexibility
T2 - eNeuro
J2 - eNeuro
PY - 2026
DA - 2026/08/07
VL - 13
IS - 8
SP - ENEURO.0050
EP - 26.2026
SN - 2373-2822
PB - Society for Neuroscience
DO - 10.1523/eneuro.0050-26.2026
UR - https://doi.org/10.1523/eneuro.0050-26.2026
LA - en
ER -

CSL-JSON

{
"id": "10.1523/eneuro.0050-26.2026",
"type": "article-journal",
"title": "GluN2A Enables Noradrenergic Control of Prefrontal Oscillations and Cognitive Flexibility",
"container-title": "eNeuro",
"author": [
{
"family": "Hosseini",
"given": "Hassan"
},
{
"family": "Evans-Martin",
"given": "Sky"
},
{
"family": "Bogomilsky",
"given": "Emma"
},
{
"family": "Jones",
"given": "Kevin S"
}
],
"container-title-short": "eNeuro",
"volume": "13",
"issue": "8",
"page": "ENEURO.0050-26.2026",
"DOI": "10.1523/eneuro.0050-26.2026",
"PMID": "42498666",
"PMCID": "PMC13456957",
"ISSN": "2373-2822",
"publisher": "Society for Neuroscience",
"URL": "https://doi.org/10.1523/eneuro.0050-26.2026",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
7
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s41593-026-02258-4 [code]
Laminar organization of cellular microcircuits modulating human interictal epileptiform discharges.
Journal: Nature neuroscience
In common: MNE-Python, seaborn, scikit-learn, 4 other tools, 1 reference
[2] doi:10.3389/fpsyg.2026.1774068 [code]
Analysis of cognitive mechanisms in phoneme perception and pronunciation errors among Korean language learners.
Journal: Frontiers in psychology
In common: MNE-Python, h5py, seaborn, 5 other tools
[3] doi:10.3389/fncom.2026.1786996 [code]
Schumann-anchored golden ratio organization of human neural oscillations.
Journal: Frontiers in computational neuroscience
In common: MNE-Python, h5py, seaborn, 5 other tools
[4] doi:10.1038/s41598-026-50946-9 [code]
Fixation-related potentials reveal that confusing program code elicits a late frontal positivity.
Journal: Scientific reports
In common: MNE-Python, h5py, seaborn, 5 other tools
[5] doi:10.1038/s41593-026-02285-1 [code]
Fixation duration on natural scenes is explained by memory encoding not processing demand.
Journal: Nature neuroscience
In common: MNE-Python, h5py, seaborn, 5 other tools
[6] doi:10.1162/imag.a.1227 [code]
Large language models reveal the neural tracking of linguistic context in attended and unattended multi-talker speech.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MNE-Python, h5py, seaborn, 5 other tools
[7] doi:10.1038/s41531-026-01372-1 [code]
Varying patterns of association between cortical large-scale networks and subthalamic nucleus activity in Parkinson's disease.
Journal: NPJ Parkinson's disease
In common: MNE-Python, h5py, seaborn, 5 other tools
[8] doi:10.7554/elife.106543 [code]
Stimulus dependencies-rather than next-word prediction-can explain pre-onset brain encoding in naturalistic listening designs.
Journal: eLife
In common: MNE-Python, h5py, seaborn, 5 other tools
[9] doi:10.1117/1.nph.13.2.025001 [code]
Surface-based image reconstruction optimization for high-density functional near-infrared spectroscopy.
Journal: Neurophotonics
In common: MNE-Python, h5py, seaborn, 5 other tools
[10] doi:10.1038/s41597-025-05174-7 [code]
A large-scale MEG and EEG dataset for object recognition in naturalistic scenes
Journal: n/a
In common: MNE-Python, h5py, seaborn, 5 other tools

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.