OSCR

High-speed whole-brain imaging in Drosophila.

Code ↔ Paper

10 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 10 matches
  1. [1] § Methods › Data analysis › Fourier analyses ↔ analysis_scripts/functions.py, lines 551–685 · score 0.74 · Fourier spectrum, absolute power, stimulus block, fft, scipy, subtracted
  2. [2] § Results › Resolving neural activity underlying individual song pulses ↔ analysis_scripts/functions.py, lines 786–868 · score 0.74 · 27–28 Hz, Fourier spectrum, absolute power, frame rate, IPI, peak
  3. [3] § Results › Capturing fast dynamics across the entire brain ↔ analysis_scripts/functions.py, lines 1108–1163 · score 0.64 · Correlation coefficients, highest correlation, ROIs extracted, Auditory stimulus, cutoff, Activity
  4. [4] § Results › Resolving neural activity underlying individual song pulses ↔ analysis_scripts/functions.py, lines 786–868 · score 0.63 · 27–28 Hz, Fourier spectrum, absolute power, IPI, peak, trace
  5. [5] § Methods › Data analysis › Identification of stimulus-modulated ROIs ↔ analysis_scripts/functions.py, lines 114–216 · score 0.61 · correlation coefficient, correlated ROIs, auditory stimulus, subset
  6. [6] § Methods › Data analysis › Identification of stimulus-modulated ROIs ↔ analysis_scripts/Suppl_figs.py, lines 101–167 · score 0.61 · correlation coefficient, convolving, kernel, rise, decay, scored
  7. [7] § Methods › Image processing and signal extraction ↔ dellaserver_processing/brainviz/roi.py, lines 26–55 · score 0.57 · agglomerative clustering, Ward, linkage, voxel, slice, brain
  8. [8] § Methods › Animal auditory stimulation and behavior recording ↔ flyvr/fictrac/fictrac_driver.py, lines 92–211 · score 0.57 · fly vr, Fictrac, tracked, setup
  9. [9] § Methods › Animal auditory stimulation and behavior recording ↔ matlab/audio_calibration/CalibrateSound_WhiteNoise_flyVR.m, lines 128–229 · score 0.55 · fly vr, Auditory stimuli, MATLAB, sound, Audio
  10. [10] § Results › Capturing fast dynamics across the entire brain ↔ analysis_scripts/Suppl_figs.py, lines 101–167 · score 0.54 · convolved stimulus, Correlation coefficients, kernel, duration, scored, blocks

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

Python · 1,483 lines · 55 KB · no license · 5 matches

  1. # -*- coding: utf-8 -*-
  4. import numpy as np
  7. import matplotlib.pyplot as plt
  8. from scipy.stats import zscore
  9. from scipy.stats import sem
  10. from scipy.fft import rfftfreq
  11. import scipy.fft
  12. from scipy.signal import find_peaks
  13. import matplotlib
  14. from scipy.interpolate import interp1d
  15. from typing import Optional, Tuple
  17. matplotlib.rcParams['pdf.fonttype'] = 42
  18. matplotlib.rcParams['ps.fonttype'] = 42
  22. def create_stim(dffs, start_block_seconds,end_block_seconds ,frame_rate, t_i2c=0):
  23. """
  24. Description
  25. ----------
  26. This function creates a continuous version of the stimulus (array of 0 or 1) with the same shape as the activity
  27. ----------
  29. Parameters
  30. ----------
  31. dffs (np.ndarray)
  32. Array containing the calcium activity over time, each row is an ROI.
  33. start_block_seconds (np.ndarray)
  34. array containing the start of each block of stimulus in seconds
  35. end_block_seconds (np.ndarray)
  36. array containing the end of each block of stimulus in seconds
  37. t_i2c (float)
  38. The first time point received by I2C. Set to 0 if data is already aligned
  39. frame_rate (float)
  40. frame rate of the scope
  41. ----------
  43. Returns
  44. ----------
  45. continuous_stim
  46. An array of 0 and 1s when stimulus is off and on respectively
  47. ----------
  49. """
  50. # Get index of start and end
  51. s = (start_block_seconds)*frame_rate
  52. e = (end_block_seconds )*frame_rate
  54. continuous_stim = []
  55. for ii in range(int((t_i2c)*frame_rate)):
  56. continuous_stim.append(0)
  58. for ii in range(dffs.shape[1]-int((t_i2c)*frame_rate)):
  59. if (s[0]<ii<e[0]) or (s[1]<ii<e[1]) or (s[2]<ii<e[2]) or (s[3]<ii<e[3]) or (s[4]<ii<e[4]) or (s[5]<ii<e[5]) or (s[6]<ii<e[6]) or (s[7]<ii<e[7]) or (s[8]<ii<e[8]) or (s[9]<ii<e[9]) or (s[10]<ii<e[10]) or (s[11]<ii<e[11]) or (s[12]<ii<e[12]):
  60. continuous_stim.append(1)
  61. else:
  62. continuous_stim.append(0)
  64. return (continuous_stim)
  68. def create_stim_train(dffs, start_block_seconds,end_block_seconds ,frame_rate, t_i2c=0):
  69. """
  70. Description
  71. ----------
  72. This function creates a continuous version of the stimulus (array of 0 or 1) with the same shape as the activity
  73. ----------
  75. Parameters
  76. ----------
  77. dffs (np.ndarray)
  78. Array containing the calcium activity over time, each row is an ROI.
  79. start_block_seconds (np.ndarray)
  80. array containing the start of each block in seconds
  81. end_block_seconds (np.ndarray)
  82. array containing the end of each block in seconds
  83. t_i2c (float)
  84. The first time point received by I2C. Set to 0 is data is already aligned
  85. frame_rate (float)
  86. frame rate of the scope
  87. ----------
  89. Returns
  90. ----------
  91. continuous_stim
  92. An array of 0 and 1s when stimulus is off and on respectively
  93. ----------
  95. """
  96. # Get index of start and end
  97. s = (start_block_seconds)*frame_rate
  98. e = (end_block_seconds )*frame_rate
  100. continuous_stim = []
  101. for ii in range(int((t_i2c)*frame_rate)):
  102. continuous_stim.append(0)
  104. for ii in range(dffs.shape[1]-int((t_i2c)*frame_rate)):
  105. if (s[0]<ii<e[0]) or (s[1]<ii<e[1]) or (s[2]<ii<e[2]) or (s[3]<ii<e[3]) or (s[4]<ii<e[4]) or (s[5]<ii<e[5]) or (s[6]<ii<e[6]) or (s[7]<ii<e[7]) or (s[8]<ii<e[8]) or (s[9]<ii<e[9]) or (s[10]<ii<e[10]) or (s[11]<ii<e[11]) or (s[12]<ii<e[12]) or (s[13]<ii<e[13]):
  106. continuous_stim.append(0.15)
  107. else:
  108. continuous_stim.append(0)
  110. return (continuous_stim)
  114. def crosscorr_sort(dffs, stimulus,cutoff,frame_rate,max_lag=0):
  115. """
  116. Description
  117. ----------
  118. This function computes the cross correlation between the calcium activity and the auditory stimulus and extract the top cutoff % of ROIs based on the correlation coefficient.
  119. ----------
  121. Parameters
  122. ----------
  123. dffs (np.ndarray)
  124. Array containing the calcium activity over time, each row is an ROI.
  125. stimulus (np.ndarray)
  126. array containing the auditory stimulus
  127. cutoff (float)
  128. threshold in percentage to use when extracting the top X% based on correlation
  129. max_lag (float)
  130. the lag over which to compute the cross correlation
  131. frame_rate (float)
  132. frame rate of the scope
  133. ----------
  135. Returns
  136. ----------
  137. audio_correlated, corr_coeff, correlations, sorted_indices
  138. array containing the index of the top 'cutoff'% ROIs with the highest correlation coefficient with the stimulus
  140. corr_coeff
  141. array containing the correlation coefficient of the extracted ROIs in audio_correlated
  143. correlations
  144. array containing the correlation coefficients of all ROIs in dffs
  146. ----------
  148. """
  150. # Normalize the activity and the stimulus
  151. dffs_mean = dffs.mean(axis=1, keepdims=True)
  152. dffs_std = dffs.std(axis=1, keepdims=True)
  153. dffs_normalized = (dffs - dffs_mean) / dffs_std
  155. stimulus_normalized = (stimulus - stimulus.mean()) / stimulus.std()
  157. # define index cutoff
  158. index_cutoff = int(dffs.shape[0] * (cutoff/100))
  160. # If we don't want any lag
  161. if max_lag == 0:
  162. # Compute correlations
  163. correlations = np.dot(dffs_normalized, stimulus_normalized.T) / dffs_normalized.shape[1]
  164. correlations = correlations.flatten()
  166. rois = np.arange(0,dffs.shape[0])
  167. rois = rois[~np.isnan(correlations)]
  169. correlations = correlations[~np.isnan(correlations)]
  171. #sort the correlation coefficients and rois
  172. sorted_indices = np.argsort(correlations)
  173. sorted_corr = correlations[sorted_indices]
  174. sorted_rois = rois[sorted_indices]
  176. # Extract the top X%
  177. audio_correlated = sorted_rois[-index_cutoff:]
  178. corr_coeff = sorted_corr[-index_cutoff:]
  179. # Result: correlations is a 1D array of shape (number of ROIs,)
  181. else:
  182. # Compute correlations for different lags
  183. num_rois, time_points = dffs.shape
  184. lags = np.arange(int(-max_lag*frame_rate), int(max_lag*frame_rate) + 1,int(0.5*frame_rate))
  185. correlation_matrix = np.zeros((num_rois, len(lags)))
  186. for i, lag in enumerate(lags):
  187. if lag < 0:
  188. # Shift auditory stimulus forward
  189. shifted_stimulus = stimulus_normalized[-lag:]
  190. activity_subset = dffs_normalized[:, :len(shifted_stimulus)]
  191. elif lag > 0:
  192. # Shift auditory stimulus backward
  193. shifted_stimulus = stimulus_normalized[:-lag]
  194. activity_subset = dffs_normalized[:, lag:]
  196. # Compute correlations for the current lag
  197. correlation_matrix[:, i] = (
  198. np.dot(activity_subset, shifted_stimulus) / len(shifted_stimulus)
  199. )
  201. # Find the best correlation across all lags for each ROI
  202. correlations = np.max(np.abs(correlation_matrix), axis=1)
  203. #best_lags = lags[np.argmax(np.abs(correlation_matrix), axis=1)]
  204. rois = np.arange(0,dffs.shape[0])
  205. rois = rois[~np.isnan(correlations)]
  206. correlations = correlations[~np.isnan(correlations)]
  207. #sort the correlation and rois
  208. sorted_indices = np.argsort(correlations)
  209. sorted_corr = correlations[sorted_indices]
  210. sorted_rois = rois[sorted_indices]
  212. audio_correlated = sorted_rois[-index_cutoff:]
  213. corr_coeff = sorted_corr[-index_cutoff:]
  215. print('number of audio correlated ROIs: {}'.format(len(audio_correlated)))
  216. return(audio_correlated, corr_coeff, correlations, sorted_indices[-index_cutoff:])
  220. def truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):
  221. if isinstance(cmap, str):
  222. cmap = plt.get_cmap(cmap)
  223. new_cmap = matplotlib.colors.LinearSegmentedColormap.from_list(
  224. 'trunc({n},{a:.2f},{b:.2f})'.format(n=cmap.name, a=minval, b=maxval),
  225. cmap(np.linspace(minval, maxval, n)))
  226. return new_cmap
  230. def compute_mean_time_series_per_block_pair(dffs, time_activity, frame_rate, start_block_seconds, end_block_seconds, t_added, scope):
  231. """
  232. Description
  233. ----------
  234. This function computes the mean activity across all ROIs during the two presentation of stimulus block with the same frequency.
  235. ----------
  237. Parameters
  238. ----------
  239. dffs (np.ndarray)
  240. Array containing the calcium activity over time, each row is an ROI.
  241. time_activity (np.ndarray)
  242. array containing the time for each calcium trace
  243. frame_rate (float)
  244. frame rate of the scope
  245. start_block_seconds (np.ndarray)
  246. array containing the start of each block in seconds
  247. end_block_seconds (np.ndarray)
  248. array containing the end of each block in seconds
  249. t_added (float)
  250. Time to add around each block for visualization purposes
  251. scope (str)
  252. 'LB' or '2p' to specify which scope was used to aquire the data
  254. ----------
  256. Returns
  257. ----------
  258. block_pair_traces (shape: (n_block_pairs, samples_per_block))
  259. array containing the mean activity across all ROIs during each block of stimulus with different frequencies
  261. block_pair_sem (shape: (n_block_pairs, samples_per_block))
  262. array containing the sem of the activity across all ROIs during each block of stimulus with different frequencies
  264. ----------
  266. """
  268. n_blocks = len(start_block_seconds)
  269. assert n_blocks % 2 == 0, "Number of blocks must be even"
  271. block_pair_traces = []
  272. block_pair_sem=[]
  274. for i in range(0, n_blocks, 2):
  275. pair_traces = []
  276. pair_sem = []
  278. for j in [i, i + 1]: # handle each of the two blocks in the pair
  279. start_time = start_block_seconds[j]-t_added
  280. end_time = end_block_seconds[j]+t_added
  281. samples_per_block = int((end_time-start_time) * frame_rate)
  283. # Get mask for time points in this block
  284. mask = (time_activity >= start_time) & (time_activity <= end_time)
  285. if scope == '2p':
  286. samples_per_block+=1
  287. if (i==10) and (j==11):
  288. mask = np.hstack(( np.array(np.where(mask)[0][0]-1) , np.where(mask)[0] ))
  289. block_data = dffs[:, mask]
  291. if block_data.shape[1] != samples_per_block:
  292. raise ValueError(f"Block {j+1} does not contain {samples_per_block} samples. Got {block_data.shape[1]}.")
  294. # Average across ROIs
  295. mean_trace = np.mean(block_data, axis=0)
  296. pair_traces.append(mean_trace)
  297. sem_trace = sem(block_data, axis=0)
  298. pair_sem.append(sem_trace)
  300. # Average the two blocks
  301. mean_pair_trace = np.mean(pair_traces, axis=0)
  302. block_pair_traces.append(mean_pair_trace)
  303. sem_pair_trace = np.mean(sem_trace, axis=0)
  304. block_pair_sem.append(sem_pair_trace)
  306. return np.stack(block_pair_traces, axis=0),np.stack(block_pair_sem, axis=0)
  310. def extract_single_stimulus_per_block_pair(stimulus, time_audio, frame_rate, start_block_seconds,end_block_seconds,t_added):
  311. """
  312. Description
  313. ----------
  314. This function extract the auditory stimulus during each block presentation for plotting purposes in other functions.
  315. ----------
  317. Parameters
  318. ----------
  319. stimulus (np.ndarray)
  320. array containing the auditory stimulus
  321. time_audio (np.ndarray)
  322. array containing the time for the auditory stimulus
  323. frame_rate (float)
  324. frame rate of the scope
  325. start_block_seconds (np.ndarray)
  326. array containing the start of each block in seconds
  327. end_block_seconds (np.ndarray)
  328. array containing the end of each block in seconds
  329. t_added (float)
  330. Time to add around each block for visualization purposes
  333. ----------
  335. Returns
  336. ----------
  337. stim_traces (shape: (n_block_pairs, samples_per_block))
  338. array containing the stimulus during each block of stimulus of a given frequency
  341. ----------
  343. """
  344. samples_per_block = int((10+t_added+t_added) * frame_rate)
  345. n_blocks = len(start_block_seconds)
  346. assert n_blocks % 2 == 0, "Number of blocks must be even"
  348. stim_traces = []
  350. for i in range(0, n_blocks, 2): # take the first block in each pair
  351. start_time = start_block_seconds[i]-t_added
  352. end_time = end_block_seconds[i] +t_added # 10s block
  354. mask = (time_audio >= start_time) & (time_audio < end_time)
  355. stim_block = stimulus[mask]
  357. if stim_block.shape[0] != samples_per_block:
  358. raise ValueError(f"Stimulus block {i+1} has {stim_block.shape[0]} samples; expected {samples_per_block}.")
  360. stim_traces.append(stim_block)
  362. return np.stack(stim_traces, axis=0)
  368. def plot_calcium_with_stimulus_overlay(mean_traces,sem_traces, stim_traces, frame_rate,path, scope):
  369. """
  370. Description
  371. ----------
  372. This function plots the mean activity across all ROIs during the two presentation of stimulus block of a given frequency overlayed with the auditory stimulus.
  373. ----------
  375. Parameters
  376. ----------
  377. mean_traces (nd.array)
  378. array containing the mean activity across all ROIs during each block of stimulus with different frequencies
  379. sem_traces (nd.array)
  380. array containing the sem of the activity across all ROIs during each block of stimulus with different frequencies
  381. stim_traces (np.ndarray)
  382. array containing the stimulus during each block of stimulus of a given frequency
  383. time_activity (np.ndarray)
  384. array containing the time for each calcium trace
  385. frame_rate (float)
  386. frame rate of the scope
  387. path (str)
  388. Path to folder where to save the plots. If set to None, plots won't be saved.
  389. scope (str)
  390. 'LB' or '2p' to specify which scope was used to aquire the data
  392. ----------
  393. """
  395. if scope == 'LB':
  396. col = 'g'
  397. else:
  398. col = 'm'
  400. fr = 1/frame_rate
  401. n_pairs, samples_per_block = mean_traces.shape
  402. time_axis = np.arange(0,(samples_per_block)*fr,fr)
  404. fr_stim = 1/100
  405. samples_per_block_stim = np.shape(stim_traces[0])[0]
  406. t_stim = np.arange(0,(float(samples_per_block_stim))*fr_stim,fr_stim)
  409. for i in range(n_pairs):
  410. max_trace = np.max(mean_traces[i] + sem_traces[i])
  411. #min_trace = np.min(mean_traces[i] + sem_traces[i])
  412. height1 = 0.006
  413. height2 = 0.085
  414. plt.figure(figsize = (8,5))
  415. plt.plot(time_axis, mean_traces[i],color= col,alpha = 1, lw = 2.5)
  416. plt.fill_between(t_stim,y1=(max_trace*stim_traces[i])+ height1,y2=(max_trace*stim_traces[i])+height2,where =stim_traces[i]>0,color='r',alpha=1)
  417. plt.fill_between(time_axis,y1=(mean_traces[i] + sem_traces[i]),y2=( mean_traces[i] - sem_traces[i]),color=col,alpha=0.4)
  418. plt.xlabel('Time (s)', fontsize = 36)
  419. plt.ylabel('Z(DF/F)', fontsize = 36)
  420. plt.locator_params(axis='y', nbins=5)
  421. plt.xlim(0,time_axis[-1])
  422. plt.xticks(fontsize = 34)
  423. plt.yticks(fontsize = 34)
  424. plt.locator_params(axis='y', nbins=3)
  425. plt.tight_layout()
  427. if path != None:
  428. plt.savefig(path + 'mean_activity_cluster_block_' + str(i) + '_2p' + '.pdf', transparent = True)
  435. def fourier_mean_activity_interpolate(dffs,start_block_seconds,end_block_seconds,t_added,frame_rate,time_activity,scope, target_frame_rate,N_target, path,xlim, col):
  436. """
  437. Description
  438. ----------
  439. This function computes and plots the fourier spectrum of the mean activity for each block pair of a given frequency
  440. ----------
  442. Parameters
  443. ----------
  444. dffs (np.ndarray)
  445. Array containing the calcium activity over time, each row is an ROI.
  446. start_block_seconds (np.ndarray)
  447. array containing the start of each block in seconds
  448. end_block_seconds (np.ndarray)
  449. array containing the end of each block in seconds
  450. t_added (float)
  451. Time to add around each block for visualization purposes
  452. frame_rate (float)
  453. frame rate of the scope
  454. time_activity (np.ndarray)
  455. array containing the time for each calcium trace
  456. scope (str)
  457. Either 'LB' or '2p'
  458. Hz_target (float)
  459. Target frame rate when interpolating 2p
  460. N_target (float)
  461. Target number of samples when interpolating 2p
  462. path (float)
  463. Path to folder where to save the plots. If set to None, plots won't be saved.
  464. xlim (float)
  465. maximum of x axis for plotting
  466. col (float)
  467. color for plotting
  468. ----------
  469. """
  470. b = 1 # Index that keeps track of the stimulus blocks
  471. # Loop through each pair of stimulus blocks
  472. for k in range(6):
  473. # Grab first block
  474. t_sart = start_block_seconds[b]
  475. t_end = end_block_seconds[b] +t_added
  476. N = int((t_end-t_sart)*frame_rate)
  477. t_act = np.linspace(t_sart,t_end,N)
  478. start_act = np.argwhere((t_sart-time_activity)<0.001)[0][0]
  479. end_act = np.argwhere((t_end-time_activity)<0.001)[0][0]
  480. if (end_act-start_act)>(len(t_act)):
  481. end_act = end_act - ((end_act-start_act)-len(t_act))
  482. if len(dffs.shape)>1:
  483. activity_block1 = dffs[:,start_act:end_act]
  484. else:
  485. activity_block1 = dffs[start_act:end_act]
  486. # Grab second block
  487. t_sart = start_block_seconds[b+1]
  488. t_end = end_block_seconds[b+1] + t_added
  489. N = int((t_end-t_sart)*frame_rate)
  490. t_act = np.linspace(t_sart,t_end,N)
  491. start_act = np.argwhere((t_sart-time_activity)<0.001)[0][0]
  492. end_act = np.argwhere((t_end-time_activity)<0.001)[0][0]
  493. if (end_act-start_act)>(len(t_act)):
  494. end_act = end_act - ((end_act-start_act)-len(t_act))
  496. if len(dffs.shape)>1:
  497. activity_block2 = dffs[:,start_act:end_act]
  498. else:
  499. activity_block2 = dffs[start_act:end_act]
  501. # append both blocks and take the mean
  502. act_both_block = np.vstack((activity_block1,activity_block2))
  503. # Compute the mean
  504. mean_block = np.mean(act_both_block,axis = 0)
  505. # subtract the mean
  506. activity = mean_block-np.mean(mean_block)
  507. normalize = int(N/2)+1
  509. #### compute fourier
  510. fourier = scipy.fft.fft(activity)
  511. fourier = np.abs(fourier)**2
  512. ff = scipy.fft.fft(activity)
  513. ff = np.abs(ff)**2
  515. # Interpolate 2-photon spectrum to match light bead frequency axis
  516. if scope == '2p':
  517. time_inter = rfftfreq(N_target, d = 1/frame_rate)
  518. freq_2p = rfftfreq(N, d = 1/frame_rate)
  519. interp_func = interp1d(freq_2p, ff[:normalize], kind='linear')
  520. fourier_interp = interp_func(time_inter)
  522. # plot the Fourier spectrums
  523. N = len(activity)
  524. plt.figure()
  525. if scope == '2p':
  526. plt.plot(rfftfreq(N_target, d = 1/frame_rate),fourier_interp[:int(N_target/2)+1], color = col,lw = 2.5 )
  527. if scope == 'LB':
  528. plt.plot(rfftfreq(N, d = 1/target_frame_rate), fourier[:normalize], color = col,lw = 2.5)
  529. plt.xlabel('Frequency (Hz)',fontsize =36)
  530. plt.ylabel('Amplitude',fontsize =36)
  531. plt.xlim(0,xlim)
  532. plt.xticks(fontsize =34)
  533. plt.yticks(fontsize =34,)
  534. plt.locator_params(axis='y', nbins=4)
  535. #plt.title('Spectrum block {0}Hz'.format(HZ[k]))
  536. plt.tight_layout()
  537. if path != None:
  538. plt.savefig(path + 'spectrum_block_' + str(k) + '_'+ scope + '.pdf', transparent = True)
  540. b=b+2 # Move to the next block pair
  542. plt.tight_layout()
  551. def power_ROI(dffs,start_block_seconds,end_block_seconds,t_added,frame_rate,time_activity,scope,N_target):
  552. """
  553. Description
  554. ----------
  555. This function computes the absolute and fraction of power at each frequencies for each ROIs.
  556. ----------
  558. Parameters
  559. ----------
  560. dffs (np.ndarray)
  561. Array containing the calcium activity over time, each row is an ROI.
  562. start_block_seconds (np.ndarray)
  563. array containing the start of each block in seconds
  564. end_block_seconds (np.ndarray)
  565. array containing the end of each block in seconds
  566. t_added (float)
  567. Time to add around each block for visualization purposes
  568. frame_rate (float)
  569. frame rate of the scope
  570. time_activity (np.ndarray)
  571. array containing the time for each calcium trace
  572. scope (str)
  573. Either 'LB' or '2p'
  574. N_target (float)
  575. Target number of samples when interpolating 2p
  576. ----------
  578. Returns
  579. ----------
  580. ps (nd.array)
  581. array containing the absolute power at each frequency for all ROIs
  582. fracps (nd.array)
  583. array containing the fraction of power at each frequency for all ROIs
  584. """
  586. mean_blocks = []
  587. ### First we grab the mean activity during of each stimulus block pair to subtract later
  588. b = 1 # Index that keeps track of the stimulus blocks
  589. # Loop through each block pairs
  590. for k in range(6):
  591. # extract first block in the pair
  592. t_sart = start_block_seconds[b]
  593. t_end = end_block_seconds[b] +t_added
  594. N = int((t_end-t_sart)*frame_rate)
  595. t_act = np.linspace(t_sart,t_end,N)
  596. start_act = np.argwhere((t_sart-time_activity)<0.001)[0][0]
  597. end_act = np.argwhere((t_end-time_activity)<0.001)[0][0]
  598. if (end_act-start_act)>(len(t_act)):
  599. end_act = end_act - ((end_act-start_act)-len(t_act))
  600. activity_block1 = dffs[:,start_act:end_act]
  602. # Grab second block in the pair
  603. t_sart = start_block_seconds[b+1]
  604. t_end = end_block_seconds[b+1] + t_added
  605. N = int((t_end-t_sart)*frame_rate)
  606. t_act = np.linspace(t_sart,t_end,N)
  607. start_act = np.argwhere((t_sart-time_activity)<0.001)[0][0]
  608. end_act = np.argwhere((t_end-time_activity)<0.001)[0][0]
  609. if (end_act-start_act)>(len(t_act)):
  610. end_act = end_act - ((end_act-start_act)-len(t_act))
  611. activity_block2 = dffs[:,start_act:end_act]
  612. # Combine both blocks
  613. activity_both_block = np.vstack((activity_block1,activity_block2))
  614. # store the mean
  615. mean_blocks.append(np.mean(activity_both_block))
  616. b +=2 # Move to the next block pair
  618. HZ = [0.25,0.5,1,2,3,5]
  619. ps = np.zeros((6,dffs.shape[0])) # will contain the absolute power
  620. fracps = np.zeros((6,dffs.shape[0])) # will contain the fraction of power
  622. for roi, i in enumerate(dffs):
  623. b=1 # Index that keeps track of the stimulus blocks
  624. # Loop through each block pairs
  625. for k in range(6):
  626. # extract first block in the pair
  627. t_sart = start_block_seconds[b]
  628. t_end = end_block_seconds[b] +t_added
  629. N = int((t_end-t_sart)*frame_rate)
  630. t_act = np.linspace(t_sart,t_end,N)
  631. start_act = np.argwhere((t_sart-time_activity)<0.001)[0][0]
  632. end_act = np.argwhere((t_end-time_activity)<0.001)[0][0]
  633. if (end_act-start_act)>(len(t_act)):
  634. end_act = end_act - ((end_act-start_act)-len(t_act))
  635. activity_block1 = dffs[:,start_act:end_act][roi,:]
  636. # Grab second block in the pair
  637. t_sart = start_block_seconds[b+1]
  638. t_end = end_block_seconds[b+1] + t_added
  639. N = int((t_end-t_sart)*frame_rate)
  640. t_act = np.linspace(t_sart,t_end,N)
  641. start_act = np.argwhere((t_sart-time_activity)<0.001)[0][0]
  642. end_act = np.argwhere((t_end-time_activity)<0.001)[0][0]
  643. if (end_act-start_act)>(len(t_act)):
  644. end_act = end_act - ((end_act-start_act)-len(t_act))
  645. activity_block2 = dffs[:,start_act:end_act][roi,:]
  646. # Combine both blocks
  647. activity_both_block = np.vstack((activity_block1,activity_block2))
  648. # Compute the mean
  649. mean_both_block = np.mean(activity_both_block,axis = 0)
  651. #### Compute fourier spectrum
  652. # subtract the overall mean during these two blocks
  653. ff_mean = scipy.fft.fft(mean_both_block - mean_blocks[k], norm = 'ortho' )
  654. ff_mean = np.abs(ff_mean)**2
  655. N_mean = len(mean_both_block)
  656. normalize = int(N_mean/2)+1
  658. ### slice frequency range
  659. f_range = [HZ[k]-0.1, HZ[k]+0.1]
  660. freq_axis = rfftfreq(N, d = 1/frame_rate)
  661. f0 = np.argmin(np.abs(freq_axis- f_range[0]))
  662. f1 = np.argmin(np.abs(freq_axis- f_range[1]))
  663. f_cutoff = np.argmin(np.abs(freq_axis- 1.1))
  665. if scope == 'LB':
  666. p = np.sum(ff_mean[f0:f1])
  667. if HZ[k]<2:
  668. totp = np.sum(ff_mean[1:f_cutoff])
  669. else:
  670. totp = np.sum(ff_mean[1:normalize])
  672. if scope == '2p':
  673. if (HZ[k]-freq_axis[f0])>0.8:
  674. p = 0
  675. else:
  676. p = np.sum(ff_mean[f0:f1])
  679. totp = np.sum(ff_mean[1:normalize])
  681. ps[k,roi] = p
  682. fracp = (p/totp)*100
  683. fracps[k,roi] = fracp
  685. return(ps,fracps)
  690. def plot_power_ROIs(ps,fracps,ps_2p, fracps_2p,path):
  691. """
  692. Description
  693. ----------
  694. This function plot the fraction of power at each frequency across all ROIs for both 2p and LB
  695. ----------
  697. Parameters
  698. ----------
  699. ps (nd.array)
  700. array containing the absolute power at each frequency for all ROIs aquired with LB
  701. fracps (nd.array)
  702. array containing the fraction of power at each frequency for all ROIs aquired with LB
  703. ps_2p (nd.array)
  704. array containing the absolute power at each frequency for all ROIs aquired with 2p
  705. fracps_2p (nd.array)
  706. array containing the fraction of power at each frequency for all ROIs aquired with 2p
  707. path (str)
  708. Path to folder where to save the plots. If set to None, plots won't be saved.
  709. ----------
  711. """
  713. HZ = [0.25,0.5,1,2,3,5]
  715. # Loop through each frequencies
  716. for k in range(len(ps)):
  717. plt.figure(figsize=(3.5, 6))
  718. plt.plot(np.random.normal(0,0.03, size = len(fracps[k])),fracps[k],'g.',alpha = 0.1)
  719. plt.plot(np.random.normal(0.3,0.03, size = len(fracps_2p[k])),fracps_2p[k],'m.',alpha = 0.1)
  720. plt.bar([0],np.mean(fracps[k]),yerr = np.std(fracps[k]),capsize = 5, color = 'white',edgecolor = 'g', width = 0.2)
  721. plt.bar([0.3],np.mean(fracps_2p[k]),yerr = np.std(fracps_2p[k]),capsize = 5, color = 'white', edgecolor = 'm', width = 0.2)
  722. plt.xticks([])
  723. plt.ylabel('Fraction of power at {} Hz'.format(HZ[k]), fontsize = 32)
  724. plt.yticks(fontsize = 32)
  725. plt.locator_params(axis='y', nbins=4)
  726. plt.tight_layout()
  728. if path != None:
  729. plt.savefig(path + 'frac_power' + str(HZ[k]) + '_' + '.pdf', transparent = True)
  733. def shuffle_within_blocks(dffs, start_block_seconds, end_block_seconds, frame_rate, seed=None):
  734. """
  735. This function returns a copy of the activity where, for each stimulus block,
  736. the time‐points within that block are independently shuffled for each ROI.
  738. Parameters
  739. ----------
  740. dffs (np.ndarray)
  741. Array containing the calcium activity over time, each row is an ROI.
  742. start_block_seconds (np.ndarray)
  743. array containing the start of each block in seconds
  744. end_block_seconds (np.ndarray)
  745. array containing the end of each block in seconds
  746. frame_rate (float)
  747. frame rate of the scope
  748. seed : int or None
  749. If given, seeds the RNG
  751. Returns
  752. -------
  753. shuffled : np.ndarray, shape (n_rois, n_timepoints)
  754. A copy of `dffs` with time‐points shuffled within each block for each ROI.
  755. """
  756. if seed is not None:
  757. np.random.seed(seed)
  759. n_rois, n_time = dffs.shape
  760. shuffled = dffs.copy()
  762. for start_sec, end_sec in zip(start_block_seconds, end_block_seconds):
  763. # Convert seconds to integer frame indices
  764. start_idx = int(np.floor(start_sec * frame_rate))
  765. end_idx = int(np.ceil (end_sec * frame_rate))
  767. # Clip to valid range
  768. start_idx = max(start_idx, 0)
  769. end_idx = min(end_idx, n_time)
  771. block_len = end_idx - start_idx
  772. if block_len <= 1:
  773. continue
  775. # For each ROI, shuffle the values within [start_idx:end_idx]
  776. for r in range(n_rois):
  777. block_vals = dffs[r, start_idx:end_idx]
  778. permuted = block_vals[np.random.permutation(block_len)]
  779. shuffled[r, start_idx:end_idx] = permuted
  781. return shuffled
  786. def fourier_and_peaks_mean(dffs,start_block_seconds,end_block_seconds,frame_rate,time_activity, path):
  787. """
  788. Description
  789. ----------
  790. This function computes the absolute power at 27-28Hz and the fourier spectrum for each ROIs
  791. ----------
  793. Parameters
  794. ----------
  795. dffs (np.ndarray)
  796. Array containing the calcium activity over time, each row is an ROI.
  797. start_block_seconds (np.ndarray)
  798. array containing the start of each block in seconds
  799. end_block_seconds (np.ndarray)
  800. array containing the end of each block in seconds
  801. frame_rate (float)
  802. frame rate of the scope
  803. time_activity (np.ndarray)
  804. array containing the time for each calcium trace
  805. path (str)
  806. Path to folder where to save the plots. If set to None, plots won't be saved.
  807. ----------
  809. Returns
  810. ----------
  811. ps (nd.array)
  812. array containing the absolute power at each frequency for all ROIs
  813. ff_all_roi (nd.array)
  814. array containing the mean Fourier spectrum for each ROI
  815. """
  817. HZ = 27.77 # frequency of pulses within the stimulus (36ms IPI)
  818. ps = []
  819. mean_roi = np.zeros((dffs.shape[0],2*int(frame_rate) ))
  821. ff_all_roi = np.zeros((dffs.shape[0],2*int(frame_rate) )) # Contains the mean ff spectrum of each ROI
  822. # First we compute the mean activity over all blocks for each ROIs to subtract later
  823. for roi in range(dffs.shape[0]):
  824. ## Loop through the blocks
  825. for k in range(2,14):
  826. # Grab block
  827. t_sart = start_block_seconds[k]
  828. t_end = end_block_seconds[k]
  829. N = int((t_end-t_sart)*frame_rate)
  830. t_act = np.linspace(t_sart,t_end,N)
  831. start_act = (np.abs(t_sart-time_activity)).argmin()
  832. end_act = (np.abs(t_end-time_activity)).argmin()
  833. if (end_act-start_act)>(len(t_act)):
  834. end_act = end_act - ((end_act-start_act)-len(t_act))
  835. # store the block
  836. if k == 2:
  837. activity_block = dffs[roi, start_act:end_act]
  838. else:
  839. activity_block = np.vstack((activity_block,dffs[roi, start_act:end_act]))
  840. ## take the mean across all block for each roi
  841. mean_across_blocks = np.mean(activity_block, axis = 0)
  842. mean_roi[roi,:] = mean_across_blocks
  844. # compute the mean of all these means
  845. overall_mean = np.mean(mean_roi)
  846. # compute fourier
  847. for roi in range(mean_roi.shape[0]):
  848. # extract activity of each roi and subtract the overall mean
  849. activity_fourier = mean_roi[roi,:] - overall_mean
  850. N = len(activity_fourier)
  851. #Slice frequency range
  852. f_range = [HZ -0.77, HZ +0.33] # Frequency range of interesest (27-28Hz)
  853. freq_axis = rfftfreq(N, d = 1/frame_rate)
  854. f0 = np.argmin(np.abs(freq_axis- f_range[0]))
  855. f1 = np.argmin(np.abs(freq_axis- f_range[1]))
  856. #Compute fourier
  857. ff = np.abs(scipy.fft.fft(activity_fourier, norm = 'ortho' ))**2
  858. if roi == 0:
  859. ff_all_roi = ff
  860. else:
  861. ff_all_roi = np.vstack((ff_all_roi,ff))
  863. #compute abstolute power
  864. p = np.sum(ff[f0:f1])
  865. ps.append(p)
  868. return ps , ff_all_roi
  873. def plot_power_ROIs_all(ps,ps_shuffled,ps_off, path,title):
  874. """
  875. Description
  876. ----------
  877. This function plots the absolute at 27-28Hz for the three groups (stim on, stim off and shuffled activity)
  878. ----------
  880. Parameters
  881. ----------
  882. ps (nd.array)
  883. array containing the absolute power at 27-28Hz for all ROIs when stimulus is on
  884. ps_shuffled (nd.array)
  885. array containing the absolute power at 27-28Hz for all ROIs when stimulus is on and the activity is shuffled
  886. ps_off (nd.array)
  887. array containing the absolute power at 27-28Hz for all ROIs when stimulus is off
  888. path (str)
  889. Path to folder where to save the plots. If set to None, plots won't be saved.
  890. ----------
  892. """
  893. plt.figure(figsize=(11, 6))
  894. plt.plot(np.random.normal(0.1,0.025, size = len(ps)),ps,'g.',alpha = 0.3)#+'.'
  895. plt.plot(np.random.normal(0.9,0.025, size = len(ps_shuffled)),ps_shuffled,'m.',alpha = 0.3)#+'.'
  896. plt.plot(np.random.normal(0.5,0.025, size = len(ps_off)),ps_off,'k.',alpha = 0.3)#+'.'
  898. plt.bar([0.1],np.mean(ps),yerr = np.std(ps),capsize = 5, color = 'white',edgecolor = 'g', width = 0.1)
  899. plt.bar([0.9],np.mean(ps_shuffled),yerr = np.std(ps_shuffled),capsize = 5, color = 'white',edgecolor = 'm', width = 0.1)
  900. plt.bar([0.5],np.mean(ps_off),yerr = np.std(ps_off),capsize = 5, color = 'white',edgecolor = 'k', width = 0.1)
  902. plt.xticks([])
  903. plt.yticks(fontsize = 22)
  904. plt.ylabel('Absolute power at [27-28] Hz', fontsize = 20)
  905. plt.locator_params(axis='y', nbins=3)
  906. plt.ylim(0,0.9)
  907. plt.tight_layout()
  909. if path != None:
  910. plt.savefig(path + 'absolute_power'+ title +'.pdf', transparent = True)
  913. def plot_power_ROIs_all_no_shuffle(ps,ps_off, path,title):
  914. """
  915. Description
  916. ----------
  917. This function plots the absolute at 27-28Hz for the three groups (stim on, stim off)
  918. ----------
  920. Parameters
  921. ----------
  922. ps (nd.array)
  923. array containing the absolute power at 27-28Hz for all ROIs when stimulus is on
  924. ps_off (nd.array)
  925. array containing the absolute power at 27-28Hz for all ROIs when stimulus is off
  926. path (str)
  927. Path to folder where to save the plots. If set to None, plots won't be saved.
  928. ----------
  930. """
  931. plt.figure(figsize=(11, 6))
  932. plt.plot(np.random.normal(0.25,0.025, size = len(ps)),ps,'g.',alpha = 0.3)#+'.'
  933. plt.plot(np.random.normal(0.6,0.025, size = len(ps_off)),ps_off,'k.',alpha = 0.3)#+'.'
  935. plt.bar([0.25],np.mean(ps),yerr = np.std(ps),capsize = 5, color = 'white',edgecolor = 'g', width = 0.1)
  936. plt.bar([0.6],np.mean(ps_off),yerr = np.std(ps_off),capsize = 5, color = 'white',edgecolor = 'k', width = 0.1)
  938. plt.xticks([])
  939. plt.yticks(fontsize = 22)
  940. plt.ylabel('Absolute power at [27-28] Hz', fontsize = 20)
  941. plt.locator_params(axis='y', nbins=3)
  942. plt.ylim(0,0.9)
  943. plt.tight_layout()
  945. if path != None:
  946. plt.savefig(path + 'absolute_power'+ title +'.pdf', transparent = True)
  951. def peaks_fourier_ROI_combine(dffs,start_block_seconds,end_block_seconds,t_added,Hz,time_activity,scope,N_target,top_peaks,path_fig):
  952. """
  953. Description
  954. ----------
  955. This function computes the fourier of each roi for each block and extract the peak frequency of the spectrum.
  956. It also plots the fourier spectrum for each block of a representative ROI.
  958. ----------
  960. Parameters
  961. ----------
  962. dffs (np.ndarray)
  963. Array containing the calcium activity over time, each row is an ROI.
  964. start_block_seconds (np.ndarray)
  965. array containing the start of each block in seconds
  966. end_block_seconds (np.ndarray)
  967. array containing the end of each block in seconds
  968. t_added (float)
  969. Time to add around each block for visualization purposes
  970. frame_rate (float)
  971. frame rate of the scope
  972. time_activity (np.ndarray)
  973. array containing the time for each calcium trace
  974. scope (str)
  975. 'LB' or '2p' to specify which scope was used to aquire the data
  976. N_target (float)
  977. Target number of samples when interpolating 2p
  978. top_peaks (int)
  979. the number of peaks to extract per spectrum
  980. path_fig (float)
  981. Path to folder where to save the plots. If set to None, plots won't be saved.
  982. ----------
  984. Returns
  985. ----------
  986. peak_freq (np.ndarray)
  987. contains the absolute peak frequency of the Fourier for each block of each ROI.
  989. ----------
  991. """
  992. if scope == 'LB':
  993. roi_to_plot = 1596
  994. col = 'g'
  995. else:
  996. roi_to_plot = 890
  997. col = 'm'
  999. mean_blocks = []
  1000. # First we grab mean of each block to subtract later
  1001. b = 1 # Index that keeps track of the stimulus blocks
  1002. for k in range(6):
  1003. # Grab first block
  1004. t_sart = start_block_seconds[b]
  1005. t_end = end_block_seconds[b] +t_added
  1006. N = int((t_end-t_sart)*Hz)
  1007. t_act = np.linspace(t_sart,t_end,N)
  1008. start_act = np.argwhere((t_sart-time_activity)<0.001)[0][0]
  1009. end_act = np.argwhere((t_end-time_activity)<0.001)[0][0]
  1010. if (end_act-start_act)>(len(t_act)):
  1011. end_act = end_act - ((end_act-start_act)-len(t_act))
  1012. activity_block1 = zscore(dffs[:,start_act:end_act],axis = 1)
  1013. # Grab second block
  1014. t_sart = start_block_seconds[b+1]
  1015. t_end = end_block_seconds[b+1] + t_added
  1016. N = int((t_end-t_sart)*Hz)
  1017. t_act = np.linspace(t_sart,t_end,N)
  1018. start_act = np.argwhere((t_sart-time_activity)<0.001)[0][0]
  1019. end_act = np.argwhere((t_end-time_activity)<0.001)[0][0]
  1020. if (end_act-start_act)>(len(t_act)):
  1021. end_act = end_act - ((end_act-start_act)-len(t_act))
  1022. activity_block2 = zscore(dffs[:,start_act:end_act],axis = 1)
  1023. # Combine both blocks
  1024. activity_both_block = np.vstack((activity_block1,activity_block2))
  1025. mean_blocks.append(np.mean(activity_both_block))
  1026. b +=2 # move to next pair
  1028. HZ = [0.25,0.5,1,2,3,5]
  1029. peak_freq = np.zeros((6,top_peaks*dffs.shape[0]))
  1031. for roi, i in enumerate(dffs):
  1032. b=1 # Index that keeps track of the stimulus blocks
  1033. for k in range(6):
  1034. #extract first block
  1035. t_sart = start_block_seconds[b]
  1036. t_end = end_block_seconds[b] +t_added
  1037. N = int((t_end-t_sart)*Hz)
  1038. t_act = np.linspace(t_sart,t_end,N)
  1039. start_act = np.argwhere((t_sart-time_activity)<0.001)[0][0]
  1040. end_act = np.argwhere((t_end-time_activity)<0.001)[0][0]
  1041. if (end_act-start_act)>(len(t_act)):
  1042. end_act = end_act - ((end_act-start_act)-len(t_act))
  1043. activity_block1 = zscore(dffs[:,start_act:end_act][roi,:])
  1044. # Grab second block
  1045. t_sart = start_block_seconds[b+1]
  1046. t_end = end_block_seconds[b+1] + t_added
  1047. N = int((t_end-t_sart)*Hz)
  1048. t_act = np.linspace(t_sart,t_end,N)
  1049. start_act = np.argwhere((t_sart-time_activity)<0.001)[0][0]
  1050. end_act = np.argwhere((t_end-time_activity)<0.001)[0][0]
  1051. if (end_act-start_act)>(len(t_act)):
  1052. end_act = end_act - ((end_act-start_act)-len(t_act))
  1053. activity_block2 = zscore(dffs[:,start_act:end_act][roi,:])
  1054. #Combine both blocks
  1055. activity_both_block = np.vstack((activity_block1,activity_block2))
  1056. mean_both_block = np.mean(activity_both_block,axis = 0)
  1057. # subtract the overall mean during these two blocks
  1058. ff_mean = np.abs(scipy.fft.fft(mean_both_block - mean_blocks[k] ))**2 #
  1059. N_mean = len(mean_both_block)
  1060. normalize = int(N_mean/2)+1
  1062. # Interpolate 2-photon spectrum to match light bead frequency axis
  1063. if scope == '2p':
  1064. # Frequency axes
  1065. time_inter = rfftfreq(N_target, d = 1/Hz)
  1066. freq_2p = rfftfreq(N, d = 1/Hz)
  1067. interp_func = interp1d(freq_2p, ff_mean[:normalize], kind='linear')
  1068. ff_mean = interp_func(time_inter)
  1069. normalize = int(N_target/2)+1
  1071. if roi == roi_to_plot:
  1072. plt.figure()
  1073. plt.plot(rfftfreq(N_target, d = 1/Hz), ff_mean[:normalize], color = col)
  1074. plt.xlabel('Frequency[Hz]',fontsize = 24)
  1075. plt.ylabel('Amplitude',fontsize = 24)
  1076. plt.xticks(fontsize =22)
  1077. plt.yticks(fontsize =22)
  1078. plt.tight_layout()
  1079. if path_fig != None:
  1080. plt.savefig(path_fig + 'spectrum_ROI_' + str(roi) + '_' + str(HZ[k]) + '_LB.pdf', transparent = True)
  1082. # extract peaks
  1083. if scope == 'LB':
  1084. peaks = find_peaks(ff_mean[:normalize],prominence = 0.7)
  1085. else:
  1086. peaks = find_peaks(ff_mean,prominence = 0.7)
  1087. if len(peaks[0])>0:
  1088. # Find the index from the maximum peak
  1089. i_max_peak = peaks[0][np.argmax(ff_mean[peaks[0]])]
  1091. #second_highest_peak_index = peaks[0][np.argpartition(ff_mean[peaks[0]],-2)[-2]]
  1093. # Find the x value from that index
  1094. x_max = rfftfreq(N_target, d = 1/Hz)[i_max_peak]
  1097. peak_freq[k,roi] = x_max
  1098. #if top_peaks == 2:
  1099. # peak_freq[k,roi+dffs.shape[0]] = rfftfreq(N_target, d = 1/Hz) [second_highest_peak_index]
  1102. b=b+2 # move to next pair
  1104. return(peak_freq)
  1108. def crosscorr_sort_corr(dffs,stimulus,threshold_test,cutoff,frame_rate):
  1109. """
  1110. Description
  1111. ----------
  1112. This function computes extract the number of ROIs for each correlation coefficient between activity and the auditory stimulus
  1113. ----------
  1115. Parameters
  1116. ----------
  1117. dffs (np.ndarray)
  1118. Array containing the calcium activity over time, each row is an ROI.
  1119. stimulus (np.ndarray)
  1120. array containing the auditory stimulus
  1121. threshold_test (np.ndarray)
  1122. Contains all of the coefficient values over which to extract the number of ROIs
  1123. cutoff (float)
  1124. threshold in percentage to use when extracting the top X% based on correlation
  1125. max_lag (float)
  1126. the lag over which to compute the cross correlation
  1127. frame_rate (float)
  1128. frame rate of the scope
  1129. ----------
  1131. Returns
  1132. ----------
  1133. n_roi
  1134. the number of ROIs extracted for each correlation coefficient
  1136. corr_coeff
  1137. array containing the correlation coefficient of the top 'cutoff'% of ROIs with the highest correlation with the stimulus
  1140. ----------
  1142. """
  1143. # Normalize dffs and the stimulus
  1144. dffs_mean = dffs.mean(axis=1, keepdims=True)
  1145. dffs_std = dffs.std(axis=1, keepdims=True)
  1146. dffs_normalized = (dffs - dffs_mean) / dffs_std
  1148. stimulus_normalized = (stimulus - stimulus.mean()) / stimulus.std()
  1149. # Compute correlations
  1150. correlations = np.dot(dffs_normalized, stimulus_normalized.T) / dffs_normalized.shape[1]
  1151. correlations = correlations.flatten()
  1152. rois = np.arange(0,dffs.shape[0])
  1153. rois = rois[~np.isnan(correlations)]
  1154. correlations = correlations[~np.isnan(correlations)]
  1155. #sort the correlation and roi index
  1156. sorted_indices = np.argsort(correlations)
  1157. sorted_corr = correlations[sorted_indices]
  1158. index_cutoff = int(dffs.shape[0] * (cutoff/100))
  1159. corr_coeff = sorted_corr[-index_cutoff:]
  1160. n_roi = []
  1161. for t in threshold_test:
  1162. n_roi.append( np.where(sorted_corr>t)[0].shape[0] )
  1163. return(n_roi, corr_coeff)
  1166. def assign_depths(n_rois: int, slice_depths: np.ndarray):
  1167. """
  1168. Assigns depths to each ROI given the total number of ROIs and slice depths.
  1170. Parameters
  1171. ----------
  1172. n_rois : int
  1173. Total number of ROIs (number of rows in your 2D array).
  1174. slice_depths : np.ndarray
  1175. 1D array of shape (n_slices,) containing the depth for each slice.
  1177. Returns
  1178. -------
  1179. roi_depths : np.ndarray
  1180. 1D array of shape (n_rois,) where each entry is the depth of the slice
  1181. corresponding to that ROI.
  1182. """
  1183. n_slices = len(slice_depths)
  1184. rois_per_slice = n_rois // n_slices # assumes equal number of ROIs per slice
  1186. if n_rois % n_slices != 0:
  1187. raise ValueError("Number of ROIs is not evenly divisible by number of slices.")
  1189. # Repeat each slice depth rois_per_slice times
  1190. roi_depths = np.repeat(slice_depths, rois_per_slice)
  1192. return roi_depths
  1195. def plot_distribution_peaks_fourier_ROIs(freq_block,scope, color, path):
  1197. HZ = [0.25,0.5,1,2,3,5]
  1198. # define bins
  1199. if scope == 'LB':
  1200. bins=np.arange(0,14.040,0.40)
  1201. xlim = 14
  1202. if scope == '2p':
  1203. bins = np.arange(0,1.1,0.08)
  1204. xlim = 1.1
  1205. # Plot histogram
  1206. for k in range(len(freq_block)):
  1207. plt.figure()
  1208. plt.hist(freq_block[k], bins=bins, color = color)
  1209. plt.xticks(fontsize = 22)
  1210. plt.yticks(fontsize = 22)
  1211. plt.xlabel('Frequency (Hz)', fontsize = 24)
  1212. plt.ylabel('Count', fontsize = 24)
  1213. plt.xlim(0,xlim)
  1214. plt.tight_layout()
  1217. if path != None:
  1218. plt.savefig(path + 'hist_fourier_peaks_' + str(HZ[k]) + '_' + scope + '.pdf', transparent = True)
  1221. def circular_shift_null_corr_prestandardized(
  1222. dffs_z: np.ndarray, # (n_rois, T) mean-zero (z-scored) ROI traces
  1223. stim_z: np.ndarray, # (T,) mean-zero (z-scored) stimulus
  1224. n_shuffles: int,
  1225. exclude_lags: int = 0, # ignored when 'shifts' is provided
  1226. seed: Optional[int] = None,
  1227. batch_size: int = 256, # shifts per batch (tune for RAM/BLAS)
  1228. dtype: np.dtype = np.float32,
  1229. shifts: Optional[np.ndarray] = None, # (n_shuffles,) specific circular shifts to use
  1230. ) -> Tuple[np.ndarray, np.ndarray]:
  1231. """
  1232. Compute Pearson correlations between each ROI and circularly-shifted stimulus versions.
  1234. If 'shifts' is provided (ints in [0, T)), it is used directly and 'exclude_lags' is ignored.
  1235. Otherwise, draws 'n_shuffles' random shifts, optionally excluding small lags.
  1237. Returns
  1238. -------
  1239. r_null : (n_rois, n_shuffles) correlations (one column per shift)
  1240. shifts : (n_shuffles,) the shift used for each column (np.int64)
  1241. """
  1242. X = np.asarray(dffs_z, dtype=dtype, order="C")
  1243. s = np.asarray(stim_z, dtype=dtype).reshape(-1)
  1245. n_rois, T = X.shape
  1246. if s.shape[0] != T:
  1247. raise ValueError("stim_z length must equal number of columns in dffs_z")
  1249. Xnorm = np.linalg.norm(X, axis=1, keepdims=True).astype(dtype)
  1250. Xnorm[Xnorm == 0] = 1.0
  1251. Xu = X / Xnorm
  1253. s_norm = float(np.linalg.norm(s))
  1254. if s_norm == 0:
  1256. return np.zeros((n_rois, n_shuffles), dtype=dtype), np.zeros(n_shuffles, dtype=np.int64)
  1257. s_u = s / s_norm
  1260. if shifts is not None:
  1261. shifts = np.asarray(shifts, dtype=np.int64).ravel()
  1262. if shifts.size != n_shuffles:
  1263. raise ValueError("len(shifts) must equal n_shuffles.")
  1265. shifts %= T
  1266. else:
  1267. rng = np.random.default_rng(seed)
  1268. if exclude_lags <= 0:
  1269. shifts = rng.integers(0, T, size=n_shuffles, endpoint=False, dtype=np.int64)
  1270. else:
  1271. mask = np.ones(T, dtype=bool)
  1272. mask[:exclude_lags+1] = False
  1273. if exclude_lags > 0:
  1274. mask[T-exclude_lags:] = False
  1275. allowed = np.nonzero(mask)[0].astype(np.int64)
  1276. if allowed.size == 0:
  1277. raise ValueError("Exclusion window too large: no shifts remain.")
  1278. shifts = rng.choice(allowed, size=n_shuffles, replace=True)
  1280. r_null = np.empty((n_rois, n_shuffles), dtype=dtype)
  1283. t = np.arange(T, dtype=np.int64)[:, None]
  1284. for start in range(0, n_shuffles, batch_size):
  1285. end = min(start + batch_size, n_shuffles)
  1286. k = shifts[start:end]
  1287. idx = (t - k[None, :]) % T
  1288. S_batch = s_u[idx]
  1289. r_null[:, start:end] = Xu @ S_batch
  1291. return r_null, shifts
  1294. def allowed_circ_shifts(T, fs, period_sec, E_sec):
  1295. period = int(round(period_sec * fs))
  1296. E = int(round(E_sec * fs))
  1297. allowed = np.ones(T, dtype=bool)
  1298. if period > 0:
  1299. n_mult = int(np.ceil(T / period)) + 1
  1300. for k in range(n_mult):
  1301. center = (k * period) % T
  1302. lo = (center - E) % T
  1303. hi = (center + E) % T
  1304. if lo <= hi:
  1305. allowed[lo:hi+1] = False
  1306. else:
  1307. allowed[:hi+1] = False
  1308. allowed[lo:] = False
  1309. if not np.any(allowed):
  1310. raise ValueError("Exclusion too wide—no shifts left.")
  1311. return np.flatnonzero(allowed)
  1314. def block_permute_null_corr_prestandardized(
  1315. dffs_z: np.ndarray, # (n_rois, T), mean-zero (z-scored)
  1316. stim_z: np.ndarray, # (T,), mean-zero (z-scored)
  1317. fs: float, # Hz
  1318. n_shuffles: int,
  1319. block_sec: float = 10.0, # seconds
  1320. jitter_within_block: int = 0,# ±samples to circularly roll inside each block
  1321. seed: Optional[int] = None,
  1322. batch_size: int = 128,
  1323. dtype: np.dtype = np.float32,
  1324. forbid_identity_perm: bool = True,
  1325. ) -> Tuple[np.ndarray, np.ndarray]:
  1326. """
  1327. Permute stimulus in contiguous blocks (optionally with within-block jitter) and
  1328. compute Pearson r for each ROI vs each permuted stimulus.
  1329. Returns:
  1330. r_null : (n_rois, n_shuffles)
  1331. perms : (n_shuffles, n_blocks)
  1332. """
  1333. X = np.asarray(dffs_z, dtype=dtype, order="C")
  1334. s = np.asarray(stim_z, dtype=dtype).reshape(-1)
  1336. n_rois, T = X.shape
  1337. if s.shape[0] != T:
  1338. raise ValueError("stim_z length must equal number of columns in dffs_z")
  1341. Xnorm = np.linalg.norm(X, axis=1, keepdims=True).astype(dtype)
  1342. Xnorm[Xnorm == 0] = 1.0
  1343. Xu = X / Xnorm
  1345. s_norm = float(np.linalg.norm(s))
  1346. if s_norm == 0:
  1347. return np.zeros((n_rois, n_shuffles), dtype=dtype), np.empty((n_shuffles, 0), dtype=np.int64)
  1348. s_u = s / s_norm
  1351. block_len = int(round(block_sec * fs))
  1352. if block_len <= 0:
  1353. raise ValueError("block_sec too small for the given fs")
  1354. BI = _make_block_indices(T, block_len) # (block_len, n_blocks)
  1355. block_len_eff, n_blocks = BI.shape
  1357. rng = np.random.default_rng(seed)
  1358. r_null = np.empty((n_rois, n_shuffles), dtype=dtype)
  1359. perms_used = np.empty((n_shuffles, n_blocks), dtype=np.int64)
  1362. for start in range(0, n_shuffles, batch_size):
  1363. end = min(start + batch_size, n_shuffles)
  1364. B = end - start
  1367. perms = np.empty((B, n_blocks), dtype=np.int64)
  1368. for b in range(B):
  1369. if forbid_identity_perm and n_blocks == 1:
  1371. perms[b] = np.array([0], dtype=np.int64)
  1372. else:
  1373. while True:
  1374. p = rng.permutation(n_blocks)
  1375. if not forbid_identity_perm or np.any(p != np.arange(n_blocks)):
  1376. break
  1377. perms[b] = p
  1380. if jitter_within_block > 0:
  1381. J = int(jitter_within_block)
  1382. jit = rng.integers(-J, J + 1, size=(B, n_blocks), endpoint=True, dtype=np.int64)
  1383. else:
  1384. jit = np.zeros((B, n_blocks), dtype=np.int64)
  1387. idx_batch = np.empty((T, B), dtype=np.int64)
  1388. for b in range(B):
  1389. cols = []
  1390. for j in range(n_blocks):
  1391. col = BI[:, perms[b, j]]
  1392. if jitter_within_block != 0:
  1393. col = np.roll(col, jit[b, j], axis=0)
  1394. cols.append(col)
  1395. idx_b = np.concatenate(cols, axis=0)[:T]
  1396. idx_batch[:, b] = idx_b
  1399. S_batch = s_u[idx_batch]
  1400. r_null[:, start:end] = Xu @ S_batch
  1401. perms_used[start:end] = perms
  1403. return r_null, perms_used
  1406. def _make_block_indices(T: int, block_len: int) -> np.ndarray:
  1407. """
  1408. Return BI of shape (block_len, n_blocks) with absolute indices per block.
  1409. Pads the final block by repeating its last index so each column has block_len rows.
  1410. """
  1411. if block_len <= 0:
  1412. raise ValueError("block_len must be positive")
  1413. n_blocks = int(np.ceil(T / block_len))
  1414. pad = n_blocks * block_len - T
  1415. idx = np.arange(T, dtype=np.int64)
  1416. if pad > 0:
  1417. idx = np.concatenate([idx, np.full(pad, idx[-1], dtype=np.int64)])
  1418. return idx.reshape(n_blocks, block_len).T # (block_len, n_blocks)
  1421. def permutation_pvals_one_sided(r_obs, r_null, alternative="greater"):
  1422. """
  1423. One-sided permutation p-values with finite-sample correction.
  1425. p_i = (1 + #{ r_null >= r_obs_i }) / (N_i + 1) if alternative == "greater"
  1426. p_i = (1 + #{ r_null <= r_obs_i }) / (N_i + 1) if alternative == "less"
  1428. Parameters
  1429. ----------
  1430. r_obs : array-like, shape (n_rois,)
  1431. Observed statistics (e.g., correlations) per ROI.
  1432. r_null : array-like, shape (n_rois, n_perm) or (n_perm,)
  1433. Null statistics from permutations. If 2D, each row is that ROI's null.
  1434. If 1D, a pooled null used for all ROIs.
  1435. alternative : {"greater","less"}, default "greater"
  1436. Direction of the one-sided test.
  1438. Returns
  1439. -------
  1440. pvals : ndarray, shape (n_rois,)
  1441. One-sided permutation p-values.
  1442. """
  1443. r_obs = np.asarray(r_obs, dtype=np.float64).reshape(-1)
  1444. r_null = np.asarray(r_null, dtype=np.float64)
  1446. if alternative not in ("greater", "less"):
  1447. raise ValueError("alternative must be 'greater' or 'less'.")
  1449. if r_null.ndim == 1:
  1450. valid = ~np.isnan(r_null)
  1451. N = int(valid.sum())
  1452. if N == 0:
  1453. return np.ones_like(r_obs)
  1454. rn = r_null[valid][None, :]
  1455. if alternative == "greater":
  1456. counts = (rn >= r_obs[:, None]).sum(axis=1)
  1457. else:
  1458. counts = (rn <= r_obs[:, None]).sum(axis=1)
  1459. pvals = (1.0 + counts) / (N + 1.0)
  1460. return pvals
  1462. elif r_null.ndim == 2:
  1463. if r_null.shape[0] != r_obs.shape[0]:
  1464. raise ValueError("For per-ROI nulls, r_null must have shape (n_rois, n_perm).")
  1465. valid = ~np.isnan(r_null)
  1466. N = valid.sum(axis=1).astype(np.int64)
  1468. if alternative == "greater":
  1469. ge = (r_null >= r_obs[:, None]) & valid
  1470. else:
  1471. ge = (r_null <= r_obs[:, None]) & valid
  1472. counts = ge.sum(axis=1)
  1475. denom = N + 1.0
  1476. denom[denom == 0] = np.inf
  1477. pvals = (1.0 + counts) / denom
  1478. pvals[np.isinf(denom)] = 1.0
  1479. return pvals
  1481. else:
  1482. raise ValueError("r_null must be 1D (pooled) or 2D (per-ROI).")

functions.py at commit 55570f4, no license · at the source

Overview

Authors: Wayan Gauthey1, Albert Lin1,2, Osama M Ahmed3, Andrew M Leifer1,2,4, Mala Murthy1,2,5, Stephan Y Thiberge1,5
ORCID iDs: Albert Lin, Osama M Ahmed, Andrew M Leifer, Mala Murthy, Stephan Y Thiberge
  1. Princeton Neuroscience Institute, Princeton University, Princeton, NJ USA
  2. Center for the Physics of Biological Function, Princeton University, Princeton, NJ USA
  3. Department of Psychology, University of Washington, Seattle, WA USA
  4. Department of Physics, Princeton University, Princeton, NJ USA
  5. Bezos Center for Neural Circuit Dynamics, Princeton University, Princeton, NJ USA
Institutions: Princeton University (United States); University of Washington (United States)
Journal: Nature communications, volume 17, issue 1, article 5810
Dates: received 8 July 2025; accepted 16 April 2026; published online 28 April 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41467-026-72437-1 · PMID 42050341 · PMCID PMC13328740 · OpenAlex W7157194336
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: drosophila (organism), systems (subfield)
Methods: Spectral & time-frequency, Statistics, Machine learning, Preprocessing, Graphs, fMRI & imaging
Keywords: Neuroscience, Biological techniques
MeSH: Brain*, Drosophila melanogaster*, Animals, Calcium, Calcium Signaling, Courtship, Female, Male, Neurons (* major topic)
Topic: Neurobiology and Insect Physiology Research (Cellular and Molecular Neuroscience, Neuroscience), according to OpenAlex
Citations: cited by 2 papers (Europe PMC); 56 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repositories

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

murthylab/fly-vr

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 1a8705e9d9dd9b94d25addee484f2d966ccefa69, 12 February 2024
Languages: Python (59), MATLAB (17), C (1)
Size: 549 files, 77 scripts
Software Heritage: archived
Found in: “Code availability”
Holds: README, environment (requirements.txt, setup.cfg, setup.py), tests
Not found: license file, CITATION.cff, continuous integration, documentation
Tools: NumPy (25 files), h5py (10 files), Matplotlib (4 files), PsychoPy (3 files), SciPy (3 files), Signal Processing Toolbox (2 files), pandas (2 files), OpenCV (1 file), Pillow (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
78 files
At the source: github.com/murthylab/fly-vr

murthylab/lightbead-analysis

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 55570f4ad028bfd19ab63d5b9b13430803cb277c, 6 April 2026
Languages: Python (43), Shell (8), MATLAB (3), Jupyter (1)
Size: 103 files, 55 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, 1 notebook
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (31 files), SciPy (17 files), Matplotlib (12 files), pandas (8 files), ANTs (7 files), h5py (6 files), scikit-image (2 files), scikit-learn (2 files), Image Processing Toolbox (1 file), OpenCV (1 file), Plotly (1 file), SimpleITK (1 file), statsmodels (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
56 files
At the source: github.com/murthylab/lightbead-analysis

Code availability statement

The paper has a code availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41467-026-72437-1.

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:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 132 scripts, each with its path and the digest of its content;
  • 10 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

Datasets cited

Code and data availability statement

The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41467-026-72437-1.

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, 30 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 6 authors, 2 keywords, 9 MeSH terms, 52 references.

Cite

This paper

Gauthey, W., Lin, A., Ahmed, O. M., Leifer, A. M., Murthy, M., & Thiberge, S. Y. (2026). High-speed whole-brain imaging in Drosophila. Nature communications, 17(1), 5810. https://doi.org/10.1038/s41467-026-72437-1

BibTeX

@article{gauthey2026high,
author = {Gauthey, Wayan and Lin, Albert and Ahmed, Osama M and Leifer, Andrew M and Murthy, Mala and Thiberge, Stephan Y},
title = {{High-speed whole-brain imaging in Drosophila}},
journal = {Nature communications},
year = {2026},
month = apr,
volume = {17},
number = {1},
pages = {5810},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-72437-1},
url = {https://doi.org/10.1038/s41467-026-72437-1},
pmid = {42050341},
pmcid = {PMC13328740}
}

RIS

TY - JOUR
AU - Gauthey, Wayan
AU - Lin, Albert
AU - Ahmed, Osama M
AU - Leifer, Andrew M
AU - Murthy, Mala
AU - Thiberge, Stephan Y
TI - High-speed whole-brain imaging in Drosophila
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/04/28
VL - 17
IS - 1
SP - 5810
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-72437-1
UR - https://doi.org/10.1038/s41467-026-72437-1
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-72437-1",
"type": "article-journal",
"title": "High-speed whole-brain imaging in Drosophila",
"container-title": "Nature communications",
"author": [
{
"family": "Gauthey",
"given": "Wayan"
},
{
"family": "Lin",
"given": "Albert"
},
{
"family": "Ahmed",
"given": "Osama M"
},
{
"family": "Leifer",
"given": "Andrew M"
},
{
"family": "Murthy",
"given": "Mala"
},
{
"family": "Thiberge",
"given": "Stephan Y"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "5810",
"DOI": "10.1038/s41467-026-72437-1",
"PMID": "42050341",
"PMCID": "PMC13328740",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-72437-1",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
28
]
]
}
}

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/s41586-026-10735-w [code]
Distributed control circuits across a brain-and-cord connectome.
Journal: Nature
In common: Plotly, scikit-image, scikit-learn, 4 other tools, drosophila, 4 references, author Mala Murthy
[2] doi:10.1038/s41467-026-72057-9 [code]
Sex-specific behavioral feedback modulates sensorimotor processing and drives flexible social behavior.
Journal: Nature communications
In common: OpenCV, scikit-image, h5py, 7 other tools, drosophila, systems, 4 references
[3] doi:10.1016/j.xpro.2026.104659 [code]
Protocol for simultaneous in vivo two-photon imaging and locomotion quantification during olfactory stimulation and pharmacology in walking Drosophila.
Journal: STAR protocols
In common: OpenCV, h5py, Pillow, 4 other tools, drosophila, 6 references
[4] doi:10.1038/s41467-026-72710-3 [code]
A modular multi-color fluorescence microscope for simultaneous tracking of cellular activity and behavior.
Journal: Nature communications
In common: OpenCV, scikit-image, Pillow, 6 other tools, drosophila, 5 references
[5] doi:10.3389/fnsys.2026.1822122 [code]
Convergence-divergence circuits for multimodal integration of innate and learned opponent valences.
Journal: Frontiers in systems neuroscience
In common: Plotly, scikit-image, h5py, 6 other tools, systems, 4 references
[6] doi:10.1038/s41592-026-03179-7 [code]
Voltage imaging of neurons distributed across entire brains of larval zebrafish.
Journal: Nature methods
In common: OpenCV, scikit-image, h5py, 3 other tools, systems, 6 references
[7] doi:10.1111/ejn.70582 [code]
Multifiber Array-Based Photometry System for Multiregional Functional Mapping in the Mouse Brain.
Journal: The European journal of neuroscience
In common: SimpleITK, OpenCV, scikit-image, 5 other tools, systems, 4 references
[8] doi:10.1002/alz.71649 [code]
Postmortem brain MRI reveals differential associations of subcortical and limbic volumes with cortical thinning and neurodegenerative pathologies.
Journal: Alzheimer's & dementia : the journal of the Alzheimer's Association
In common: SimpleITK, ANTs, Plotly, 9 other tools
[9] doi:10.1038/s41593-026-02232-0 [code]
Entorhinal cortex represents task-relevant remote locations independently of CA1.
Journal: Nature neuroscience
In common: OpenCV, scikit-image, h5py, 9 other tools, systems
[10] doi:10.21203/rs.3.rs-9326213/v1 [code]
Multi-task fMRI outperforms resting-state fMRI for revealing task-invariant organization of the human brain
Journal: Research Square (preprint)
In common: PsychoPy, ANTs, Plotly, 8 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.