OSCR

Spatial richness of neural magnetic fields.

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. [1] § 4 Methods › 4.5 Morphology reconstruction modified algorithm ↔ Ziad_MorphologyReconstruction4.ipynb, lines 330–403 · score 0.72 · axon hillock, best fit, outliers, closest, perpendicular, opposite
  2. [2] § 4 Methods › 4.5 Morphology reconstruction modified algorithm ↔ Ziad_MorphologyReconstruction5.ipynb, lines 333–406 · score 0.72 · axon hillock, best fit, outliers, closest, perpendicular, opposite
  3. [3] § 2 Results › 2.2 Neural signal scaling ↔ Ada_09_09_24_main.ipynb, lines 184–269 · score 0.67 · ball stick, soma diameter, axon diameter, axon length, segment, threshold
  4. [4] § 4 Methods › 4.2 Similarity calculation and template creation ↔ ZIAD_PointSpread.ipynb, lines 199–259 · score 0.57 · nearest neighbors, rotated coordinates
  5. [5] § 4 Methods › 4.3 Spike sorting recording generation ↔ MEArecTemplate/generators/spiketraingenerator.py, lines 125–167 · score 0.53 · refractory period, spike train, Poisson, neurons, cell

Paper

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

The paper is loaded when this pane is shown.

The authors' code

Jupyter notebook · 935 lines · 31 KB · CC-BY-4.0 · 1 match

  1. # %%
  2. from sklearn import svm, datasets
  3. from sklearn.linear_model import HuberRegressor
  4. from sklearn.neighbors import NearestNeighbors
  5. from scipy.spatial import distance
  6. import time
  7. import numpy as np
  8. import MEArecTemplate as mr
  9. from pathlib import Path
  10. import MEAutility as mu
  11. import LFPy
  12. import matplotlib.pyplot as plt
  14. # %%
  15. %run ZIAD_MEARecHelperFunctions.ipynb
  17. # %%
  18. # Get all signals from the grid of electrodes that exceed a certain threshold
  19. def get_strong_signals(data, elec_x, elec_y, thresh):
  20. data = data/np.max(abs(data))
  22. coords = []
  23. targets = []
  24. for i in range(len(data)):
  25. if np.max(abs(data[i])) >= thresh:
  26. coords.append([elec_x[i], elec_y[i]])
  28. # Target is 1 if signal is positive, 0 if negative
  29. targets.append(np.max(data[i]) > abs(np.min(data[i])))
  31. return np.array(coords), np.array(targets)
  33. def get_electrodes(mea_name):
  34. mea_cells_folder = '/Users/Ziad/.config/mearec/1.7.2/cell_models/MEArecLinearCells/'
  35. cell_name = 'L5_TTPC1_cADpyr232_1'
  36. cell_model_folder = Path(Path(mea_cells_folder) / cell_name)
  38. cell = mr.return_bbp_cell(cell_model_folder, end_T=1000, dt=0.03125, start_T=0)
  39. mea = mu.return_mea(mea_name)
  40. electrodes = LFPy.RecExtElectrode(cell, probe=mea)
  42. return electrodes
  44. def get_electrodes2(mea_name):
  45. m_idx = mea_name.find('MEA')
  46. count = int(np.sqrt(int(mea_name[:m_idx])))
  47. pitch = int(mea_name[m_idx+3:])
  49. max_coord = (count - 1)*pitch/2.0
  50. coords = np.arange(-1*max_coord, max_coord+1, pitch)
  52. elec_x = []
  53. elec_y = []
  54. for xcoord in coords:
  55. for ycoord in coords:
  56. elec_x.append(xcoord)
  57. elec_y.append(ycoord)
  59. return np.array(elec_x), np.array(elec_y)
  61. def make_meshgrid(x, y, h=.5):
  62. x_min, x_max = x.min() - 1, x.max() + 1
  63. y_min, y_max = y.min() - 1, y.max() + 1
  64. xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
  65. return xx, yy
  67. def plot_contours(ax, clf, xx, yy, **params):
  68. Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
  69. Z = Z.reshape(xx.shape)
  70. out = ax.contourf(xx, yy, Z, **params)
  71. return out, Z
  73. def load_cell(template_id, tempgen):
  74. # Load cell and position and rotation info
  75. mea_cells_folder = '/Users/Ziad/.config/mearec/1.7.2/cell_models/MEArecLinearCells/'
  76. cell_name = 'L5_TTPC1_cADpyr232_1'
  77. cell_model_folder = Path(Path(mea_cells_folder) / cell_name)
  79. T = 1000
  80. dt = 0.03125
  81. cell = mr.return_bbp_cell(cell_model_folder, end_T=T, dt=dt, start_T=0)
  83. pos = tempgen.locations[template_id]
  84. rot = tempgen.rotations[template_id]
  86. cell = mr.ziad_flatten_geometry(cell, pos, rot, 10)
  87. cell.set_pos(pos[0], pos[1], pos[2])
  88. cell.set_rotation(rot[0], rot[1], rot[2])
  90. return cell
  92. def get_apic_dist(template_id, all_y, all_z, clf, verbose=False):
  93. coords = np.zeros((2, np.shape(all_y)[1]))
  94. coords[0] = all_y[template_id]
  95. coords[1] = all_z[template_id]
  96. dists = abs(clf.decision_function(coords.T))/np.linalg.norm(clf.coef_)
  97. if verbose:
  98. print(dists)
  100. return np.mean(dists), np.std(dists)
  102. def get_apic_dist_real(template_id, all_y, all_z, xx, yy, clf, boundary = [], verbose=False):
  103. coords = np.zeros((np.shape(all_y)[1], 2))
  104. coords[:, 0] = all_y[template_id]
  105. coords[:, 1] = all_z[template_id]
  107. if len(boundary) == 0:
  108. dists = distance.cdist(coords, get_boundary_coords(xx, yy, clf), 'euclidean')
  109. else:
  110. dists = distance.cdist(coords, boundary, 'euclidean')
  112. dists = np.min(dists, axis=1)
  113. # if verbose:
  114. # print(dists)
  115. # plt.hist(dists, bins=30)
  117. return np.mean(dists), np.std(dists), dists
  119. def get_boundary_coords(xx, yy, clf):
  120. Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
  121. Z = Z.reshape(xx.shape)
  123. boundary = []
  124. for i in range(len(xx)):
  125. for j in range(1, len(xx[0])):
  126. if j > 0:
  127. if Z[i, j] != Z[i, j-1]:
  128. #print("hit1")
  129. midx = (xx[i, j] + xx[i, j-1]) / 2
  130. midy = yy[i, j]
  131. boundary.append([midx, midy])
  132. if i > 0:
  133. if Z[i, j] != Z[i-1, j]:
  134. #print("hit2")
  135. midx = xx[i, j]
  136. midy = (yy[i, j] + yy[i-1, j]) / 2
  137. boundary.append([midx, midy])
  138. #print(boundary)
  139. boundary = np.array(boundary)
  140. return boundary
  142. def generate_noise(snr, sig, shape):
  143. noise = np.random.normal(size=shape)
  145. sig_pwr = np.sum(sig**2)
  146. noise_pwr = sig_pwr/(10**(snr/10))
  147. noise_coeff = np.sqrt(noise_pwr/np.sum(noise**2))
  148. noise = noise*noise_coeff
  150. new_noise_pwr = np.sum(noise**2)
  152. #print("SNR: ", 10*np.log10(sig_pwr/noise_pwr))
  153. return noise
  155. def estimate_axon_hillock(signals, elec_x, elec_y, return_med = False):
  156. mags_pwr = np.sqrt(np.sum(signals**2, axis=1))
  157. mags_strong_indices = np.argsort(-1*mags_pwr)[:4]
  159. mags_relative_pwr = mags_pwr[mags_strong_indices] / np.sum(mags_pwr[mags_strong_indices])
  161. new_x = np.sum(elec_x[mags_strong_indices] * mags_relative_pwr)
  162. new_y = np.sum(elec_y[mags_strong_indices] * mags_relative_pwr)
  164. # Returns coordinates of other strong points
  165. if return_med:
  166. new_coords = []
  167. indices = np.arange(10, 100, 10)
  168. #indices = np.arange(4, 17, 4)
  169. for index in indices:
  170. mags_med_indices = np.argsort(-1*mags_pwr)[index:index+4]
  172. mags_relative_pwr_med = mags_pwr[mags_med_indices] / np.sum(mags_pwr[mags_med_indices])
  174. med_x = np.sum(elec_x[mags_med_indices] * mags_relative_pwr_med)
  175. med_y = np.sum(elec_y[mags_med_indices] * mags_relative_pwr_med)
  177. new_coords.append([med_x, med_y])
  179. return new_x, new_y, np.array(new_coords)
  181. return new_x, new_y
  183. def get_lbf_points(signals, indices, elec_x, elec_y):
  184. mags_pwr = np.sqrt(np.sum(signals**2, axis=1))
  186. new_coords = []
  187. #indices = np.arange(10, 100, 10)
  188. #indices = np.arange(4, 17, 4)
  189. for index in indices:
  190. mags_med_indices = np.argsort(-1*mags_pwr)[index:index+4]
  192. mags_relative_pwr_med = mags_pwr[mags_med_indices] / np.sum(mags_pwr[mags_med_indices])
  194. med_x = np.sum(elec_x[mags_med_indices] * mags_relative_pwr_med)
  195. med_y = np.sum(elec_y[mags_med_indices] * mags_relative_pwr_med)
  197. new_coords.append([med_x, med_y])
  199. return np.array(new_coords)
  201. def cast_lbf_to_boundary(lbf_coords, boundary):
  202. dists = distance.cdist(lbf_coords, boundary, 'euclidean')
  203. min_coord_idxs = np.argmin(dists, axis=1)
  204. cast_coords = boundary[min_coord_idxs]
  205. return cast_coords
  207. def calc_lbf(ah_x, ah_y, point_coords, loss_func, weight, eps = 1.35):
  208. x = np.zeros((len(point_coords[:, 0]) + 1,))
  209. y = np.zeros((len(point_coords[:, 1]) + 1,))
  210. x[0] = ah_x
  211. y[0] = ah_y
  212. x[1:] = point_coords[:, 0]
  213. y[1:] = point_coords[:, 1]
  214. weights = np.ones((len(x),))
  215. weights[0] = weight
  217. if loss_func == 'Huber':
  218. huber = HuberRegressor(epsilon = eps)
  219. try:
  220. huber.fit(x[:, None], y, sample_weight = weights)
  221. except ValueError as e:
  222. print(f"Value error with eps = {eps} - retrying with different epsilon")
  223. return -1e8, -1e8
  224. y1 = huber.predict([[0]])
  225. y2 = huber.predict([[1]])
  226. m = (y2 - y1)
  227. b = y1
  229. elif loss_func == 'Normal':
  230. m, b = np.polyfit(x, y, 1, w = weights)
  232. return m, b
  234. def load_cell(template_id, tempgen):
  235. # Load cell and position and rotation info
  236. mea_cells_folder = '/Users/Ziad/.config/mearec/1.7.2/cell_models/MEArecLinearCells/'
  237. cell_name = 'L5_TTPC1_cADpyr232_1'
  238. cell_model_folder = Path(Path(mea_cells_folder) / cell_name)
  240. T = 1000
  241. dt = 0.03125
  242. cell = mr.return_bbp_cell(cell_model_folder, end_T=T, dt=dt, start_T=0)
  244. pos = tempgen.locations[template_id]
  245. rot = tempgen.rotations[template_id]
  247. cell = mr.ziad_flatten_geometry(cell, pos, rot, 10)
  248. cell.set_pos(pos[0], pos[1], pos[2])
  249. cell.set_rotation(rot[0], rot[1], rot[2])
  251. return cell
  253. def remove_outliers(n_neighbors, cast_coords, max_range):
  254. # Remove outliers
  255. nbrs = NearestNeighbors(n_neighbors=n_neighbors, algorithm='ball_tree').fit(cast_coords)
  256. distances, indices = nbrs.kneighbors(cast_coords)
  257. avg_dists = np.mean(distances[:, 1:], axis=1)
  259. cast_coords_no_outliers = []
  260. for i in range(len(avg_dists)):
  261. if avg_dists[i] < max_range:
  262. cast_coords_no_outliers.append(cast_coords[i])
  263. return np.array(cast_coords_no_outliers)
  265. def gen_modified_coords(clf, signals, elec_x, elec_y, xx, yy, coords, params):
  267. min_dist = params['min_dist']
  268. max_dist = params['max_dist']
  269. num_points = params['num_points']
  271. opp_dist = params['opp_dist']
  273. # Get boundary estimation (true/false values assigned to dense coordinate map) and cast to boolean
  274. Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
  275. Z = Z.reshape(xx.shape)
  276. Z = (Z != 0)
  278. # Estimate axon hillock as well as direction of neuron
  279. ah_x, ah_y, new_coords = estimate_axon_hillock(signals, elec_x, elec_y, return_med = True)
  281. # Calculate line of best fit - assign half the points to be identical (axon hillock)
  282. mult = 2
  283. fit_coords = np.zeros((len(new_coords)*(mult+1), 2))
  284. fit_coords[:len(new_coords)*mult, 0] = ah_x
  285. fit_coords[:len(new_coords)*mult, 1] = ah_y
  286. fit_coords[len(new_coords)*mult:, 0] = new_coords[:, 0]
  287. fit_coords[len(new_coords)*mult:, 1] = new_coords[:, 1]
  288. m, b = np.polyfit(fit_coords[:, 0], fit_coords[:, 1], 1)
  290. # Find points above line
  291. q = yy > (xx*m + b)
  293. # Determine whether points above line are mostly in category 0 or 1 of SVM
  294. greater_than_category = np.sum(q & Z)/np.sum(q) > 0.5
  296. # Generate points close to axon_hillock along line of best fit at specified distances
  297. nearby_dists = np.linspace(min_dist, max_dist, num_points)
  299. # Find closest point to (ah_x, ah_y) on line
  300. b2 = ah_y + ah_x/m
  301. ah_x2 = (b2 - b)/(m + 1/m)
  302. ah_y2 = m*ah_x2 + b
  304. # Get nearby points along line of best fit
  305. nearby_x = nearby_dists/np.sqrt(1 + m**2) + ah_x2
  306. nearby_y = m*nearby_x + b
  308. # Get one point one either side of each of those points along the line perpendicular to line of best fit
  309. b_vals = nearby_y + nearby_x/m
  310. opposite_dists = np.arange(-1*opp_dist, opp_dist + 0.1, 2*opp_dist)
  311. opposite_x = np.add.outer(opposite_dists/np.sqrt(1 + (1/m)**2), nearby_x)
  312. b_vals = np.ones(np.shape(opposite_x)) * b_vals
  313. opposite_y = -1*opposite_x / m + b_vals
  315. # Generate modified coordinates and targets
  316. mod_coords = np.zeros((len(coords)+np.shape(opposite_x)[1]*np.shape(opposite_x)[0], 2))
  317. mod_coords[:len(coords), :] = coords
  318. mod_coords[len(coords):len(coords)+len(opposite_x[0]), 0] = opposite_x[0, :]
  319. mod_coords[len(coords):len(coords)+len(opposite_x[0]), 1] = opposite_y[0, :]
  320. mod_coords[len(coords) + len(opposite_x[0]):len(coords)+len(opposite_x[0])*2, 0] = opposite_x[1, :]
  321. mod_coords[len(coords) + len(opposite_x[0]):len(coords)+len(opposite_x[0])*2, 1] = opposite_y[1, :]
  323. mod_targets = np.zeros((len(mod_coords),))
  324. mod_targets[:len(targets)] = targets[:]
  325. mod_targets[len(targets):np.shape(opposite_x)[1] + len(targets)] = not greater_than_category
  326. mod_targets[len(targets) + np.shape(opposite_x)[1]:np.shape(opposite_x)[1]*2 + len(targets)] = greater_than_category
  328. return mod_coords, mod_targets
  330. def gen_modified_coords2(clf, signals, elec_x, elec_y, xx, yy, coords, boundary, params):
  332. min_dist = params['min_dist']
  333. max_dist = params['max_dist']
  334. num_points = params['num_points']
  336. opp_dist = params['opp_dist']
  337. weight = params['weight']
  338. eps = params['epsilon']
  339. max_range = params['max_range']
  341. # Get boundary estimation (true/false values assigned to dense coordinate map) and cast to boolean
  342. Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
  343. Z = Z.reshape(xx.shape)
  344. Z = (Z != 0)
  346. ah_x, ah_y, new_coords = estimate_axon_hillock(signals, elec_x, elec_y, return_med = True)
  348. indices = np.arange(4, 200, 4)
  349. new_coords = get_lbf_points(signals, indices, elec_x, elec_y)
  350. cast_coords = cast_lbf_to_boundary(new_coords, boundary)
  351. cast_coords = remove_outliers(4, cast_coords, max_range)
  352. m, b = calc_lbf(ah_x, ah_y, cast_coords, 'Normal', weight, eps = eps)
  354. # for i in range(3):
  355. # m, b = calc_lbf(ah_x, ah_y, cast_coords, 'Huber', weight, eps = eps)
  356. # if m != -1e8 and b != -1e8:
  357. # break
  358. # else:
  359. # eps += 0.05
  361. # if m == -1e8 and b == -1e8:
  362. # m, b = calc_lbf(ah_x, ah_y, cast_coords, 'Normal', weight, eps = eps)
  364. q = yy > (xx*m + b)
  365. greater_than_category = np.sum(q & Z)/np.sum(q) > 0.5
  367. # Points close to axon_hillock along line of best fit
  368. nearby_dists = np.linspace(min_dist, max_dist, num_points)
  369. #nearby_dists = np.arange(-5, 5.1, 0.01)*5
  371. # Find closest point to (ah_x, ah_y) on line
  372. b2 = ah_y + ah_x/m
  373. ah_x2 = (b2 - b)/(m + 1/m)
  374. ah_y2 = m*ah_x2 + b
  375. #print(ah_x, ah_x2)
  377. # Get nearby points along line of best fit
  378. nearby_x = nearby_dists/np.sqrt(1 + m**2) + ah_x2
  379. nearby_y = m*nearby_x + b
  381. #print(np.sqrt((nearby_x - ah_x2)**2 + (nearby_y - (ah_y2))**2))
  383. # Get one point one either side of each of those points along the line perpendicular to line of best fit
  384. b_vals = nearby_y + nearby_x/m
  385. opposite_dists = np.arange(-2, 2.1, 4)*5
  386. opposite_x = np.add.outer(opposite_dists/np.sqrt(1 + (1/m)**2), nearby_x)
  387. b_vals = np.ones(np.shape(opposite_x)) * b_vals
  388. opposite_y = -1*opposite_x / m + b_vals
  390. # Re-calculate SVM with modified coordinates
  391. mod_coords = np.zeros((len(coords)+np.shape(opposite_x)[1]*np.shape(opposite_x)[0], 2))
  392. mod_coords[:len(coords), :] = coords
  393. mod_coords[len(coords):len(coords)+len(opposite_x[0]), 0] = opposite_x[0, :]
  394. mod_coords[len(coords):len(coords)+len(opposite_x[0]), 1] = opposite_y[0, :]
  395. mod_coords[len(coords) + len(opposite_x[0]):len(coords)+len(opposite_x[0])*2, 0] = opposite_x[1, :]
  396. mod_coords[len(coords) + len(opposite_x[0]):len(coords)+len(opposite_x[0])*2, 1] = opposite_y[1, :]
  398. mod_targets = np.zeros((len(mod_coords),))
  399. mod_targets[:len(targets)] = targets[:]
  400. mod_targets[len(targets):np.shape(opposite_x)[1] + len(targets)] = not greater_than_category
  401. mod_targets[len(targets) + np.shape(opposite_x)[1]:np.shape(opposite_x)[1]*2 + len(targets)] = greater_than_category
  403. return mod_coords, mod_targets
  405. # %%
  406. # Run for all cells
  408. snrs = [40, 20, 0]
  409. mea_names = ['400MEA50', '400MEA75', '400MEA100']
  410. file_prefix = 'mag_templates_flattened_morphology_L5_TTPC1_cADpyr232_1_n300_'
  412. for snr in snrs:
  413. for mea_name in mea_names:
  414. # Parameters
  415. #mea_name = '400MEA50'
  416. thresh = 0.0
  417. #snr = 40
  418. iters_per_cell = 1
  419. C = 0.1
  420. gamma = 0.1
  421. cells = range(300)
  423. print(snr, mea_name)
  425. # Load template
  426. #templates_file = f'ziad_mearec_templates/mag_templates_flattened_morphology_L5_TTPC1_cADpyr232_1_n300_{mea_name}.h5'
  427. #tempgen = mr.tools.load_templates(templates_file, verbose=False)
  429. # Get apical dendrite coordinates and extracellular magnetic fields
  430. with open(f'{file_prefix}{mea_name}.npy', 'rb') as f:
  431. all_y = np.load(f)
  432. all_z = np.load(f)
  433. mags = np.load(f)
  436. # Main loop
  437. elec_x, elec_y = get_electrodes2(mea_name)
  438. xx, yy = make_meshgrid(np.array(elec_x), np.array(elec_y))
  440. dists = np.zeros((len(cells), iters_per_cell))
  441. dists_std = np.zeros((len(cells), iters_per_cell))
  442. dists_list = []
  443. dists_std_list = []
  444. fails = 0
  445. for n, template_id in enumerate(cells):
  446. #print("Template ID: ", template_id)
  447. for itr in range(iters_per_cell):
  448. #start = time.time()
  449. #elec_x, elec_y = get_electrodes2(mea_name)
  451. #cell = load_cell(template_id, tempgen)
  453. # Generate noise according to SNR parameter
  454. noise = generate_noise(snr, mags[template_id], np.shape(mags[template_id]))
  456. # Extract signals with magnitude that exceeds threshold
  457. signals = mags[template_id] + noise
  458. coords, targets = get_strong_signals(signals, elec_x, elec_y, thresh)
  460. # Estimate axon hillock based on strongest signals
  461. #ah_x, ah_y = estimate_axon_hillock(mags[template_id] + noise, elec_x, elec_y)
  462. #real_x = all_y[template_id][0]
  463. #real_y = all_z[template_id][0]
  464. #est_dist = np.sqrt((real_x - ah_x)**2 + (real_y - ah_y)**2)
  465. #print("Estimated axon hillock distance: ", est_dist)
  467. # Apply SVM to coordinates of strong signals
  468. model = svm.SVC(kernel="rbf")
  469. clf = model.fit(coords, targets)
  470. boundary = get_boundary_coords(xx, yy, clf)
  472. # Generate modified coordinates and calculate new SVM
  473. params = {}
  474. params['min_dist'] = -25
  475. params['max_dist'] = 25
  476. params['num_points'] = 1000
  477. params['opp_dist'] = 10
  478. params['weight'] = 100
  479. params['epsilon'] = 1.2
  480. params['max_range'] = 50
  481. mod_coords, mod_targets = gen_modified_coords2(clf, signals, elec_x, elec_y, xx, yy, coords, boundary, params)
  482. mod_model = svm.SVC(kernel='rbf')
  483. mod_clf = mod_model.fit(mod_coords, mod_targets)
  485. mod_boundary = get_boundary_coords(xx, yy, mod_clf)
  486. boundaries = [boundary, mod_boundary]
  488. # if len(boundary) != 0:
  489. # dist, std, all_dists = get_apic_dist_real(template_id, all_y, all_z, xx, yy, clf, boundary = boundary)
  490. # print("Original dist: ", dist)
  492. if len(mod_boundary) != 0:
  493. dist, std, all_dists = get_apic_dist_real(template_id, all_y, all_z, xx, yy, clf, boundary = mod_boundary)
  494. #print("Modified dist: ", dist)
  495. for i in range(len(all_dists)):
  496. print(all_dists[i], end='\t')
  497. #print()
  499. else:
  500. dist = 10000000
  501. std = 1000000
  503. print()
  504. #print('Dist: ', dist)
  505. if dist < 10000000:
  506. dists[n, itr] = dist
  507. dists_std[n, itr] = std
  508. dists_list.append(dist)
  509. dists_std_list.append(std)
  510. else:
  511. fails += 1
  512. #print("Time: ", time.time()-start)
  514. # %%
  515. for i in range(3):
  516. print(i)
  517. if i == 1:
  518. break
  520. # %%
  521. # Compute modified SVM for single cell
  522. file_prefix = 'mag_templates_flattened_morphology_L5_TTPC1_cADpyr232_1_n300_'
  523. mea_name = '400MEA50'
  524. snr = 40
  525. thresh = 0
  526. template_id = 8
  527. plot = True
  529. # Modified SVM parameters
  530. params = {}
  531. params['min_dist'] = -25
  532. params['max_dist'] = 25
  533. params['num_points'] = 100
  534. params['opp_dist'] = 10
  536. # Load actual coordinates of cell
  537. with open(f'{file_prefix}{mea_name}.npy', 'rb') as f:
  538. all_y = np.load(f)
  539. all_z = np.load(f)
  540. mags = np.load(f)
  542. # Get electrode coordinates
  543. elec_x, elec_y = get_electrodes2(mea_name)
  544. xx, yy = make_meshgrid(np.array(elec_x), np.array(elec_y))
  546. # Generate noise according to SNR parameter
  547. noise = generate_noise(snr, mags[template_id], np.shape(mags[template_id]))
  549. # Extract signals with magnitude that exceeds threshold
  550. signals = mags[template_id] + noise
  551. coords, targets = get_strong_signals(signals, elec_x, elec_y, thresh)
  553. # Apply SVM to coordinates of strong signals
  554. model = svm.SVC(kernel="rbf")
  555. clf = model.fit(coords, targets)
  556. boundary = get_boundary_coords(xx, yy, clf)
  557. dist, std, all_dists = get_apic_dist_real(template_id, all_y, all_z, xx, yy, clf, boundary = boundary)
  558. print("Original dist: ", dist)
  560. # Plot original SVM
  561. tempgen = mr.tools.load_templates('ziad_mearec_templates/' + file_prefix + mea_name + '.h5', verbose=False)
  562. cell = load_cell(template_id, tempgen)
  563. if plot:
  564. fig, ax = plotcell_1plane_morph(cell, 1000, 1000)
  565. ax.set_xlim([-600, 600])
  566. ax.set_ylim([-600, 600])
  567. #out, Z = plot_contours(ax, clf, xx, yy, cmap=plt.cm.coolwarm, alpha=0.8)
  568. Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
  569. Z = Z.reshape(xx.shape)
  570. Z = (Z != 0)
  572. # Generate modified coordinates
  573. # mod_coords, mod_targets = gen_modified_coords(clf, signals, elec_x, elec_y, xx, yy, coords, params)
  574. # mod_model = svm.SVC(kernel='rbf')
  575. # mod_clf = mod_model.fit(mod_coords, mod_targets)
  577. # Estimate axon hillock and plot
  578. ah_x, ah_y, new_coords = estimate_axon_hillock(signals, elec_x, elec_y, return_med = True)
  579. if plot:
  580. ax.scatter(ah_x, ah_y, color='green')
  581. ax.scatter(new_coords[:, 0], new_coords[:, 1], color='black')
  583. # mult = 2
  584. # fit_coords = np.zeros((len(new_coords)*(mult+1), 2))
  585. # fit_coords[:len(new_coords)*mult, 0] = ah_x
  586. # fit_coords[:len(new_coords)*mult, 1] = ah_y
  587. # fit_coords[len(new_coords)*mult:, 0] = new_coords[:, 0]
  588. # fit_coords[len(new_coords)*mult:, 1] = new_coords[:, 1]
  589. # m, b = np.polyfit(fit_coords[:, 0], fit_coords[:, 1], 1)
  591. weight = 100
  592. eps = 1.25
  593. indices = np.arange(4, 200, 4)
  594. new_coords = get_lbf_points(signals, indices, elec_x, elec_y)
  595. cast_coords = cast_lbf_to_boundary(new_coords, boundary)
  597. ax.scatter(cast_coords[:, 0], cast_coords[:, 1], color='red')
  599. # Remove outliers
  600. nbrs = NearestNeighbors(n_neighbors=4, algorithm='ball_tree').fit(cast_coords)
  601. distances, indices = nbrs.kneighbors(cast_coords)
  602. avg_dists = np.mean(distances[:, 1:], axis=1)
  603. max_range = 50
  604. cast_coords_no_outliers = []
  605. for i in range(len(avg_dists)):
  606. if avg_dists[i] < max_range:
  607. cast_coords_no_outliers.append(cast_coords[i])
  608. cast_coords = np.array(cast_coords_no_outliers)
  610. ax.scatter(cast_coords[:, 0], cast_coords[:, 1], color='purple')
  612. m, b = calc_lbf(ah_x, ah_y, cast_coords, 'Huber', weight, eps = eps)
  613. line_x_coords = np.linspace(np.min(elec_x), np.max(elec_x), 400)
  615. if plot:
  616. ax.plot(line_x_coords, m*line_x_coords + b, color = 'blue')
  618. m2, b2 = calc_lbf(ah_x, ah_y, cast_coords, 'Normal', weight)
  619. line_x_coords = np.linspace(np.min(elec_x), np.max(elec_x), 400)
  621. if plot:
  622. ax.plot(line_x_coords, m2*line_x_coords + b2, color = 'orange')
  624. # weight = 1000
  625. # fit_coords = np.zeros((len(new_coords)+1, 2))
  626. # fit_coords[0, 0] = ah_x
  627. # fit_coords[0, 1] = ah_y
  628. # fit_coords[1:, 0] = new_coords[:, 0]
  629. # fit_coords[1:, 1] = new_coords[:, 1]
  630. # weights = np.ones((len(new_coords)+1,))
  631. # weights[0] = weight
  632. # m, b = np.polyfit(fit_coords[:, 0], fit_coords[:, 1], 1, w = weights)
  634. # line_x_coords = np.linspace(np.min(elec_x), np.max(elec_x), 400)
  636. # if plot:
  637. # ax.plot(line_x_coords, m*line_x_coords + b, color = 'orange')
  639. # q = yy > (xx*m + b)
  640. # print(np.unique(Z))
  641. # greater_than_category = np.sum(q & Z)/np.sum(q) > 0.5
  643. # # Points close to axon_hillock along line of best fit
  644. # nearby_dists = np.arange(-5, 5.1, 0.01)*5
  646. # # Find closest point to (ah_x, ah_y) on line
  647. # b2 = ah_y + ah_x/m
  648. # ah_x2 = (b2 - b)/(m + 1/m)
  649. # ah_y2 = m*ah_x2 + b
  650. # print(ah_x, ah_x2)
  652. # # Get nearby points along line of best fit
  653. # nearby_x = nearby_dists/np.sqrt(1 + m**2) + ah_x2
  654. # nearby_y = m*nearby_x + b
  656. # print(np.sqrt((nearby_x - ah_x2)**2 + (nearby_y - (ah_y2))**2))
  658. # # Get one point one either side of each of those points along the line perpendicular to line of best fit
  659. # b_vals = nearby_y + nearby_x/m
  660. # opposite_dists = np.arange(-2, 2.1, 4)*5
  661. # opposite_x = np.add.outer(opposite_dists/np.sqrt(1 + (1/m)**2), nearby_x)
  662. # b_vals = np.ones(np.shape(opposite_x)) * b_vals
  663. # opposite_y = -1*opposite_x / m + b_vals
  665. # if plot:
  666. # ax.plot(opposite_x[0, :], opposite_y[0, :], color='purple')
  667. # ax.plot(opposite_x[1, :], opposite_y[1, :], color='green')
  669. # # ax.contourf(xx, yy, q, alpha = 0.4)
  671. # # Re-calculate SVM with modified coordinates
  672. # mod_coords = np.zeros((len(coords)+np.shape(opposite_x)[1]*np.shape(opposite_x)[0], 2))
  673. # mod_coords[:len(coords), :] = coords
  674. # mod_coords[len(coords):len(coords)+len(opposite_x[0]), 0] = opposite_x[0, :]
  675. # mod_coords[len(coords):len(coords)+len(opposite_x[0]), 1] = opposite_y[0, :]
  676. # mod_coords[len(coords) + len(opposite_x[0]):len(coords)+len(opposite_x[0])*2, 0] = opposite_x[1, :]
  677. # mod_coords[len(coords) + len(opposite_x[0]):len(coords)+len(opposite_x[0])*2, 1] = opposite_y[1, :]
  679. # mod_targets = np.zeros((len(mod_coords),))
  680. # mod_targets[:len(targets)] = targets[:]
  681. # mod_targets[len(targets):np.shape(opposite_x)[1] + len(targets)] = not greater_than_category
  682. # mod_targets[len(targets) + np.shape(opposite_x)[1]:np.shape(opposite_x)[1]*2 + len(targets)] = greater_than_category
  684. # sample_weights = np.ones((len(mod_targets),))
  685. # sample_weights[len(targets):] = 1
  687. # mod_model = svm.SVC(kernel="rbf")
  688. # mod_clf = mod_model.fit(mod_coords, mod_targets)
  689. # mod_boundary = get_boundary_coords(xx, yy, mod_clf)
  690. # dist, std, all_dists_mod = get_apic_dist_real(template_id, all_y, all_z, xx, yy, clf, boundary = mod_boundary)
  691. # print("Modified dist: ", dist)
  693. # if plot:
  694. # fig, ax = plotcell_1plane_morph(cell, 1000, 1000)
  695. # out, Z = plot_contours(ax, mod_clf, xx, yy, cmap=plt.cm.coolwarm, alpha=0.8)
  697. # print("Original Dists: ", all_dists[:10])
  698. # print("Modified Dists: ", all_dists_mod[:10])
  700. # %%
  701. a = []
  702. a.append([2, 0])
  703. a.append([4, 3])
  704. a.append([0, 0])
  705. print(np.shape(np.array(a)))
  707. # %%
  708. nbrs = NearestNeighbors(n_neighbors=4, algorithm='ball_tree').fit(cast_coords)
  709. distances, indices = nbrs.kneighbors(cast_coords)
  710. avg_dists = np.mean(distances[:, 1:], axis=1)
  711. print(np.shape(avg_dists))
  712. print(np.shape(avg_dists[avg_dists < 50]))
  713. print(indices)
  715. # %%
  716. fig, ax = plotcell_1plane_morph(cell, 1000, 1000)
  717. #out, Z = plot_contours(ax, clf, xx, yy, cmap=plt.cm.coolwarm, alpha=0.8)
  719. weight = 100
  720. indices = np.arange(4, 200, 4)
  721. new_coords = get_lbf_points(signals, indices, elec_x, elec_y)
  722. cast_coords = cast_lbf_to_boundary(new_coords, boundary)
  723. ax.scatter(cast_coords[:, 0], cast_coords[:, 1], color='red')
  725. m, b = calc_lbf(ah_x, ah_y, cast_coords, 'Huber', weight, eps = 1.1)
  726. print(m, b)
  727. line_x_coords = np.linspace(-250, 150, 400)
  729. if plot:
  730. plt.plot(line_x_coords, m*line_x_coords + b, color = 'blue')
  732. m, b = calc_lbf(ah_x, ah_y, cast_coords, 'Normal', weight)
  733. print(m, b)
  734. line_x_coords = np.linspace(np.min(elec_x), np.max(elec_x), 400)
  736. if plot:
  737. plt.plot(line_x_coords, m*line_x_coords + b, color = 'orange')
  739. plt.xlim([-475, 475])
  740. plt.ylim([-475, 475])
  742. # %%
  743. np.max(elec_x)
  745. # %%
  746. line_x_coords = np.linspace(np.min(elec_x), np.max(elec_x), 400)
  748. m, b = calc_lbf(ah_x, ah_y, fit_coords[1:, :], 'Huber', 1000)
  749. plt.plot(line_x_coords, m*line_x_coords + b, color = 'orange')
  751. m, b = calc_lbf(ah_x, ah_y, fit_coords[1:, :], 'Normal', 1000)
  752. plt.plot(line_x_coords, m*line_x_coords + b, color = 'green')
  754. # %%
  755. print(all_y[template_id, 0], all_z[template_id, 0])
  756. soma = np.zeros((1, 2))
  757. soma[0] = [all_y[template_id, 0], all_z[template_id, 0]]
  758. print(boundary)
  759. dist = distance.cdist(soma, boundary)
  760. print(np.min(dist), np.argmin(dist))
  762. # %%
  763. print(all_y[template_id, 0], all_z[template_id, 0])
  764. soma = np.zeros((1, 2))
  765. soma[0] = [all_y[template_id, 0], all_z[template_id, 0]]
  766. print(boundary)
  767. dist = distance.cdist(soma, mod_boundary)
  768. print(np.min(dist), np.argmin(dist))
  770. # %%
  771. plt.plot(all_dists)
  772. plt.plot(all_dists_mod)
  774. # %%
  775. a = np.zeros((3, 2))
  776. a[0] = [0, 0]
  777. a[1] = [2, 1]
  778. a[2] = [-3, 2]
  780. b = np.zeros((2, 2))
  781. b[0] = [4, 5]
  782. b[1] = [-4, 0]
  784. np.min(distance.cdist(a, b), axis=1)
  786. #get_apic_dist_real(template_id, all_y, all_z, xx, yy, clf, boundary = boundary)
  788. # %%
  789. nearby_dists = np.arange(-5, 5.1, 1)
  791. # Find closest point to (ah_x, ah_y) on line
  792. b2 = ah_y + ah_x/m
  793. ah_x2 = (b2 - b)/(m + 1/m)
  794. ah_y2 = m*ah_x2 + b
  795. print(ah_x, ah_x2)
  797. # Get nearby points along line of best fit
  798. nearby_x = nearby_dists/np.sqrt(1 + m**2) + ah_x2
  799. nearby_y = m*nearby_x + b
  801. print(np.sqrt((nearby_x - ah_x2)**2 + (nearby_y - (ah_y2))**2))
  803. # Get one point one either side of each of those points along the line perpendicular to line of best fit
  804. b_vals = nearby_y + nearby_x/m
  805. opposite_dists = np.arange(-2, 2.1, 4)
  806. print(nearby_x)
  807. opposite_x = np.add.outer(opposite_dists/np.sqrt(1 + (1/m)**2), nearby_x)
  808. b_vals = np.ones(np.shape(opposite_x)) * b_vals
  809. opposite_y = -1*opposite_x / m + b_vals
  810. print(opposite_y)
  812. # %%
  813. np.shape(targets)
  815. # %%
  816. mod_coords
  818. # %%
  819. mod_targets = np.zeros((len(mod_coords),))
  820. mod_targets[:len(targets)] = targets[:]
  821. mod_targets[len(targets):np.shape(opposite_x)[1] + len(targets)] = not greater_than_category
  822. mod_targets[len(targets) + np.shape(opposite_x)[1]:np.shape(opposite_x)[1]*2 + len(targets)] = greater_than_category
  823. print(mod_targets[400:])
  825. # %%
  826. greater_than_category
  828. # %%
  829. with open(f'mag_templates_flattened_morphology_L5_TTPC1_cADpyr232_1_n300_400MEA50.npy', 'rb') as f:
  830. all_y = np.load(f)
  831. all_z = np.load(f)
  832. mags = np.load(f)
  834. elec_x, elec_y = get_electrodes2('400MEA50')
  836. # %%
  837. mags_pwr = np.sqrt(np.sum(mags[0]**2, axis=1))
  838. mags_strong_indices = np.argsort(-1*mags_pwr)[:4]
  839. mags_relative_pwr = mags_pwr[mags_strong_indices] / np.sum(mags_pwr[mags_strong_indices])
  841. new_x = np.sum(elec_x[mags_strong_indices] * mags_relative_pwr)
  842. new_y = np.sum(elec_y[mags_strong_indices] * mags_relative_pwr)
  844. print(new_x, new_y)
  846. # %%
  847. elec_x[mags_strong_indices] * mags_relative_pwr
  849. # %% [markdown]
  850. # ### IGNORE EVERYTHING BELOW THIS POINT
  852. # %%
  853. dists_list = np.array(dists_list)
  854. dists_std_list = np.array(dists_std_list)
  856. print("Mean distance: ", np.mean(dists_list))
  857. print("Mean std of dist: ", np.sqrt(np.mean(dists_std_list**2)))
  858. print("Num fails: ", fails)
  860. # %%
  861. np.sqrt(np.mean(dists_std[:, 0]**2))
  863. # %%
  864. for i in range(len(dists)):
  865. mean_total = 0
  866. var_total = 0
  867. count = 0
  868. for j in range(len(dists[0])):
  869. if dists[i, j] < 1000000:
  870. mean_total += dists[i, j]
  871. var_total += dists_std[i, j]**2
  872. count += 1
  873. print(mean_total/count, '\t', np.sqrt(var_total/count))
  876. # %%
  877. dists[0, 1] = 60
  878. dists[0, 2] = 1000000
  879. dists_std[0] = 12
  881. # %%
  882. elec_y
  884. # %%
  885. electrodes = get_electrodes('400MEA75')
  886. elec_x = electrodes.y
  887. elec_y = electrodes.z
  889. # %%
  890. len(elec_x)
  892. # %%
  893. a, b = get_electrodes2('400MEA75')
  895. # %%
  896. len(a)
  898. # %%
  899. np.arange(-1*max_coord, max_coord+1, pitch)
  901. # %%
  902. l1 = 100
  903. l2 = 300
  904. a = np.random.random(l1)
  905. b = np.random.random(l2)
  906. c = np.zeros(l1+l2)
  907. c[:l1] = a
  908. c[l1:] = b
  910. print(np.std(a))
  911. print(np.std(b))
  912. print(np.std(c))
  914. # %%
  915. print(np.sqrt((np.std(a)**2*(l1-1) + np.std(b)**2*(l2-1))/(l1+l2-2)))
  916. print(np.sqrt((np.std(a)**2*(l1) + np.std(b)**2*(l2))/(l1+l2)))
  918. # %%
  919. w = 1e-3
  920. r = 1e-3
  922. I = 10000e-9
  923. N = 100
  924. mu_r = 1000
  925. f = 1e3
  927. B_flux = w*np.log((r+w)/r)*I*2e-7
  928. print(B_flux)
  929. print(I*2e-7/(r+w/2))
  931. emf = N*mu_r*B_flux*f
  932. print(emf*1e9, 'nV')
  934. # %%

Ziad_MorphologyReconstruction4.ipynb, under CC-BY-4.0 · at the source

Overview

Authors: Ziad Ali1, Ada S Y Poon1
ORCID iDs: Ziad Ali, Ada S Y Poon
  1. Electrical Engineering Department, Stanford University, Stanford, California, United States of America
Institutions: Stanford University (United States)
Journal: PLoS computational biology, volume 22, issue 5, article e1014283
Dates: received 3 October 2025; accepted 29 April 2026; published online 22 May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1371/journal.pcbi.1014283 · PMID 42172273 · PMCID PMC13196990 · OpenAlex W4410256442
Open access: gold, a free copy (OpenAlex)
Preprint: doi:10.1101/2025.05.08.652049
Status: code verified
Categories: computational modeling (no new data) (modality), human (organism), computational (subfield)
Methods: Spectral & time-frequency, Statistics, Machine learning, Single-unit activity, calcium imaging
MeSH: Magnetic Fields*, Models, Neurological*, Neurons*, Action Potentials, Animals, Brain, Computational Biology, Computer Simulation, Humans (* major topic)
Topic: Neural Networks and Applications (Artificial Intelligence, Computer Science), according to OpenAlex
Funding: National Science Foundation; Stanford Bio-X; Wu Tsai Neurosciences Institute, Stanford University (SG4-19); National Science Foundation Graduate Research Fellowship Program
Citations: not cited yet (Europe PMC); 68 references in the paper

Abstract

Brain implants that measure neural magnetic fields, rather than electrical potentials, are expected to confer significant clinical advantages related to implant longevity and signal fidelity due to the elimination of the electrode-tissue interface. However, the informational differences between neural electrical potentials and magnetic fields remain poorly understood. Using a mathematical formalism based on neuronal current sources, we directly establish the complementary informational content of extracellular magnetic fields and electrical potentials. This formalism also reveals that extracellular magnetic fields generated by spiking neurons inherently exhibit one order lower spatial polarity than electric fields, resulting in more favorable distance-scaling characteristics. We then use computational modeling to illustrate how dense networks of neurons are easier to distinguish and spike sort on the basis of their magnetic, rather than electrical, spike templates. Lastly, we show how the solenoidal nature of neural magnetic fields facilitates approximate morphological reconstruction, even with sparse sensor arrays. Our findings highlight the unique experimental advantages of neural magnetic field sensing, motivating the development of compact, low-noise devices capable of meeting the stringent sensitivity requirements for cortical recordings.

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

Repository

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

figshare 32061105

License: CC-BY-4.0
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Size: 7 files
Software Heritage: not checked
Found in: “Data Availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NEURON (387 files), NumPy (54 files), Matplotlib (45 files), LFPy (12 files), SciPy (12 files), scikit-learn (10 files), Plotly (7 files), h5py (6 files), Elephant (4 files), Neo (4 files), SymPy (2 files), SpikeInterface (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers (HTTP 200)
  • 28 September 2026: the link answers (HTTP 200)
410 files
At the source: doi.org/10.6084/m9.figshare.32061105

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

Tracing map

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

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 410 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

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

Data Availability

Data and code can be accessed at https://doi.org/10.6084/m9.figshare.32061105.

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

  • Funding: added National Science Foundation; Stanford Bio-X; Wu Tsai Neurosciences Institute, Stanford University: SG4-19; National Science Foundation Graduate Research Fellowship Program

Version 1, 28 September 2026: the first record

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

Cite

This paper

Ali, Z., & Poon, A. S. Y. (2026). Spatial richness of neural magnetic fields. PLoS computational biology, 22(5), e1014283. https://doi.org/10.1371/journal.pcbi.1014283

BibTeX

@article{ali2026spatial,
author = {Ali, Ziad and Poon, Ada S Y},
title = {{Spatial richness of neural magnetic fields}},
journal = {PLoS computational biology},
year = {2026},
month = may,
volume = {22},
number = {5},
pages = {e1014283},
publisher = {PLOS},
issn = {1553-734X},
doi = {10.1371/journal.pcbi.1014283},
url = {https://doi.org/10.1371/journal.pcbi.1014283},
pmid = {42172273},
pmcid = {PMC13196990}
}

RIS

TY - JOUR
AU - Ali, Ziad
AU - Poon, Ada S Y
TI - Spatial richness of neural magnetic fields
T2 - PLoS computational biology
J2 - PLoS Comput Biol
PY - 2026
DA - 2026/05/22
VL - 22
IS - 5
SP - e1014283
SN - 1553-734X
PB - PLOS
DO - 10.1371/journal.pcbi.1014283
UR - https://doi.org/10.1371/journal.pcbi.1014283
LA - en
ER -

CSL-JSON

{
"id": "10.1371/journal.pcbi.1014283",
"type": "article-journal",
"title": "Spatial richness of neural magnetic fields",
"container-title": "PLoS computational biology",
"author": [
{
"family": "Ali",
"given": "Ziad"
},
{
"family": "Poon",
"given": "Ada S Y"
}
],
"container-title-short": "PLoS Comput Biol",
"volume": "22",
"issue": "5",
"page": "e1014283",
"DOI": "10.1371/journal.pcbi.1014283",
"PMID": "42172273",
"PMCID": "PMC13196990",
"ISSN": "1553-734X",
"publisher": "PLOS",
"URL": "https://doi.org/10.1371/journal.pcbi.1014283",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
22
]
]
}
}

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.1016/j.isci.2026.115488 [code]
An integrated &lt;i&gt;i&lt;/i&gt; &lt;i&gt;n vitro&lt;/i&gt; platform and biophysical modeling approach for studying synaptic transmission in isolated neuronal pairs.
Journal: iScience
In common: LFPy, Elephant, Neo, 7 other tools, 2 references
[2] doi:10.7554/elife.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: Neo, SpikeInterface, h5py, 4 other tools, 3 references
[3] doi:10.1093/bioinformatics/btag328 [code]
eFEL: electrophysiology feature extraction library.
Journal: Bioinformatics (Oxford, England)
In common: Neo, NEURON, h5py, 4 other tools, 2 references
[4] doi:10.1371/journal.pcbi.1014730 [code]
A unified model of short- and long-term plasticity: Effects on network connectivity and information capacity.
Journal: PLoS computational biology
In common: Elephant, Neo, SymPy, 4 other tools, computational modeling (no new data)
[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: Neo, SpikeInterface, h5py, 4 other tools, 2 references
[6] doi: [code]
Naturalistic behavior and self-generated neural activity predictive of self-correction
Journal: bioRxiv : the preprint server for biology
In common: Elephant, Neo, SpikeInterface, 4 other tools
[7] doi:10.7554/elife.103046 [code]
Dichotomy between extracellular signatures of active dendritic chemical synapses and gap junctions.
Journal: eLife
In common: LFPy, NEURON, Matplotlib, 1 other tool, 3 references
[8] doi:10.1371/journal.pcbi.1014304 [code]
Linking reduced prefrontal microcircuit inhibition in schizophrenia to EEG biomarkers in silico.
Journal: PLoS computational biology
In common: LFPy, NEURON, scikit-learn, 3 other tools, 1 reference
[9] doi:10.7554/elife.110170 [code]
Efficient and reproducible pipelines for spike sorting large-scale electrophysiology data.
Journal: eLife
In common: SpikeInterface, NumPy, 5 references
[10] doi:10.1186/s12974-026-03890-4 [code]
Neuronal toll-like receptor-4 regulation of matrix metalloproteinase-9 activity mediates dentate circuit dysfunction after traumatic brain injury.
Journal: Journal of neuroinflammation
In common: Neo, SpikeInterface, h5py, 4 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.