OSCR

Mouse white matter matters: cortical origins and spatial organization of mouse white matter tracts.

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] § Materials and methods ↔ Projection_Density_Filtered_AllenSDK_Pipeline.ipynb, lines 257 to 291 · score 1.00 · SSP tr, SSP un, SSp bfd, SSp ul, AUDpo, ORBvl · Report a mismatch
  2. [2] § Materials and methods ↔ AllenSDK_Pipeline.ipynb, lines 107 to 135 · score 1.00 · SSP tr, SSP un, SSp bfd, SSp ul, AUDpo, ORBvl · Report a mismatch
  3. [3] § Results ↔ Projection_Density_Filtered_AllenSDK_Pipeline.ipynb, lines 257 to 291 · score 0.99 · SSp ll, SSp bfd, SSp tr, SSp ul, SSp un, AUDpo · Report a mismatch
  4. [4] § Results ↔ AllenSDK_Pipeline.ipynb, lines 107 to 135 · score 0.99 · SSp ll, SSp bfd, SSp tr, SSp ul, SSp un, AUDpo · Report a mismatch
  5. [5] § Materials and methods ↔ Projection_Density_Filtered_AllenSDK_Pipeline.ipynb, lines 61 to 106 · score 0.89 · projection signal, weighted center, injection centroids, projection densities, injection density, mass · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Jupyter notebook · 572 lines · 19 KB · no license · 3 matches

  1. # %%
  2. # imports
  3. import numpy as np
  4. import pandas as pd
  5. import matplotlib.pyplot as plt
  6. from allensdk.core.mouse_connectivity_cache import MouseConnectivityCache
  7. from mpl_toolkits.mplot3d import Axes3D
  8. from sklearn.linear_model import LinearRegression
  9. from scipy.stats import linregress
  10. import statsmodels.api as sm
  11. from tqdm import tqdm
  12. import time
  13. from matplotlib.patches import Patch
  15. # %%
  16. # config
  17. voxel_size_um = 25 # um per voxel 25um
  18. min_mean_bundle_density = 1e-4
  20. # structures
  21. isocortex_id = 315
  22. bundle_ids = [884] # replace with any fiber tract ids
  24. # hemisphere: right, left, or None
  25. hemisphere = "right"
  27. # cache and structure tree from allensdk
  28. mcc = MouseConnectivityCache()
  29. st = mcc.get_structure_tree()
  31. # %%
  32. # experiments
  33. print("loading isocortex non-cre injection experiments")
  34. exps = mcc.get_experiments(cre=False, injection_structure_ids=[isocortex_id])
  35. experiment_ids = [e["id"] for e in exps]
  36. print(f"using {len(experiment_ids)} isocortex experiments")
  38. # %%
  39. # build bundle mask
  40. mask_union = None
  41. for sid in bundle_ids:
  42. m, _ = mcc.get_structure_mask(sid)
  43. mask_union = m.astype(bool) if mask_union is None else (mask_union | m.astype(bool))
  45. if mask_union is None:
  46. raise RuntimeError("no structure masks were built (check bundle_ids).")
  48. # restrict to one hemisphere
  49. if hemisphere in ("right", "left"):
  50. mid = mask_union.shape[2] // 2
  51. if hemisphere == "right":
  52. mask_union[:, :, :mid] = False
  53. else:
  54. mask_union[:, :, mid:] = False
  56. # precompute voxel indices
  57. mx, my, mz = np.where(mask_union)
  58. mask_index_tuple = (mx, my, mz)
  59. print(f"mask ready: {mx.size:,} voxels ({hemisphere or 'both'} hemisphere)")
  61. # %%
  62. # HELPERS
  63. # density volumes are 3d arrays where each allensdk voxel stores the fraction of the
  64. # voxel filled by signal. Density values are between 0 and 1
  65. # as written in the allen dev docs:
  66. # projection density= sum of detected projection pixels / sum of all pixels in voxel
  67. # injection_density= density of detected projection pixels within the
  68. # manually annotated injection site
  70. # this gets the projection crossing coordinates within mask using density values
  71. def weighted_centroid_from_density(density_vol, idx_tuple, voxel_size_um):
  72. w = density_vol[idx_tuple] # get projection density values inside your mask
  73. pos = w > 0 # keep only voxels with nonzero density
  74. if not np.any(pos): # if no signal at all, return None
  75. return None
  77. x = idx_tuple[0][pos] # x voxel indices of nonzero voxels
  78. y = idx_tuple[1][pos] # y voxel indices
  79. z = idx_tuple[2][pos] # z voxel indices
  80. w = w[pos].astype(np.float32) # weights = projection density values
  82. # weighted average voxel index + converted to um
  83. vx = float(np.average(x, weights=w)) * voxel_size_um
  84. vy = float(np.average(y, weights=w)) * voxel_size_um
  85. vz = float(np.average(z, weights=w)) * voxel_size_um
  86. return vx, vy, vz
  88. #finds the center of mass of the projection signal within wm mask
  89. # weights projection densities so that brighter voxels influence the centroid more
  91. # this gets the injection site centroid based on all nonzero voxels in injection volume
  92. def weighted_centroid_from_binary(density_vol, voxel_size_um):
  93. pos = density_vol > 0 # find voxels with injection signal
  94. if not np.any(pos): # if no injection voxels, return None
  95. return None
  96. x, y, z = np.where(pos) # voxel coordinates of injection
  97. w = density_vol[pos].astype(np.float32) # injection densities as weights
  99. # weighted centroid
  100. vx = float(np.average(x, weights=w)) * voxel_size_um
  101. vy = float(np.average(y, weights=w)) * voxel_size_um
  102. vz = float(np.average(z, weights=w)) * voxel_size_um
  103. return vx, vy, vz
  104. # finds the weighted center of the injection site
  105. # weighs injection densitites so that denser parts of the injection count more
  106. # outputs injection centroid
  108. # %%
  109. # main loop
  110. inj_x, inj_y, inj_z = {}, {}, {}
  111. proj_x, proj_y, proj_z = {}, {}, {}
  113. t0 = time.time()
  114. for eid in tqdm(experiment_ids, desc="processing experiments"):
  115. try:
  116. proj_vol, _ = mcc.get_projection_density(eid) # 3d projection density volume
  117. inj_vol, _ = mcc.get_injection_density(eid) # 3d injection density volume
  119. # projection densities inside WM mask (after hemisphere filtering)
  120. wm_densities = proj_vol[mask_index_tuple].astype(np.float32)
  122. # drop NaNs
  123. wm_densities = wm_densities[~np.isnan(wm_densities)]
  124. # skip if no valid voxels in the bundle
  125. if wm_densities.size == 0:
  126. continue
  127. # mean projection density through the WM structure
  128. bundle_mean = float(np.mean(wm_densities))
  129. # filter: require mean density >= threshold
  130. if bundle_mean < min_mean_bundle_density:
  131. continue
  132. # centroids only for experiments that passed the filter
  133. proj_centroid = weighted_centroid_from_density(
  134. proj_vol, mask_index_tuple, voxel_size_um
  135. )
  136. if proj_centroid is None:
  137. continue
  138. px, py, pz = proj_centroid
  139. proj_x[eid], proj_y[eid], proj_z[eid] = px, py, pz
  141. inj_centroid = weighted_centroid_from_binary(inj_vol, voxel_size_um)
  142. if inj_centroid is None:
  143. continue
  144. ix, iy, iz = inj_centroid
  145. inj_x[eid], inj_y[eid], inj_z[eid] = ix, iy, iz
  147. except Exception as e:
  148. print(f"{eid}: {e}")
  150. elapsed = time.time() - t0
  151. print(f"\n total processing time: {elapsed:.2f} s")
  153. # how many experiments were kept?
  154. kept_ids = sorted(proj_x.keys())
  155. print(f"kept {len(kept_ids)} / {len(experiment_ids)} experiments "
  156. f"(mean WM density ≥ {min_mean_bundle_density})")
  157. print("first few kept IDs + means:")
  158. for eid in kept_ids[:10]:
  159. # recompute just for display
  160. proj_vol, _ = mcc.get_projection_density(eid)
  161. wm = proj_vol[mask_index_tuple].astype(np.float32)
  162. wm = wm[~np.isnan(wm)]
  163. print(eid, np.mean(wm))
  166. # %%
  167. # dataframe + correlation
  168. common_ids = sorted(set(inj_x) & set(proj_x))
  170. df = pd.DataFrame({
  171. "injection_x": [inj_x[e] for e in common_ids],
  172. "injection_y": [inj_y[e] for e in common_ids],
  173. "injection_z": [inj_z[e] for e in common_ids],
  174. "projection_x": [proj_x[e] for e in common_ids],
  175. "projection_y": [proj_y[e] for e in common_ids],
  176. "projection_z": [proj_z[e] for e in common_ids],
  177. }, index=common_ids)
  179. print(f"final n = {len(df)} rows")
  180. print("\ncorrelation matrix (injection → projection):")
  181. print(df.corr(numeric_only=True))
  183. # %%
  184. import pandas as pd
  185. import numpy as np
  186. from statsmodels.stats.outliers_influence import variance_inflation_factor
  188. def compute_vif(df, predictors):
  189. X = df[predictors].dropna().astype(float).values
  190. X_ = np.column_stack([np.ones(X.shape[0]), X])
  192. vif_vals = [variance_inflation_factor(X_, i) for i in range(1, X_.shape[1])]
  194. vif_table = pd.DataFrame({
  195. "predictor": predictors,
  196. "VIF": vif_vals
  197. })
  199. def interpret(v):
  200. if v < 2:
  201. return "low collinearity"
  202. elif v < 5:
  203. return "moderate collinearity"
  204. elif v < 10:
  205. return "high collinearity"
  206. else:
  207. return "severe collinearity"
  209. vif_table["interpretation"] = vif_table["VIF"].apply(interpret)
  210. return vif_table
  212. predictors = ['injection_x','injection_y','injection_z']
  213. vif_table = compute_vif(df, predictors)
  214. print(vif_table)
  216. # %%
  217. # Lasso regression
  219. # %%
  220. # attach region labels to df using experiment injection structure acronyms
  221. # build: exp_id to injection structure acronym
  222. exp_struct_acro = {}
  223. for e in exps:
  224. try:
  225. s = st.get_structures_by_id([e['structure_id']])[0]
  226. exp_struct_acro[e['id']] = s['acronym']
  227. except Exception:
  228. pass
  230. # keep only rows present in df.index
  231. df_regions = df.copy()
  232. df_regions['region'] = [get_region_group(exp_struct_acro.get(eid, None)) for eid in df_regions.index]
  233. df_regions = df_regions[df_regions['region'].notna()]
  234. print(f"region-labeled n = {len(df_regions)} (dropped unlabeled)")
  236. # %%
  237. # modeling helpers
  238. predictor_cols = ['injection_x', 'injection_y', 'injection_z']
  239. axis_map = {'x': 'projection_x', 'y': 'projection_y', 'z': 'projection_z'}
  240. axis_label = {'x': 'A-P', 'y': 'D-V', 'z': 'M-L'}
  242. def fit_models(df_in: pd.DataFrame):
  243. x = sm.add_constant(df_in[predictor_cols])
  244. models = {}
  245. for ax, ycol in axis_map.items():
  246. y = df_in[ycol]
  247. models[ax] = sm.OLS(y, x).fit()
  248. return models
  250. models = fit_models(df_regions)
  252. # %%
  253. print("Experiments with NaN projection centroids:",
  254. sum(np.isnan(list(proj_x.values()))))
  255. print("Experiments used in regression dataframe:", len(df))
  257. # %%
  258. # Color palette
  259. region_colors = {
  260. 'Prefrontal': {'acronyms': {'ACAd','ACAv','FRP','ILA','ORBl','ORBvl','PL'},
  261. 'color': [0.97, 0.83, 0.34]},
  262. 'Insula': {'acronyms': {'AId','GU','VISC'},
  263. 'color': [1.00, 0.62, 0.23]},
  264. 'Motor': {'acronyms': {'MOp','MOs'},
  265. 'color': [0.40, 0.76, 0.40]},
  266. 'Somatosensory': {'acronyms': {'SSp-bfd','SSp-ll','SSp-m','SSp-n','SSp-tr','SSp-ul','SSp-un','SSs'},
  267. 'color': [0.85, 0.19, 0.20]},
  268. 'Temporal': {'acronyms': {'ECT','AUDd','AUDp','AUDpo','AUDv'},
  269. 'color': [1.00, 0.45, 0.71]},
  270. 'Retrosplenial': {'acronyms': {'RSPagl','RSPd','RSPv'},
  271. 'color': [0.78, 0.00, 1.00]},
  272. 'Visual': {'acronyms': {'VISp','VISal','VISam','VISl','VISpm','VISpor','VISpl','VISli'},
  273. 'color': [0.00, 0.55, 1.00]}
  274. }
  276. legend_order = ["Prefrontal", "Insula", "Motor",
  277. "Somatosensory", "Temporal", "Retrosplenial", "Visual"]
  279. # Convert RGB to hex
  280. def rgb_to_hex(rgb):
  281. r, g, b = (int(255*c) for c in rgb)
  282. return f"#{r:02x}{g:02x}{b:02x}"
  284. group_color_hex = {k: rgb_to_hex(v['color']) for k, v in region_colors.items()}
  286. # Helper to get region group by acronym
  287. def get_region_group(acronym: str):
  288. for group, props in region_colors.items():
  289. if acronym in props['acronyms']:
  290. return group
  291. return None
  293. # %%
  294. # lasso imports
  295. import numpy as np
  296. import matplotlib.pyplot as plt
  298. from sklearn.preprocessing import StandardScaler
  299. from sklearn.linear_model import LassoCV
  300. from sklearn.metrics import r2_score
  302. from matplotlib.patches import Patch
  304. # %%
  305. # axis labels and column mappings
  306. axis_label = {'x': 'A-P', 'y': 'D-V', 'z': 'M-L'}
  308. predictors = [
  309. 'injection_x',
  310. 'injection_y',
  311. 'injection_z'
  312. ]
  314. axis_to_ycol = {
  315. 'x': 'projection_x',
  316. 'y': 'projection_y',
  317. 'z': 'projection_z'
  318. }
  320. # %%
  321. def fit_lasso_models(df, axes=('x', 'y', 'z'), cv=5, alphas=None, random_state=0):
  322. """
  323. Fit one LassoCV model per projection axis on standardized predictors.
  325. Returns:
  326. dict: axis {
  327. 'scaler': StandardScaler,
  328. 'model': LassoCV,
  329. 'index': DataFrame index used for fitting
  330. }
  331. """
  332. models = {}
  334. for ax in axes:
  335. cols = predictors + [axis_to_ycol[ax]]
  336. sub = df.dropna(subset=cols).copy()
  338. X = sub[predictors].to_numpy(float)
  339. y = sub[axis_to_ycol[ax]].to_numpy(float)
  341. scaler = StandardScaler()
  342. Xz = scaler.fit_transform(X)
  344. lcv = LassoCV(
  345. cv=cv,
  346. alphas=alphas,
  347. random_state=random_state,
  348. max_iter=10000
  349. )
  350. lcv.fit(Xz, y)
  352. models[ax] = {
  353. 'scaler': scaler,
  354. 'model': lcv,
  355. 'index': sub.index
  356. }
  358. return models
  360. # %%
  361. def plot_axis_summary_lasso(
  362. models,
  363. df_regions,
  364. group_color_hex,
  365. legend_order,
  366. axis_key='x'
  367. ):
  368. """
  369. Two-panel summary for a single axis using LassoCV.
  371. Left:
  372. Predicted vs actual projection coordinate, colored by region.
  373. Right:
  374. Lasso coefficients (betas) on standardized predictors.
  376. Title reports R squared and chosen alpha.
  377. """
  378. assert axis_key in ('x', 'y', 'z')
  380. pack = models[axis_key]
  381. scaler = pack['scaler']
  382. lcv = pack['model']
  384. # align rows used by the model
  385. idx = pack['index']
  386. X = df_regions.loc[idx, predictors].to_numpy(float)
  387. y = df_regions.loc[idx, axis_to_ycol[axis_key]].to_numpy(float)
  388. Xz = scaler.transform(X)
  389. y_pred = lcv.predict(Xz)
  391. fig, (ax_scatter, ax_bar) = plt.subplots(
  392. nrows=1,
  393. ncols=2,
  394. figsize=(12, 5),
  395. gridspec_kw={'width_ratios': [1.25, 1]}
  396. )
  398. # predicted vs actual
  399. for region in legend_order:
  400. if region not in group_color_hex:
  401. continue
  403. mask = (df_regions.loc[idx, 'region'] == region).to_numpy()
  404. if not np.any(mask):
  405. continue
  407. ax_scatter.scatter(
  408. y_pred[mask],
  409. y[mask],
  410. s=70,
  411. edgecolor='black',
  412. alpha=0.85,
  413. color=group_color_hex[region],
  414. label=region
  415. )
  417. lo = float(min(y.min(), y_pred.min()))
  418. hi = float(max(y.max(), y_pred.max()))
  419. ax_scatter.plot([lo, hi], [lo, hi], 'r--', lw=2)
  421. pretty = axis_label[axis_key]
  422. r2 = r2_score(y, y_pred)
  423. ax_scatter.set_xlabel(f"Predicted {pretty} Projection (µm)")
  424. ax_scatter.set_ylabel(f"Actual {pretty} Projection (µm)")
  425. ax_scatter.set_title(f"{pretty} Prediction (LassoCV: R²={r2:.3f}, α={lcv.alpha_:.3g})")
  426. ax_scatter.grid(True, linestyle='--', alpha=0.6)
  428. # RIGHT: beta bars (standardized-X coefficients)
  429. coef = lcv.coef_ # corresponds to predictors after standardization
  430. label_map = {
  431. 'injection_x': 'A-P Injection Coordinate',
  432. 'injection_y': 'D-V Injection Coordinate',
  433. 'injection_z': 'M-L Injection Coordinate'
  434. }
  435. labels = [label_map[p] for p in predictors]
  436. bars = ax_bar.bar(labels, coef, color='skyblue', edgecolor='black')
  438. # annotate zeros and values
  439. rng = (max(coef.max(), 0) - min(coef.min(), 0)) or 1.0
  440. for b, v in zip(bars, coef):
  441. ytxt = (b.get_height() + 0.05*rng) if v >= 0 else (b.get_height() - 0.05*rng)
  442. va = 'bottom' if v >= 0 else 'top'
  443. ax_bar.text(b.get_x()+b.get_width()/2, ytxt, f"{v:.3f}", ha='center', va=va, fontsize=10)
  445. ax_bar.axhline(0, color='gray', linestyle='--', linewidth=1)
  446. ax_bar.set_ylabel("Lasso coefficient (β) on standardized predictors")
  447. ax_bar.set_title(f"Influence of Injection Coordinates\non {pretty} Projection")
  448. ax_bar.grid(True, axis='y', linestyle='--', alpha=0.6)
  449. ax_bar.tick_params(axis='x', labelrotation=20)
  451. plt.tight_layout()
  452. plt.show()
  454. # %%
  455. # fit lasso models
  456. lasso_models = fit_lasso_models(df_regions, cv=5)
  458. # plot
  459. plot_axis_summary_lasso(lasso_models, df_regions, group_color_hex, legend_order, axis_key='x') # A-P
  460. plot_axis_summary_lasso(lasso_models, df_regions, group_color_hex, legend_order, axis_key='y') # D-V
  461. plot_axis_summary_lasso(lasso_models, df_regions, group_color_hex, legend_order, axis_key='z') # M-L
  463. # %%
  464. # partial regression plots
  466. # %%
  467. # labels and columns
  468. axis_label = {'x': 'A-P', 'y': 'D-V', 'z': 'M-L'}
  469. predictors = ['injection_x', 'injection_y', 'injection_z']
  470. axis_to_ycol = {'x': 'projection_x', 'y': 'projection_y', 'z': 'projection_z'}
  472. def _residualize(y, X):
  473. """Return residuals of OLS: y ~ X (with constant)."""
  474. Xc = sm.add_constant(X, has_constant='add')
  475. model = sm.OLS(y, Xc, missing='drop').fit()
  476. return model.resid, model
  478. def partial_regression_plots(
  479. df_regions,
  480. axis_key='x',
  481. group_color_hex=None,
  482. legend_order=None,
  483. point_size=70,
  484. alpha=0.85,
  485. show=True
  486. ):
  487. """
  488. Added-variable plots for a chosen projection axis.
  489. Rows used: non-NA on projection axis + all three predictors.
  490. Returns (fig, axes, full_model) where full_model is OLS on all 3 predictors.
  491. """
  492. assert axis_key in ('x','y','z')
  493. ycol = axis_to_ycol[axis_key]
  495. # rows with complete data
  496. needed = predictors + [ycol]
  497. d = df_regions.dropna(subset=needed).copy()
  499. # Fit the full OLS once (y ~ X,Y,Z) for reference
  500. X_full = sm.add_constant(d[predictors], has_constant='add')
  501. full_model = sm.OLS(d[ycol], X_full).fit()
  503. # figure: one subplot per predictor
  504. fig, axes = plt.subplots(1, 3, figsize=(16, 4.8), sharey=False)
  505. fig.suptitle(f"Partial regression (added-variable) plots for {axis_label[axis_key]} projection", y=1.02)
  507. for ax, pred in zip(axes, predictors):
  508. others = [p for p in predictors if p != pred]
  510. # residualize outcome on "others", and predictor on "others"
  511. y_res, _ = _residualize(d[ycol].to_numpy(float), d[others].to_numpy(float))
  512. x_res, _ = _residualize(d[pred].to_numpy(float), d[others].to_numpy(float))
  514. # quick simple regression on residuals -> partial slope & p-value
  515. lr = linregress(x_res, y_res)
  516. slope, intercept, r_val, p_val = lr.slope, lr.intercept, lr.rvalue, lr.pvalue
  518. # scatter (by region if provided)
  519. if group_color_hex and 'region' in d.columns and legend_order:
  520. for region in legend_order:
  521. if region not in group_color_hex:
  522. continue
  523. m = (d['region'] == region).to_numpy()
  524. if not np.any(m):
  525. continue
  526. ax.scatter(
  527. x_res[m], y_res[m],
  528. s=point_size, alpha=alpha,
  529. color=group_color_hex[region],
  530. edgecolor='black', linewidths=0.5
  531. )
  532. else:
  533. ax.scatter(x_res, y_res, s=point_size, alpha=alpha,
  534. color='#4c78a8', edgecolor='black', linewidths=0.5)
  536. # regression line on residuals
  537. xx = np.linspace(x_res.min(), x_res.max(), 100)
  538. ax.plot(xx, intercept + slope*xx, 'r--', lw=2)
  540. # labels and title with stats
  541. nice_pred = {
  542. 'injection_x': 'A-P injection',
  543. 'injection_y': 'D-V injection',
  544. 'injection_z': 'M-L injection'
  545. }[pred]
  546. ax.set_xlabel(f"{nice_pred} residual (µm)")
  547. ax.set_ylabel(f"{axis_label[axis_key]} projection residual (µm)")
  548. beta_full = full_model.params[pred] # equals slope on residuals
  549. ax.set_title(f"{nice_pred} | others\nβ={beta_full:.3f}, R²={r_val**2:.2f}, p={p_val:.2e}")
  550. ax.grid(True, linestyle='--', alpha=0.5)
  552. # shared legend (if region colors provided)
  553. if group_color_hex and legend_order:
  554. handles = [Patch(facecolor=group_color_hex[r], edgecolor='black', label=r)
  555. for r in legend_order if r in group_color_hex]
  556. fig.legend(handles=handles, title='region', bbox_to_anchor=(1.01, 0.5), loc='center left')
  558. plt.tight_layout(rect=[0, 0, 0.95, 1])
  559. if show:
  560. plt.show()
  561. return fig, axes, full_model
  563. # %%
  564. # plot
  565. fig, axes, full_ap = partial_regression_plots(
  566. df_regions,
  567. axis_key='x',
  568. group_color_hex=group_color_hex,
  569. legend_order=legend_order
  570. )
  571. partial_regression_plots(df_regions, axis_key='y', group_color_hex=group_color_hex, legend_order=legend_order)
  572. partial_regression_plots(df_regions, axis_key='z', group_color_hex=group_color_hex, legend_order=legend_order)

Projection_Density_Filtered_AllenSDK_Pipeline.ipynb at commit dfcdc36, no license · at the source

Overview

Authors: Sofia D. Gordeev1, Melissa Franch2, Sarah R. Heilbronner2
  1. Program in Neuroscience, Rice University,77005 Houston, TX USA
  2. Department of Neurosurgery, Baylor College of Medicine,S836, 1 Baylor Plaza, TX Houston, 77030 USA
Institutions: Rice University (United States); Baylor College of Medicine (United States)
Journal: Brain structure & function, volume 231, issue 3, article 46
Dates: received 1 January 2026; accepted 10 March 2026; published online 27 March 2026; in print 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1007/s00429-026-03101-z · PMID 41893879 · PMCID PMC13031187 · OpenAlex W7141132906
Open access: hybrid, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: structural MRI / diffusion (modality), mouse (organism)
Methods: Statistics
Keywords: Connectivity, Axon, White matter, Model species, Neuroanatomy
MeSH: Cerebral Cortex*, White Matter*, Animals, Brain Mapping, Male, Mice, Mice, Inbred C57BL, Neural Pathways (* major topic)
Topic: Advanced Neuroimaging Techniques and Applications (Radiology, Nuclear Medicine and Imaging, Medicine), according to OpenAlex
Funding: Robert and Janice McNair Foundation; national institutes of health (R01MH126923)
Citations: not cited yet (Europe PMC); 63 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.

Repository

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

sdg5-create/MouseWMMatters

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: dfcdc365e212e93131236e7c300e3393998791c0, 29 December 2025
Languages: Jupyter (4)
Size: 4 files, 4 scripts
Software Heritage: not archived
Found in: “Data availability”
Holds: 4 notebooks
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: AllenSDK (4 files), Matplotlib (4 files), NumPy (4 files), pandas (3 files), scikit-learn (3 files), SciPy (3 files), statsmodels (2 files)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
4 files
At the source: github.com/sdg5-create/MouseWMMatters

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;
  • 4 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.

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.1007/s00429-026-03101-z.

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, 3 authors, 5 keywords, 8 MeSH terms, 2 funders, 60 references.

Cite

This paper

Gordeev, S. D., Franch, M., & Heilbronner, S. R. (2026). Mouse white matter matters: cortical origins and spatial organization of mouse white matter tracts. Brain structure & function, 231(3), 46. https://doi.org/10.1007/s00429-026-03101-z

BibTeX

@article{gordeev2026mouse,
author = {Gordeev, Sofia D. and Franch, Melissa and Heilbronner, Sarah R.},
title = {{Mouse white matter matters: cortical origins and spatial organization of mouse white matter tracts}},
journal = {Brain structure \& function},
year = {2026},
month = mar,
volume = {231},
number = {3},
pages = {46},
publisher = {Springer Science+Business Media},
issn = {1863-2653},
doi = {10.1007/s00429-026-03101-z},
url = {https://doi.org/10.1007/s00429-026-03101-z},
pmid = {41893879},
pmcid = {PMC13031187}
}

RIS

TY - JOUR
AU - Gordeev, Sofia D.
AU - Franch, Melissa
AU - Heilbronner, Sarah R.
TI - Mouse white matter matters: cortical origins and spatial organization of mouse white matter tracts
T2 - Brain structure & function
J2 - Brain Struct Funct
PY - 2026
DA - 2026/03/27
VL - 231
IS - 3
SP - 46
SN - 1863-2653
PB - Springer Science+Business Media
DO - 10.1007/s00429-026-03101-z
UR - https://doi.org/10.1007/s00429-026-03101-z
LA - en
ER -

CSL-JSON

{
"id": "10.1007/s00429-026-03101-z",
"type": "article-journal",
"title": "Mouse white matter matters: cortical origins and spatial organization of mouse white matter tracts",
"container-title": "Brain structure & function",
"author": [
{
"family": "Gordeev",
"given": "Sofia D."
},
{
"family": "Franch",
"given": "Melissa"
},
{
"family": "Heilbronner",
"given": "Sarah R."
}
],
"container-title-short": "Brain Struct Funct",
"volume": "231",
"issue": "3",
"page": "46",
"DOI": "10.1007/s00429-026-03101-z",
"PMID": "41893879",
"PMCID": "PMC13031187",
"ISSN": "1863-2653",
"publisher": "Springer Science+Business Media",
"URL": "https://doi.org/10.1007/s00429-026-03101-z",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
27
]
]
}
}

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.2463/mrms.rev.2024-0007 [code]
Tractometry of Human Visual White Matter Pathways in Health and Disease.
Journal: Magnetic resonance in medical sciences : MRMS : an official journal of Japan Society of Magnetic Resonance in Medicine
In common: pandas, Matplotlib, NumPy, structural MRI / diffusion, 7 references
[2] doi:10.7554/elife.107012 [code]
Cross-species standardised cortico-subcortical tractography.
Journal: eLife
In common: structural MRI / diffusion, 7 references
[3] doi:10.1073/pnas.2314918121 [code]
Subcallosal cingulate deep brain stimulation evokes two distinct cortical responses via differential white matter activation.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: pandas, SciPy, Matplotlib, 1 other tool, 5 references
[4] doi:10.3389/fninf.2023.1272243 [code]
Translating single-neuron axonal reconstructions into meso-scale connectivity statistics in the mouse somatosensory thalamus.
Journal: Frontiers in neuroinformatics
In common: AllenSDK, scikit-learn, pandas, 3 other tools, mouse, 3 references
[5] doi:10.1038/s41593-026-02253-9 [code]
Genoarchitecture and input-output organization of the mouse basal ganglia and thalamic parafascicular nucleus.
Journal: Nature neuroscience
In common: AllenSDK, scikit-learn, pandas, 3 other tools, mouse, 3 references
[6] doi:10.1162/imag.a.1310 [code]
Experimental quality control induces changes in Allen mouse brain connectomes.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: AllenSDK, scikit-learn, pandas, 2 other tools, mouse, 3 references
[7] doi:10.1162/imag_a_00245 [code]
Feature attention graph neural network for estimating brain age and identifying important neural connections in mouse models of genetic risk for Alzheimer's disease.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: scikit-learn, pandas, SciPy, 2 other tools, structural MRI / diffusion, mouse, 3 references
[8] doi:10.7554/elife.78635 [code]
A connectomics-based taxonomy of mammals.
Journal: eLife
In common: statsmodels, scikit-learn, pandas, 3 other tools, structural MRI / diffusion, 3 references
[9] doi:10.1007/s00429-024-02773-9 [code]
Comparing mouse and human cingulate cortex organization using functional connectivity.
Journal: Brain structure & function
In common: AllenSDK, statsmodels, pandas, 3 other tools, mouse, 2 references
[10] doi:10.1186/s41747-025-00570-5 [code]
Connectivity related to major brain functions in Alzheimer disease progression: microstructural properties of the cingulum bundle and its subdivision using diffusion-weighted MRI.
Journal: European radiology experimental
In common: statsmodels, pandas, SciPy, 2 other tools, structural MRI / diffusion, 3 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.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.1007/s00429-026-03101-z.svg)](https://openscicode.org/badge/doi/10.1007/s00429-026-03101-z)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1007/s00429-026-03101-z.svg
   :target: https://openscicode.org/badge/doi/10.1007/s00429-026-03101-z
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1007/s00429-026-03101-z"><img src="https://openscicode.org/badge/doi/10.1007/s00429-026-03101-z.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge 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: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

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