OSCR

Neuropixels Opto: combining high-resolution electrophysiology and optogenetics.

Code ↔ Paper

5 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 5 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § Methods › Activating local neural populations › Data processing ↔ spks/sorting.py, lines 74–133 · score 0.62 · phase shift, bandpass filter, Kilosort
  2. [2] § Methods › Spike sorting and quality metrics ↔ spks/clusters.py, lines 240–323 · score 0.61 · amplitude cutoff, presence ratio, ISI, clusters, metrics, spike
  3. [3] § Results › Optotagging nearby neurons ↔ spks/clusters.py, lines 240–323 · score 0.59 · amplitude cutoff, presence ratio, firing rates, ISI, metrics, waveforms
  4. [4] § Methods › Optotagging nearby neurons (AI) › Data processing ↔ spks/sorting.py, lines 74–133 · score 0.57 · phase shift, Kilosort, pipeline, preprocessing, raw, filter
  5. [5] § Methods › Optotagging nearby neurons (AI) › Data processing ↔ spks/postprocess.py, the whole file · a weak match · score 0.50 · waveform amplitudes, Kilosort, peak, location, spike

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 · 514 lines · 24 KB · no license · 2 matches

  1. # Run various spike sorters using spike interface precompiled docker images
  2. # This should allow running it on a fast disk and copying only the relevant files over
  3. # The functions and parameters should be exposed and contained in this module.
  4. from .utils import *
  5. from .raw import *
  7. def get_probename(filename):
  8. # get the probe name from a file (only works with spikeglx?)
  9. probename = re.search(r'\s*imec[0-9]*[a-z]?\s*',str(filename))
  10. if not probename is None:
  11. return str(probename.group()).strip('/').strip('.')
  12. else:
  13. return 'probe0'
  15. def get_sorting_folder_path(filename,
  16. sorting_results_path_rules = ['..','..','{sortname}','{probename}'],
  17. sorting_folder_dictionary = dict(sortname = 'sorting',
  18. probename = 'probe0')):
  19. '''
  20. Gets the sorting folder path from a defined rule.
  22. foldername = get_sorting_folder_path(filename)
  23. '''
  25. filename = Path(filename)
  26. if filename.is_file():
  27. foldername = filename.parent
  29. sorting_folder_dictionary['probename'] = get_probename(filename)
  31. sorting_results_path = foldername #FIXME: not defined if filename isn't file
  32. for f in sorting_results_path_rules:
  33. if f == '..':
  34. foldername = foldername.parent
  35. else:
  36. foldername = foldername.joinpath(f.format(**sorting_folder_dictionary))
  37. return foldername
  39. def move_sorting_results(
  40. scratch_folder,
  41. original_session_path,
  42. move_filtered_data = False,
  43. sorting_results_path_rules = ['..','..','{sortname}','{probename}'],
  44. sorting_folder_dictionary = dict(
  45. sortname = 'sorting',
  46. probename = 'probe0')):
  47. '''
  48. Move spike sorting results to a standardized folder
  50. '''
  51. sorting_results_path = get_sorting_folder_path(
  52. filename = original_session_path,
  53. sorting_folder_dictionary=sorting_folder_dictionary,
  54. sorting_results_path_rules=sorting_results_path_rules)
  56. files_to_copy = []
  57. extensions = ['.npy','.tsv','.hdf','.m','.mat','.py','.log']
  58. if move_filtered_data:
  59. extensions += ['filtered_recording.*.bin']
  60. for name in extensions:
  61. files_to_copy += scratch_folder.glob(f'*{name}')
  62. if not sorting_results_path.exists():
  63. sorting_results_path.mkdir(parents=True, exist_ok=True)
  64. for f in tqdm(files_to_copy,desc = 'Moving files'):
  65. if os.path.exists(sorting_results_path/f.name):
  66. os.remove(sorting_results_path/f.name) #need to delete files before moving to avoid weird permission error
  67. try:
  68. shutil.move(f,sorting_results_path/f.name)
  69. except Exception as err:
  70. print(err)
  71. print(f'FAILED to move {f} to {sorting_results_path}')
  72. return sorting_results_path
  74. def run_kilosort(sessionfiles = [],
  75. channels = None,
  76. foldername = None,
  77. temporary_folder = 'temporary',
  78. version = '4.0',
  79. sorting_results_path_rules = ['..','..','{sortname}','{probename}'],
  80. sorting_folder_dictionary = dict(sortname = None, probename = 'probe0'),
  81. do_post_processing = False,
  82. device = 'cuda',
  83. gpu_index = 0,
  84. split_shanks = False,
  85. motion_correction = True,
  86. dredge_motion_correction = False,
  87. thresholds = None,
  88. batch_size = int(60000),
  89. lowpass = 300.,
  90. highpass = 13000.,
  91. filter_pipeline_par = [dict(function = 'bandpass_filter_gpu',
  92. sampling_rate = 30000,
  93. lowpass = 300,
  94. highpass = 13000,
  95. return_gpu = True),
  96. dict(function = 'phase_shift_gpu',
  97. sample_shifts = None,
  98. return_gpu = True),
  99. dict(function = 'global_car_gpu',
  100. return_gpu = False)]):
  101. '''
  102. Runs kilosort given binary files, returns a folder with the results.
  103. '''
  105. using_scratch = False
  106. if foldername is None:
  107. foldername = create_temporary_folder(temporary_folder, prefix=f'ks{version}_sorting')
  108. using_scratch = True
  110. for f in filter_pipeline_par:
  111. if 'lowpass' in f.keys() and not lowpass is None:
  112. f['lowpass'] = lowpass
  113. if 'highpass' in f.keys() and not highpass is None:
  114. f['highpass'] = highpass
  116. tt = RawRecording(sessionfiles,device = device,
  117. filter_pipeline_par = filter_pipeline_par,
  118. return_preprocessed = True)
  119. dtype = 'int16'
  120. binaryfilepath = pjoin(foldername,'filtered_recording.{probename}.bin'.format(
  121. **sorting_folder_dictionary))
  122. output_folder = os.path.dirname(binaryfilepath)
  124. if not os.path.exists(output_folder):
  125. os.makedirs(output_folder)
  126. print(f'Exporting binary to {binaryfilepath}')
  127. if channels is None:
  128. channels = tt.channel_info.channel_idx.values
  129. print(tt.offsets,len(sessionfiles),len(sessionfiles)>1)
  130. print(sessionfiles)
  131. binaryfile,metadata = tt.to_binary(binaryfilepath,
  132. filter_pipeline_par = filter_pipeline_par,
  133. channels = channels)
  135. if dredge_motion_correction:
  136. from .raw import dredge_motion_correct_binary_file,dredge_motion_correct_across_sessions
  137. n_jobs = 10
  138. print(len(sessionfiles),len(sessionfiles)>1)
  139. if len(sessionfiles)>1:
  140. print('Using multisession dredge.')
  141. binaryfilepath = dredge_motion_correct_across_sessions(binaryfilepath=binaryfilepath,
  142. metadata = metadata,
  143. n_jobs = n_jobs)
  144. else:
  145. print('Using single session dredge.')
  146. binaryfilepath = dredge_motion_correct_binary_file(binaryfilepath,
  147. nchannels = metadata['nchannels'],
  148. sampling_rate = metadata['sampling_rate'],
  149. channel_coords = metadata['channel_coords'],
  150. channel_shank = metadata['channel_shank'],
  151. output_folder = foldername,
  152. overwrite = True,
  153. output_dtype = 'int16',
  154. n_jobs = n_jobs)
  155. dtype = 'int16'
  156. print('Motion corrected done with dredge so skipping kilosort motion.')
  157. motion_correction = 0
  159. del tt # RawRecording no longer needed
  160. channelmappath = pjoin(os.path.dirname(binaryfilepath),'chanMap.mat')
  161. opspath = pjoin(os.path.dirname(binaryfilepath),'ops.mat')
  162. if lowpass is None:
  163. lowpass = 300.
  165. nchannels = metadata['nchannels']
  166. coords = np.stack(metadata['channel_coords'])
  167. # make the channelmap file
  168. chanMap = dict(Nchannels = nchannels,
  169. connected = np.ones(nchannels,dtype=bool).T,
  170. xcoords = coords[:,0].astype(float),
  171. ycoords = coords[:,1].astype(float),
  172. chanMap = np.array(metadata['channel_idx'],dtype=np.int64)+1,
  173. chanMap0ind = np.array(metadata['channel_idx'],dtype=np.int64),
  174. kcoords = np.array(metadata['channel_shank'],dtype=float).T+1,
  175. fs = metadata['sampling_rate'])
  176. from scipy.io import savemat
  177. savemat(channelmappath, chanMap,appendmat = False)
  179. if version == '2.5':
  180. compiled_name = 'kilosort2_5'
  181. if thresholds is None:
  182. thresholds = [9.,3.]
  183. ops = dict(ops = dict(default_ks25_ops,
  184. NchanTOT=float(metadata['nchannels']),
  185. Nchan = float(len(metadata['channel_idx'])),
  186. fbinary = binaryfilepath,
  187. fproc = pjoin(output_folder,'temp_wh.dat'),
  188. chanMap = channelmappath,
  189. fs = metadata['sampling_rate'],
  190. doCorrection = int(motion_correction),
  191. fshigh = lowpass,
  192. Th = thresholds,
  193. GPU = gpu_index + 1)) # indices are one based ...
  194. matlabcommand = kilosort25_matlabcommand
  195. elif version == '3.0':
  196. compiled_name = 'kilosort3_0'
  197. if thresholds is None:
  198. thresholds = [9.,9.]
  199. ops = dict(ops = dict(default_ks30_ops,
  200. NchanTOT=float(metadata['nchannels']),
  201. Nchan = float(len(metadata['channel_idx'])),
  202. fbinary = binaryfilepath,
  203. fproc = pjoin(output_folder,'temp_wh.dat'),
  204. chanMap = channelmappath,
  205. fs = metadata['sampling_rate'],
  206. doCorrection = int(motion_correction),
  207. fshigh = lowpass,
  208. Th = thresholds,
  209. GPU = gpu_index + 1)) # indices are one based ...
  210. if version in ['2.5','3.0']:
  211. # save the files
  212. savemat(opspath, ops,appendmat = False)
  213. import shutil
  214. if not shutil.which(compiled_name) is None:
  215. os.system(f'{compiled_name} {output_folder}') # easier to kill than subprocess?
  216. else: # just run using a local installation..
  217. matlabfile = pjoin(output_folder,'run_ks.m')
  218. with open(matlabfile,'w') as f:
  219. f.write(matlabcommand.format(output_folder = output_folder))
  220. cmd = """matlab -nodisplay -nosplash -r "run('{0}');" """.format(matlabfile)
  221. os.system(cmd) # easier to kill than subprocess?
  222. elif version == '4.0':
  223. if thresholds is None:
  224. thresholds = [9.,8.]
  225. res = run_kilosort4(
  226. device = device,
  227. foldername = foldername,
  228. binaryfilepath = binaryfilepath,
  229. metadata = metadata,
  230. motion_correction = motion_correction,
  231. thresholds = thresholds,
  232. dtype = dtype,
  233. batch_size = batch_size)
  234. else:
  235. raise(OSError('Undefined version {version}'))
  236. if do_post_processing:
  237. foldername = kilosort_post_processing(
  238. foldername,
  239. sessionfiles,
  240. move = using_scratch,
  241. binaryfilepath = binaryfilepath,
  242. sorting_results_path_rules = sorting_results_path_rules,
  243. sorting_folder_dictionary = sorting_folder_dictionary)
  244. return foldername
  246. def run_kilosort4(device, foldername, binaryfilepath,
  247. metadata,
  248. dtype = 'int16',
  249. thresholds = None, # pass a list if needed
  250. do_car = False,
  251. batch_size = int(60000),
  252. motion_correction = 1):
  253. nchannels = metadata['nchannels']
  254. coords = np.stack(metadata['channel_coords'])
  256. yc = coords[:,1].astype(np.float32)
  257. xc = coords[:,0].astype(np.float32)
  258. fix_shanks = False # flag to fix the phy coords # this is now fixed on v4.04
  259. if fix_shanks:
  260. # lets stack the shanks... because kilosort 4.0 can not handle multiple shanks..
  261. previous = 0
  262. for shank in np.unique(metadata['channel_shank']):
  263. idx = np.where(metadata['channel_shank'] == shank)
  264. offset = np.max(yc[idx])
  265. yc[idx] = (yc[idx]-np.min(yc[idx])) + previous
  266. xc[idx] = (xc[idx]-np.min(xc[idx]))
  267. previous += 100 + offset
  269. probe = dict(n_chan = nchannels,
  270. xc = xc,
  271. yc = yc,
  272. chanMap = np.array(metadata['channel_idx'], dtype=int),
  273. kcoords = np.array(metadata['channel_shank'], dtype=int).T)
  275. from kilosort import run_kilosort
  276. settings = dict(fs = metadata['sampling_rate'],
  277. n_chan_bin = nchannels,
  278. batch_size = batch_size,
  279. data_dir = foldername)
  281. settings['nblocks'] = int(motion_correction)
  282. if not thresholds is None:
  283. settings['Th_universal'] = thresholds[0]
  284. settings['Th_learned'] = thresholds[1]
  286. res = run_kilosort(filename = binaryfilepath,
  287. results_dir = foldername,
  288. settings = settings,
  289. data_dtype = dtype,
  290. probe = probe,
  291. device = device,
  292. do_CAR = do_car,
  293. save_preprocessed_copy = False,
  294. save_extra_vars = True) # save pc_features
  296. if fix_shanks:
  297. ops = res[0]
  298. st = res[1]
  299. tF = res[3]
  300. ops['xc'],ops['yc'] = coords.astype(np.float32).T # recompute the spike positions
  301. from kilosort.postprocessing import compute_spike_positions
  302. positions = compute_spike_positions(st,tF,ops)
  303. np.save(Path(foldername)/'spike_positions.npy',np.vstack(positions).T) # overwrite spike positions
  304. np.save(Path(foldername)/'channel_positions.npy',coords.astype(float)) # save the correct channel positions
  305. del res
  306. free_gpu()
  307. return True
  309. def kilosort_post_processing(resultsfolder,
  310. sessionfolder,
  311. move = False,
  312. binaryfilepath = None,
  313. sorting_results_path_rules = ['..','..','{sortname}','{probename}'],
  314. sorting_folder_dictionary = dict(
  315. sortname = 'kilosort',
  316. probename = 'probe0'),
  317. max_n_spikes = 1000):
  318. '''
  319. Post processing for kilosort results
  321. 1. remove duplicates
  322. 2. compute_waveforms
  323. 3. store a sample of 1000 waveforms to disk
  324. 4. move the files to a new folder and if so delete the scratch folder
  326. '''
  327. # 1. remove duplicates
  328. from .clusters import Clusters
  329. resultsfolder = Path(resultsfolder)
  330. sp = Clusters(resultsfolder,get_metrics = False,get_waveforms=False,load_template_features = True)
  331. sp.remove_duplicate_spikes(overwrite_phy=True)
  332. del sp
  333. # 2. compute_waveforms and store to disk
  334. sp = Clusters(resultsfolder,get_metrics = False,get_waveforms=False)
  335. meta = load_dict_from_h5(list(resultsfolder.glob('filtered_recording.*.metadata.hdf'))[0])
  336. from .io import map_binary
  337. if binaryfilepath is None:
  338. binaryfilepath = list(resultsfolder.glob('filtered_recording.*.bin'))[0]
  339. data = map_binary(binaryfilepath,meta['nchannels'])
  340. # don't filter the waveforms because it was done before.
  341. sp.extract_waveforms(data,np.arange(meta['nchannels']),
  342. max_n_spikes=max_n_spikes,
  343. save_folder_path = resultsfolder,filter_par = None)
  344. del sp
  345. # Compute metrics and mean waveforms
  346. sp = Clusters(resultsfolder,get_metrics = True, get_waveforms=True, load_template_features = True)
  347. del sp # close so it can move
  348. # 4. move the files to a new folder
  349. if move:
  350. if type(sessionfolder) in [list]:
  351. folder = sessionfolder[0]
  352. print(f'Saving to {folder}')
  353. else:
  354. folder = sessionfolder
  355. outputfolder = move_sorting_results(
  356. resultsfolder,
  357. folder,
  358. sorting_results_path_rules = sorting_results_path_rules,
  359. sorting_folder_dictionary = sorting_folder_dictionary)
  360. # 5. delete the scratch
  361. shutil.rmtree(resultsfolder)
  362. resultsfolder = outputfolder
  363. return resultsfolder # Clusters(resultsfolder) to open
  365. from .io import list_spikeglx_binary_paths
  367. def sort_multiprobe_sessions(sessions,
  368. temporary_folder = '/scratch',
  369. method = 'kilosort2.5',
  370. sorting_results_path_rules = ['..','..','{sortname}','{probename}'],
  371. sorting_folder_dictionary = dict(
  372. sortname = 'kilosort', probename = 'probe0'),
  373. do_post_processing = True,
  374. move = True,
  375. device = 'cuda',
  376. gpu_index = 0,
  377. motion_correction = True):
  378. '''
  379. Sort multiprobe neuropixels recordings (will concatenate multiple sessions if a list is passed).
  380. '''
  381. if not type(sessions) is list:
  382. sessions = [sessions]
  384. tmp = [list_spikeglx_binary_paths(s) for s in sessions]
  385. all_probe_dirs = []
  386. for iprobe in range(len(tmp[0])):
  387. all_probe_dirs.append([t[iprobe][0] for t in tmp])
  388. results = []
  389. for probepath in all_probe_dirs:
  390. print('Running {1} on sessions {0}'.format(' ,'.join(probepath),method))
  391. sorting_folder_dictionary['probename'] = get_probename(probepath)
  393. results_folder = run_kilosort(sessionfiles = probepath,
  394. version = method.strip('kilosort'),
  395. temporary_folder = temporary_folder,
  396. sorting_results_path_rules = sorting_results_path_rules,
  397. sorting_folder_dictionary = sorting_folder_dictionary,
  398. do_post_processing = False,
  399. motion_correction = motion_correction,
  400. device=device, gpu_index = gpu_index)
  401. print('Completed {1} Results folder: {0}'.format(results_folder,method))
  402. if do_post_processing:
  403. results_folder = kilosort_post_processing(
  404. results_folder,
  405. probepath,
  406. sorting_results_path_rules = sorting_results_path_rules,
  407. sorting_folder_dictionary = sorting_folder_dictionary,
  408. move = move)
  409. print('Completed sorting for results folder: {0}'.format(results_folder))
  410. results.append(results_folder)
  411. return results
  413. kilosort25_matlabcommand = '''
  414. load(fullfile('{output_folder}','ops.mat'))
  415. load(fullfile('{output_folder}','chanMap.mat'))
  416. % This assumes kilosort 2.5 and all are installed and on the path
  417. % preprocess data to create temp_wh.dat
  418. rez = preprocessDataSub(ops);
  419. rez = datashift2(rez, ops.doCorrection); % last input is for shifting data
  421. % ORDER OF BATCHES IS NOW RANDOM, controlled by random number generator
  422. iseed = 1;
  423. rez = learnAndSolve8b(rez, iseed); % main tracking and template matching algorithm
  425. % OPTIONAL: remove double-counted spikes - solves issue in which individual spikes are assigned to multiple templates.
  426. % See issue 29: https://github.com/MouseLand/Kilosort/issues/29
  427. % rez = remove_ks2_duplicate_spikes(rez);
  429. rez = find_merges(rez, 1); % final merges
  430. rez = splitAllClusters(rez, 1); % final splits by SVD
  431. rez = set_cutoff(rez); % decide on cutoff
  432. rez.good = get_good_units(rez); % eliminate widely spread waveforms (likely noise)
  433. fprintf('found %d good units', sum(rez.good>0))
  434. fprintf('Saving results to Phy ')
  435. rezToPhy(rez, '{output_folder}'); % write to Phy
  436. exit(1);
  437. '''
  439. default_ks25_ops = dict(
  440. datatype = 'dat',
  441. trange = [0.,np.inf],
  442. CAR = 1.,
  443. nblocks = 5.,
  444. sig = 20.,
  445. lam = 10.,
  446. AUCsplit = 0.9,
  447. minFR = 1./50,
  448. momentum = [20.,400.],
  449. sigmaMask = 30.,
  450. ThPre = 8.,
  451. spkTh = -6.,
  452. reorder = 1.,
  453. nskip = 25.,
  454. nfilt_factor = 4.,
  455. ntbuff = 64.,
  456. NT = 65600.,
  457. whiteningRange = 32.,
  458. nSkipCov = 25.,
  459. scaleproc = 200.,
  460. nPCs = 3,
  461. useRam = 0,
  462. nt0 = 61.)
  464. default_ks30_ops = dict(
  465. datatype = 'dat',
  466. trange = [0.,np.inf],
  467. CAR = 1.,
  468. nblocks = 5.,
  469. sig = 20.,
  470. lam = 20.,
  471. AUCsplit = 0.8,
  472. minFR = 1./50,
  473. momentum = [20.,400.],
  474. sigmaMask = 30.,
  475. ThPre = 8.,
  476. spkTh = -6.,
  477. reorder = 1.,
  478. nskip = 25.,
  479. nfilt_factor = 4.,
  480. ntbuff = 64.,
  481. NT = 65600.,
  482. whiteningRange = 32.,
  483. nSkipCov = 25.,
  484. scaleproc = 200.,
  485. nPCs = 3,
  486. useRam = 0,
  487. nt0 = 61.)
  490. class SpikeSorting(object):
  491. def __init__(raw_files, output_folder,
  492. filter_pipeline_par = [dict(function = 'bandpass_filter_gpu',
  493. sampling_rate = 30000,
  494. lowpass = 300,
  495. highpass = 10000,
  496. return_gpu = False),
  497. dict(function = 'global_car_gpu',
  498. return_gpu = True)],
  499. temporary_folder = None, motion_correction = True, **kwargs):
  500. ''' Run a spike sorter.
  501. 1) Creates the output folder.
  502. 2) Concatenates the input files.
  503. 3) Writes a json file with the onsets and offsets of each file, the channelmap
  504. 4) Downloads a sorter image and runs it in the temporaty folder
  505. 5) Copies the files to the output folder and cleans the temporary folder
  508. THIS IS A PLACEHOLDER FOR NOW.
  509. '''
  510. pass

sorting.py at commit 451691a, no license · at the source

Overview

Authors: Anna A. Lakunina1, Karolina Z. Socha2, Alexander E. Ladd3, Anna J. Bowen3, Susu Chen4, Jennifer Colonell4, Anjal Doshi1, Bill Karsh4,5, Michael Krumin2, Pavel Kulik1, Anna J. Li3, Pieter Neutens6, John O’Callaghan6, Meghan Olsen1, Jan Putzeys6, Charu Bai Reddy2, Harrie A. C. Tilmans6, Sara Vargas7, Marleen Welkenhuysen6, Zhiwen Ye3
and 9 other authorsMichael Häusser8, Christof Koch9, Jonathan T. Ting3,7, Barundeb Dutta6, Timothy D. Harris4,5, Nicholas A. Steinmetz3, Karel Svoboda1,4, Joshua H. Siegle1, Matteo Carandini2
ORCID iDs: Anna A. Lakunina, Karolina Z. Socha, Alexander E. Ladd, Anna J. Bowen, Susu Chen, Jennifer Colonell, Anjal Doshi, Bill Karsh, Michael Krumin, Pavel Kulik, Anna J. Li, Pieter Neutens, John O’Callaghan, Meghan Olsen, Jan Putzeys, Charu Bai Reddy, Harrie A. C. Tilmans, Sara Vargas, Marleen Welkenhuysen, Zhiwen Ye, Michael Häusser, Christof Koch, Jonathan T. Ting, Barundeb Dutta, Timothy D. Harris, Nicholas A. Steinmetz, Karel Svoboda, Joshua H. Siegle, Matteo Carandini
  1. Allen Institute for Neural Dynamics,Seattle, WA USA
  2. UCL Institute of Ophthalmology, University College London,London, UK
  3. Department of Neurobiology and Biophysics, University of Washington,Seattle, WA USA
  4. Janelia Research Campus, Howard Hughes Medical Institute,Ashburn, VA USA
  5. Department of Biomedical Engineering, Johns Hopkins University,Baltimore, MD USA
  6. IMEC,Leuven, Belgium
  7. Allen Institute for Brain Science,Seattle, WA USA
  8. Wolfson Institute for Biomedical Research, University College London,London, UK
  9. Allen Institute MindScope Program,Seattle, WA USA
Institutions: Allen Institute for Neural Dynamics (United States); University College London (United Kingdom); University of Washington (United States); Howard Hughes Medical Institute (United States); Johns Hopkins University (United States); IMEC (Belgium); Allen Institute for Brain Science (United States); Allen Institute (United States)
Journal: Nature methods, volume 23, issue 6, pages 1207-1216
Dates: received 21 February 2025; accepted 24 March 2026; published online 1 June 2026; in print 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41592-026-03076-z · PMID 42225964 · PMCID PMC13259958 · OpenAlex W4407229385
Open access: hybrid, a free copy (OpenAlex)
Preprint: doi:10.1101/2025.02.04.636286
Status: code verified
Categories: extracellular electrophysiology (units, LFP) (modality), mouse (organism), systems (subfield)
Methods: Spectral & time-frequency, Preprocessing, Evoked potentials, fMRI & imaging, Single-unit activity, calcium imaging, Connectivity
Keywords: Extracellular recording, Neurophysiology, Optogenetics
MeSH: Electrophysiology*, Neurons*, Optogenetics*, Animals, Mice (* major topic)
Topic: Photoreceptor and optogenetics research (Cellular and Molecular Neuroscience, Neuroscience), according to OpenAlex
Funding: Wellcome Trust (Wellcome) (204915/Z/16/Z, 225819/Z/22/Z); NIH (UF1MH128339, U01NS133760); Howard Hughes Medical Institute (HHMI) (--); Pew Charitable Trusts (Pew Biomedical Scholars Program); Esther A. and Joseph Klingenstein Fund (EAJK Fund); Simons Foundation; Allen Foundation (Allen Foundation Inc.) (--)
Citations: cited by 8 papers (Europe PMC); 99 references in the paper
Research resources: RRID:AB_10000240, RRID:AB_2534096, Alexa Fluor 647 RRID:AB_2535809, RRID:AB_2665811

Abstract

High-resolution extracellular electrophysiology is the gold standard for recording spikes from distributed neural populations and is especially powerful when combined with optogenetics for manipulation of specific cell types with high temporal resolution. We integrated these approaches into prototype Neuropixels Opto probes, which combine electronic and photonic circuits. These devices pack 960 electrical recording sites and two sets of 14 light emitters onto a 70-μm-wide, 1-cm-long shank, allowing spatially addressable optogenetic stimulation with blue and red light. In mouse cortex, Neuropixels Opto probes delivered high-quality recordings together with spatially addressable optogenetics, differentially activating or silencing neurons at distinct cortical depths. In the mouse striatum and other deep structures, Neuropixels Opto probes delivered efficient optotagging, facilitating the identification of two cell types in parallel. Neuropixels Opto probes represent a promising tool for recording, identifying and manipulating neuronal populations.

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 5 matches between paragraphs and lines of code.

spkware/spks

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 451691a558650c80696a6871377f33986f3abb2f, 18 March 2026
Languages: Python (15), Jupyter (4)
Size: 21 files, 19 scripts
Software Heritage: not archived
Found in: the text, “Data processing”
Holds: README, environment (setup.py), 4 notebooks
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: SciPy (6 files), Matplotlib (4 files), h5py (3 files), NumPy (3 files), PyTorch (2 files), Kilosort (1 file), pandas (1 file), SpikeInterface (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
20 files
At the source: github.com/spkware/spks

AllenInstitute/MIES

License: BSD-2-Clause
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 5e6410391e0a92988c37df39c3ea435bd96af058, 17 September 2026
Languages: Shell (28), C/C++ (14), Python (2), C++ (2), C (1)
Size: 1,065 files, 47 scripts
Software Heritage: archived
Found in: the text, “In vitro electrophysiology and optogenetic stimu”
Holds: README, license file, environment (tools/documentation/Dockerfile, tools/documentation/requirements.in, tools/documentation/requirements.txt, tools/ftp-upload/Dockerfile, tools/nwb-read-tests/Dockerfile, tools/nwb-read-tests/requirements.in, tools/nwb-read-tests/requirements.txt, tools/pre-commit/Dockerfile, tools/pre-commit/requirements.in, tools/pre-commit/requirements.txt, tools/report-generator/Dockerfile), tests, continuous integration, documentation
Not found: CITATION.cff
Tools: h5py (1 file), Neurodata Without Borders (PyNWB, MatNWB) (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
49 files
At the source: github.com/AllenInstitute/MIES

codeocean.allenneuraldynamics.org/capsule/1593868

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: the link answers
Software Heritage: not checked
Found in: “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 (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
At the source: codeocean.allenneuraldynamics.org/capsule/1593868/tree/v1

Code availability

The code used in this study is available in open repositories under open access licenses. Code for the electrical and optical characterizations (Fig. 2 and Extended Data Figs. 2b–e and 3a,b) is available via Figshare at 10.5522/04/31268383 (ref. 97). Code for the experiments demonstrating recording and activation of local neural populations (Fig. 3 and Extended Data Figs. 4 and 5) is available via Zenodo at 10.5281/zenodo.18461445 (ref. 99). Code for the spatially resolved neural inactivations (Fig. 4 and Extended Data Figs. 6 and 7) is available via Figshare at 10.6084/m9.figshare.31271761 (ref. 98). Code for the subcortical optotagging experiments (Figs. 5 and 6 and Extended Data Figs. 3c–f, 8 and 10) is available via Code Ocean at https://codeocean.allenneuraldynamics.org/capsule/1593868/tree/v1.

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

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:

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

Data availability

The data from this study are available in open repositories under open access licenses. Data from the electrical and optical characterizations (Fig. 2 and Extended Data Figs. 2b–e and 3a,b) are available via Figshare at 10.5522/04/31268383 (ref. 97). Data from the experiments demonstrating recording and activation of local neural populations (Fig. 3 and Extended Data Figs. 4 and 5) are available via Zenodo at 10.5281/zenodo.18461445. Data from the spatially resolved neural inactivations (Fig. 4 and Extended Data Figs. 6 and 7) are available via Figshare at 10.6084/m9.figshare.31271761 (ref. 98). Data from the subcortical optotagging experiments (Figs. 5 and 6 and Extended Data Figs. 3c–f, 8 and 10) are available via Code Ocean at https://codeocean.allenneuraldynamics.org/capsule/1593868/tree/v1.

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 2, 28 September 2026

  • Publisher: n/a → Nature Portfolio

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 29 authors, 3 keywords, 5 MeSH terms, 7 funders, 94 references, 4 RRIDs.

Cite

This paper

Lakunina, A. A., Socha, K. Z., Ladd, A. E., Bowen, A. J., Chen, S., Colonell, J., Doshi, A., Karsh, B., Krumin, M., Kulik, P., Li, A. J., Neutens, P., O’Callaghan, J., Olsen, M., Putzeys, J., Bai Reddy, C., Tilmans, H. A. C., Vargas, S., Welkenhuysen, M., . . . Carandini, M. (2026). Neuropixels Opto: combining high-resolution electrophysiology and optogenetics. Nature methods, 23(6), 1207-1216. https://doi.org/10.1038/s41592-026-03076-z

BibTeX

@article{lakunina2026neuropixels,
author = {Lakunina, Anna A. and Socha, Karolina Z. and Ladd, Alexander E. and Bowen, Anna J. and Chen, Susu and Colonell, Jennifer and Doshi, Anjal and Karsh, Bill and Krumin, Michael and Kulik, Pavel and Li, Anna J. and Neutens, Pieter and O’Callaghan, John and Olsen, Meghan and Putzeys, Jan and Bai Reddy, Charu and Tilmans, Harrie A. C. and Vargas, Sara and Welkenhuysen, Marleen and Ye, Zhiwen and Häusser, Michael and Koch, Christof and Ting, Jonathan T. and Dutta, Barundeb and Harris, Timothy D. and Steinmetz, Nicholas A. and Svoboda, Karel and Siegle, Joshua H. and Carandini, Matteo},
title = {{Neuropixels Opto: combining high-resolution electrophysiology and optogenetics}},
journal = {Nature methods},
year = {2026},
month = jun,
volume = {23},
number = {6},
pages = {1207--1216},
publisher = {Nature Portfolio},
issn = {1548-7091},
doi = {10.1038/s41592-026-03076-z},
url = {https://doi.org/10.1038/s41592-026-03076-z},
pmid = {42225964},
pmcid = {PMC13259958}
}

RIS

TY - JOUR
AU - Lakunina, Anna A.
AU - Socha, Karolina Z.
AU - Ladd, Alexander E.
AU - Bowen, Anna J.
AU - Chen, Susu
AU - Colonell, Jennifer
AU - Doshi, Anjal
AU - Karsh, Bill
AU - Krumin, Michael
AU - Kulik, Pavel
AU - Li, Anna J.
AU - Neutens, Pieter
AU - O’Callaghan, John
AU - Olsen, Meghan
AU - Putzeys, Jan
AU - Bai Reddy, Charu
AU - Tilmans, Harrie A. C.
AU - Vargas, Sara
AU - Welkenhuysen, Marleen
AU - Ye, Zhiwen
AU - Häusser, Michael
AU - Koch, Christof
AU - Ting, Jonathan T.
AU - Dutta, Barundeb
AU - Harris, Timothy D.
AU - Steinmetz, Nicholas A.
AU - Svoboda, Karel
AU - Siegle, Joshua H.
AU - Carandini, Matteo
TI - Neuropixels Opto: combining high-resolution electrophysiology and optogenetics
T2 - Nature methods
J2 - Nat Methods
PY - 2026
DA - 2026/06/01
VL - 23
IS - 6
SP - 1207
EP - 1216
SN - 1548-7091
PB - Nature Portfolio
DO - 10.1038/s41592-026-03076-z
UR - https://doi.org/10.1038/s41592-026-03076-z
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41592-026-03076-z",
"type": "article-journal",
"title": "Neuropixels Opto: combining high-resolution electrophysiology and optogenetics",
"container-title": "Nature methods",
"author": [
{
"family": "Lakunina",
"given": "Anna A."
},
{
"family": "Socha",
"given": "Karolina Z."
},
{
"family": "Ladd",
"given": "Alexander E."
},
{
"family": "Bowen",
"given": "Anna J."
},
{
"family": "Chen",
"given": "Susu"
},
{
"family": "Colonell",
"given": "Jennifer"
},
{
"family": "Doshi",
"given": "Anjal"
},
{
"family": "Karsh",
"given": "Bill"
},
{
"family": "Krumin",
"given": "Michael"
},
{
"family": "Kulik",
"given": "Pavel"
},
{
"family": "Li",
"given": "Anna J."
},
{
"family": "Neutens",
"given": "Pieter"
},
{
"family": "O’Callaghan",
"given": "John"
},
{
"family": "Olsen",
"given": "Meghan"
},
{
"family": "Putzeys",
"given": "Jan"
},
{
"family": "Bai Reddy",
"given": "Charu"
},
{
"family": "Tilmans",
"given": "Harrie A. C."
},
{
"family": "Vargas",
"given": "Sara"
},
{
"family": "Welkenhuysen",
"given": "Marleen"
},
{
"family": "Ye",
"given": "Zhiwen"
},
{
"family": "Häusser",
"given": "Michael"
},
{
"family": "Koch",
"given": "Christof"
},
{
"family": "Ting",
"given": "Jonathan T."
},
{
"family": "Dutta",
"given": "Barundeb"
},
{
"family": "Harris",
"given": "Timothy D."
},
{
"family": "Steinmetz",
"given": "Nicholas A."
},
{
"family": "Svoboda",
"given": "Karel"
},
{
"family": "Siegle",
"given": "Joshua H."
},
{
"family": "Carandini",
"given": "Matteo"
}
],
"container-title-short": "Nat Methods",
"volume": "23",
"issue": "6",
"page": "1207-1216",
"DOI": "10.1038/s41592-026-03076-z",
"PMID": "42225964",
"PMCID": "PMC13259958",
"ISSN": "1548-7091",
"publisher": "Nature Portfolio",
"URL": "https://doi.org/10.1038/s41592-026-03076-z",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
1
]
]
}
}

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.7554/elife.110170 [code]
Efficient and reproducible pipelines for spike sorting large-scale electrophysiology data.
Journal: eLife
In common: SpikeInterface, Neurodata Without Borders (PyNWB, MatNWB), pandas, 1 other tool, extracellular electrophysiology (units, LFP), mouse, 7 references, 2 authors
[2] doi:10.1038/s41467-026-71331-0 [code]
A multimodal approach for visualizing and identifying electrophysiological cell types in vivo.
Journal: Nature communications
In common: PyTorch, pandas, SciPy, 2 other tools, extracellular electrophysiology (units, LFP), mouse, 5 references, 2 authors
[3] doi:10.7554/elife.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: Kilosort, SpikeInterface, Neurodata Without Borders (PyNWB, MatNWB), 6 other tools, extracellular electrophysiology (units, LFP), mouse, 5 references
[4] doi:10.1038/s41593-026-02232-0 [code]
Entorhinal cortex represents task-relevant remote locations independently of CA1.
Journal: Nature neuroscience
In common: Kilosort, SpikeInterface, Neurodata Without Borders (PyNWB, MatNWB), 6 other tools, systems, mouse, 2 references
[5] doi:10.1016/j.patter.2026.101590 [code]
Density-based longitudinal neuron tracking in high-density electrophysiological recordings.
Journal: Patterns (New York, N.Y.)
In common: Kilosort, SpikeInterface, h5py, 5 other tools, extracellular electrophysiology (units, LFP), 4 references
[6] doi:10.1016/j.crmeth.2026.101421 [code]
EthoPy provides an accessible platform for reproducible behavioral neuroscience.
Journal: Cell reports methods
In common: Neurodata Without Borders (PyNWB, MatNWB), h5py, pandas, 3 other tools, mouse, 7 references
[7] doi:10.1038/s41467-026-71664-w [code]
Dorsal prefrontal cortex drives perseverative behavior in mice.
Journal: Nature communications
In common: Kilosort, NumPy, systems, mouse, 8 references
[8] doi:10.7554/elife.109717 [code]
Retrosplenial cortex enables context-dependent goal-directed sensorimotor transformation.
Journal: eLife
In common: Kilosort, Neurodata Without Borders (PyNWB, MatNWB), h5py, 4 other tools, systems, mouse, 3 references
[9] doi:10.1038/s41467-026-76581-6 [code]
Thalamocortical bursts encode reward contingencies and drive associative learning.
Journal: Nature communications
In common: Kilosort, h5py, pandas, 3 other tools, systems, mouse, 4 references
[10] doi:10.1016/j.celrep.2026.117420 [code]
Neural population dynamics of direct electrical stimulation of neocortex.
Journal: Cell reports
In common: Neurodata Without Borders (PyNWB, MatNWB), pandas, SciPy, 2 other tools, extracellular electrophysiology (units, LFP), systems, mouse, 4 references

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.