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] § 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] § 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] § 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] § 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] § 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 paper is loaded by your browser, with JavaScript: read it at doi.org or on Europe PMC.

The authors' code

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

# %%
# imports
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from allensdk.core.mouse_connectivity_cache import MouseConnectivityCache
from mpl_toolkits.mplot3d import Axes3D
from sklearn.linear_model import LinearRegression
from scipy.stats import linregress
import statsmodels.api as sm
from tqdm import tqdm
import time
from matplotlib.patches import Patch
# %%
# config
voxel_size_um = 25 # um per voxel 25um
min_mean_bundle_density = 1e-4
# structures
isocortex_id = 315
bundle_ids = [884] # replace with any fiber tract ids
# hemisphere: right, left, or None
hemisphere = "right"
# cache and structure tree from allensdk
mcc = MouseConnectivityCache()
st = mcc.get_structure_tree()
# %%
# experiments
print("loading isocortex non-cre injection experiments")
exps = mcc.get_experiments(cre=False, injection_structure_ids=[isocortex_id])
experiment_ids = [e["id"] for e in exps]
print(f"using {len(experiment_ids)} isocortex experiments")
# %%
# build bundle mask
mask_union = None
for sid in bundle_ids:
m, _ = mcc.get_structure_mask(sid)
mask_union = m.astype(bool) if mask_union is None else (mask_union | m.astype(bool))
if mask_union is None:
raise RuntimeError("no structure masks were built (check bundle_ids).")
# restrict to one hemisphere
if hemisphere in ("right", "left"):
mid = mask_union.shape[2] // 2
if hemisphere == "right":
mask_union[:, :, :mid] = False
else:
mask_union[:, :, mid:] = False
# precompute voxel indices
mx, my, mz = np.where(mask_union)
mask_index_tuple = (mx, my, mz)
print(f"mask ready: {mx.size:,} voxels ({hemisphere or 'both'} hemisphere)")
# %%
# HELPERS
# density volumes are 3d arrays where each allensdk voxel stores the fraction of the
# voxel filled by signal. Density values are between 0 and 1
# as written in the allen dev docs:
# projection density= sum of detected projection pixels / sum of all pixels in voxel
# injection_density= density of detected projection pixels within the
# manually annotated injection site
# this gets the projection crossing coordinates within mask using density values
def weighted_centroid_from_density(density_vol, idx_tuple, voxel_size_um):
w = density_vol[idx_tuple] # get projection density values inside your mask
pos = w > 0 # keep only voxels with nonzero density
if not np.any(pos): # if no signal at all, return None
return None
x = idx_tuple[0][pos] # x voxel indices of nonzero voxels
y = idx_tuple[1][pos] # y voxel indices
z = idx_tuple[2][pos] # z voxel indices
w = w[pos].astype(np.float32) # weights = projection density values
# weighted average voxel index + converted to um
vx = float(np.average(x, weights=w)) * voxel_size_um
vy = float(np.average(y, weights=w)) * voxel_size_um
vz = float(np.average(z, weights=w)) * voxel_size_um
return vx, vy, vz
#finds the center of mass of the projection signal within wm mask
# weights projection densities so that brighter voxels influence the centroid more
# this gets the injection site centroid based on all nonzero voxels in injection volume
def weighted_centroid_from_binary(density_vol, voxel_size_um):
pos = density_vol > 0 # find voxels with injection signal
if not np.any(pos): # if no injection voxels, return None
return None
x, y, z = np.where(pos) # voxel coordinates of injection
w = density_vol[pos].astype(np.float32) # injection densities as weights
# weighted centroid
vx = float(np.average(x, weights=w)) * voxel_size_um
vy = float(np.average(y, weights=w)) * voxel_size_um
vz = float(np.average(z, weights=w)) * voxel_size_um
return vx, vy, vz
# finds the weighted center of the injection site
# weighs injection densitites so that denser parts of the injection count more
# outputs injection centroid
# %%
# main loop
inj_x, inj_y, inj_z = {}, {}, {}
proj_x, proj_y, proj_z = {}, {}, {}
t0 = time.time()
for eid in tqdm(experiment_ids, desc="processing experiments"):
try:
proj_vol, _ = mcc.get_projection_density(eid) # 3d projection density volume
inj_vol, _ = mcc.get_injection_density(eid) # 3d injection density volume
# projection densities inside WM mask (after hemisphere filtering)
wm_densities = proj_vol[mask_index_tuple].astype(np.float32)
# drop NaNs
wm_densities = wm_densities[~np.isnan(wm_densities)]
# skip if no valid voxels in the bundle
if wm_densities.size == 0:
continue
# mean projection density through the WM structure
bundle_mean = float(np.mean(wm_densities))
# filter: require mean density >= threshold
if bundle_mean < min_mean_bundle_density:
continue
# centroids only for experiments that passed the filter
proj_centroid = weighted_centroid_from_density(
proj_vol, mask_index_tuple, voxel_size_um
)
if proj_centroid is None:
continue
px, py, pz = proj_centroid
proj_x[eid], proj_y[eid], proj_z[eid] = px, py, pz
inj_centroid = weighted_centroid_from_binary(inj_vol, voxel_size_um)
if inj_centroid is None:
continue
ix, iy, iz = inj_centroid
inj_x[eid], inj_y[eid], inj_z[eid] = ix, iy, iz
except Exception as e:
print(f"{eid}: {e}")
elapsed = time.time() - t0
print(f"\n total processing time: {elapsed:.2f} s")
# how many experiments were kept?
kept_ids = sorted(proj_x.keys())
print(f"kept {len(kept_ids)} / {len(experiment_ids)} experiments "
f"(mean WM density ≥ {min_mean_bundle_density})")
print("first few kept IDs + means:")
for eid in kept_ids[:10]:
# recompute just for display
proj_vol, _ = mcc.get_projection_density(eid)
wm = proj_vol[mask_index_tuple].astype(np.float32)
wm = wm[~np.isnan(wm)]
print(eid, np.mean(wm))
# %%
# dataframe + correlation
common_ids = sorted(set(inj_x) & set(proj_x))
df = pd.DataFrame({
"injection_x": [inj_x[e] for e in common_ids],
"injection_y": [inj_y[e] for e in common_ids],
"injection_z": [inj_z[e] for e in common_ids],
"projection_x": [proj_x[e] for e in common_ids],
"projection_y": [proj_y[e] for e in common_ids],
"projection_z": [proj_z[e] for e in common_ids],
}, index=common_ids)
print(f"final n = {len(df)} rows")
print("\ncorrelation matrix (injection → projection):")
print(df.corr(numeric_only=True))
# %%
import pandas as pd
import numpy as np
from statsmodels.stats.outliers_influence import variance_inflation_factor
def compute_vif(df, predictors):
X = df[predictors].dropna().astype(float).values
X_ = np.column_stack([np.ones(X.shape[0]), X])
vif_vals = [variance_inflation_factor(X_, i) for i in range(1, X_.shape[1])]
vif_table = pd.DataFrame({
"predictor": predictors,
"VIF": vif_vals
})
def interpret(v):
if v < 2:
return "low collinearity"
elif v < 5:
return "moderate collinearity"
elif v < 10:
return "high collinearity"
else:
return "severe collinearity"
vif_table["interpretation"] = vif_table["VIF"].apply(interpret)
return vif_table
predictors = ['injection_x','injection_y','injection_z']
vif_table = compute_vif(df, predictors)
print(vif_table)
# %%
# Lasso regression
# %%
# attach region labels to df using experiment injection structure acronyms
# build: exp_id to injection structure acronym
exp_struct_acro = {}
for e in exps:
try:
s = st.get_structures_by_id([e['structure_id']])[0]
exp_struct_acro[e['id']] = s['acronym']
except Exception:
pass
# keep only rows present in df.index
df_regions = df.copy()
df_regions['region'] = [get_region_group(exp_struct_acro.get(eid, None)) for eid in df_regions.index]
df_regions = df_regions[df_regions['region'].notna()]
print(f"region-labeled n = {len(df_regions)} (dropped unlabeled)")
# %%
# modeling helpers
predictor_cols = ['injection_x', 'injection_y', 'injection_z']
axis_map = {'x': 'projection_x', 'y': 'projection_y', 'z': 'projection_z'}
axis_label = {'x': 'A-P', 'y': 'D-V', 'z': 'M-L'}
def fit_models(df_in: pd.DataFrame):
x = sm.add_constant(df_in[predictor_cols])
models = {}
for ax, ycol in axis_map.items():
y = df_in[ycol]
models[ax] = sm.OLS(y, x).fit()
return models
models = fit_models(df_regions)
# %%
print("Experiments with NaN projection centroids:",
sum(np.isnan(list(proj_x.values()))))
print("Experiments used in regression dataframe:", len(df))
# %%
# Color palette
region_colors = {
'Prefrontal': {'acronyms': {'ACAd','ACAv','FRP','ILA','ORBl','ORBvl','PL'},
'color': [0.97, 0.83, 0.34]},
'Insula': {'acronyms': {'AId','GU','VISC'},
'color': [1.00, 0.62, 0.23]},
'Motor': {'acronyms': {'MOp','MOs'},
'color': [0.40, 0.76, 0.40]},
'Somatosensory': {'acronyms': {'SSp-bfd','SSp-ll','SSp-m','SSp-n','SSp-tr','SSp-ul','SSp-un','SSs'},
'color': [0.85, 0.19, 0.20]},
'Temporal': {'acronyms': {'ECT','AUDd','AUDp','AUDpo','AUDv'},
'color': [1.00, 0.45, 0.71]},
'Retrosplenial': {'acronyms': {'RSPagl','RSPd','RSPv'},
'color': [0.78, 0.00, 1.00]},
'Visual': {'acronyms': {'VISp','VISal','VISam','VISl','VISpm','VISpor','VISpl','VISli'},
'color': [0.00, 0.55, 1.00]}
}
legend_order = ["Prefrontal", "Insula", "Motor",
"Somatosensory", "Temporal", "Retrosplenial", "Visual"]
# Convert RGB to hex
def rgb_to_hex(rgb):
r, g, b = (int(255*c) for c in rgb)
return f"#{r:02x}{g:02x}{b:02x}"
group_color_hex = {k: rgb_to_hex(v['color']) for k, v in region_colors.items()}
# Helper to get region group by acronym
def get_region_group(acronym: str):
for group, props in region_colors.items():
if acronym in props['acronyms']:
return group
return None
# %%
# lasso imports
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LassoCV
from sklearn.metrics import r2_score
from matplotlib.patches import Patch
# %%
# axis labels and column mappings
axis_label = {'x': 'A-P', 'y': 'D-V', 'z': 'M-L'}
predictors = [
'injection_x',
'injection_y',
'injection_z'
]
axis_to_ycol = {
'x': 'projection_x',
'y': 'projection_y',
'z': 'projection_z'
}
# %%
def fit_lasso_models(df, axes=('x', 'y', 'z'), cv=5, alphas=None, random_state=0):
"""
Fit one LassoCV model per projection axis on standardized predictors.
Returns:
dict: axis {
'scaler': StandardScaler,
'model': LassoCV,
'index': DataFrame index used for fitting
}
"""
models = {}
for ax in axes:
cols = predictors + [axis_to_ycol[ax]]
sub = df.dropna(subset=cols).copy()
X = sub[predictors].to_numpy(float)
y = sub[axis_to_ycol[ax]].to_numpy(float)
scaler = StandardScaler()
Xz = scaler.fit_transform(X)
lcv = LassoCV(
cv=cv,
alphas=alphas,
random_state=random_state,
max_iter=10000
)
lcv.fit(Xz, y)
models[ax] = {
'scaler': scaler,
'model': lcv,
'index': sub.index
}
return models
# %%
def plot_axis_summary_lasso(
models,
df_regions,
group_color_hex,
legend_order,
axis_key='x'
):
"""
Two-panel summary for a single axis using LassoCV.
Left:
Predicted vs actual projection coordinate, colored by region.
Right:
Lasso coefficients (betas) on standardized predictors.
Title reports R squared and chosen alpha.
"""
assert axis_key in ('x', 'y', 'z')
pack = models[axis_key]
scaler = pack['scaler']
lcv = pack['model']
# align rows used by the model
idx = pack['index']
X = df_regions.loc[idx, predictors].to_numpy(float)
y = df_regions.loc[idx, axis_to_ycol[axis_key]].to_numpy(float)
Xz = scaler.transform(X)
y_pred = lcv.predict(Xz)
fig, (ax_scatter, ax_bar) = plt.subplots(
nrows=1,
ncols=2,
figsize=(12, 5),
gridspec_kw={'width_ratios': [1.25, 1]}
)
# predicted vs actual
for region in legend_order:
if region not in group_color_hex:
continue
mask = (df_regions.loc[idx, 'region'] == region).to_numpy()
if not np.any(mask):
continue
ax_scatter.scatter(
y_pred[mask],
y[mask],
s=70,
edgecolor='black',
alpha=0.85,
color=group_color_hex[region],
label=region
)
lo = float(min(y.min(), y_pred.min()))
hi = float(max(y.max(), y_pred.max()))
ax_scatter.plot([lo, hi], [lo, hi], 'r--', lw=2)
pretty = axis_label[axis_key]
r2 = r2_score(y, y_pred)
ax_scatter.set_xlabel(f"Predicted {pretty} Projection (µm)")
ax_scatter.set_ylabel(f"Actual {pretty} Projection (µm)")
ax_scatter.set_title(f"{pretty} Prediction (LassoCV: R²={r2:.3f}, α={lcv.alpha_:.3g})")
ax_scatter.grid(True, linestyle='--', alpha=0.6)
# RIGHT: beta bars (standardized-X coefficients)
coef = lcv.coef_ # corresponds to predictors after standardization
label_map = {
'injection_x': 'A-P Injection Coordinate',
'injection_y': 'D-V Injection Coordinate',
'injection_z': 'M-L Injection Coordinate'
}
labels = [label_map[p] for p in predictors]
bars = ax_bar.bar(labels, coef, color='skyblue', edgecolor='black')
# annotate zeros and values
rng = (max(coef.max(), 0) - min(coef.min(), 0)) or 1.0
for b, v in zip(bars, coef):
ytxt = (b.get_height() + 0.05*rng) if v >= 0 else (b.get_height() - 0.05*rng)
va = 'bottom' if v >= 0 else 'top'
ax_bar.text(b.get_x()+b.get_width()/2, ytxt, f"{v:.3f}", ha='center', va=va, fontsize=10)
ax_bar.axhline(0, color='gray', linestyle='--', linewidth=1)
ax_bar.set_ylabel("Lasso coefficient (β) on standardized predictors")
ax_bar.set_title(f"Influence of Injection Coordinates\non {pretty} Projection")
ax_bar.grid(True, axis='y', linestyle='--', alpha=0.6)
ax_bar.tick_params(axis='x', labelrotation=20)
plt.tight_layout()
plt.show()
# %%
# fit lasso models
lasso_models = fit_lasso_models(df_regions, cv=5)
# plot
plot_axis_summary_lasso(lasso_models, df_regions, group_color_hex, legend_order, axis_key='x') # A-P
plot_axis_summary_lasso(lasso_models, df_regions, group_color_hex, legend_order, axis_key='y') # D-V
plot_axis_summary_lasso(lasso_models, df_regions, group_color_hex, legend_order, axis_key='z') # M-L
# %%
# partial regression plots
# %%
# labels and columns
axis_label = {'x': 'A-P', 'y': 'D-V', 'z': 'M-L'}
predictors = ['injection_x', 'injection_y', 'injection_z']
axis_to_ycol = {'x': 'projection_x', 'y': 'projection_y', 'z': 'projection_z'}
def _residualize(y, X):
"""Return residuals of OLS: y ~ X (with constant)."""
Xc = sm.add_constant(X, has_constant='add')
model = sm.OLS(y, Xc, missing='drop').fit()
return model.resid, model
def partial_regression_plots(
df_regions,
axis_key='x',
group_color_hex=None,
legend_order=None,
point_size=70,
alpha=0.85,
show=True
):
"""
Added-variable plots for a chosen projection axis.
Rows used: non-NA on projection axis + all three predictors.
Returns (fig, axes, full_model) where full_model is OLS on all 3 predictors.
"""
assert axis_key in ('x','y','z')
ycol = axis_to_ycol[axis_key]
# rows with complete data
needed = predictors + [ycol]
d = df_regions.dropna(subset=needed).copy()
# Fit the full OLS once (y ~ X,Y,Z) for reference
X_full = sm.add_constant(d[predictors], has_constant='add')
full_model = sm.OLS(d[ycol], X_full).fit()
# figure: one subplot per predictor
fig, axes = plt.subplots(1, 3, figsize=(16, 4.8), sharey=False)
fig.suptitle(f"Partial regression (added-variable) plots for {axis_label[axis_key]} projection", y=1.02)
for ax, pred in zip(axes, predictors):
others = [p for p in predictors if p != pred]
# residualize outcome on "others", and predictor on "others"
y_res, _ = _residualize(d[ycol].to_numpy(float), d[others].to_numpy(float))
x_res, _ = _residualize(d[pred].to_numpy(float), d[others].to_numpy(float))
# quick simple regression on residuals -> partial slope & p-value
lr = linregress(x_res, y_res)
slope, intercept, r_val, p_val = lr.slope, lr.intercept, lr.rvalue, lr.pvalue
# scatter (by region if provided)
if group_color_hex and 'region' in d.columns and legend_order:
for region in legend_order:
if region not in group_color_hex:
continue
m = (d['region'] == region).to_numpy()
if not np.any(m):
continue
ax.scatter(
x_res[m], y_res[m],
s=point_size, alpha=alpha,
color=group_color_hex[region],
edgecolor='black', linewidths=0.5
)
else:
ax.scatter(x_res, y_res, s=point_size, alpha=alpha,
color='#4c78a8', edgecolor='black', linewidths=0.5)
# regression line on residuals
xx = np.linspace(x_res.min(), x_res.max(), 100)
ax.plot(xx, intercept + slope*xx, 'r--', lw=2)
# labels and title with stats
nice_pred = {
'injection_x': 'A-P injection',
'injection_y': 'D-V injection',
'injection_z': 'M-L injection'
}[pred]
ax.set_xlabel(f"{nice_pred} residual (µm)")
ax.set_ylabel(f"{axis_label[axis_key]} projection residual (µm)")
beta_full = full_model.params[pred] # equals slope on residuals
ax.set_title(f"{nice_pred} | others\nβ={beta_full:.3f}, R²={r_val**2:.2f}, p={p_val:.2e}")
ax.grid(True, linestyle='--', alpha=0.5)
# shared legend (if region colors provided)
if group_color_hex and legend_order:
handles = [Patch(facecolor=group_color_hex[r], edgecolor='black', label=r)
for r in legend_order if r in group_color_hex]
fig.legend(handles=handles, title='region', bbox_to_anchor=(1.01, 0.5), loc='center left')
plt.tight_layout(rect=[0, 0, 0.95, 1])
if show:
plt.show()
return fig, axes, full_model
# %%
# plot
fig, axes, full_ap = partial_regression_plots(
df_regions,
axis_key='x',
group_color_hex=group_color_hex,
legend_order=legend_order
)
partial_regression_plots(df_regions, axis_key='y', group_color_hex=group_color_hex, legend_order=legend_order)
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. Gordeev¹, Melissa Franch², Sarah R. Heilbronner²

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

AllenSDK_Pipeline.ipynb, Jupyter, 578 lines, 2 matches
Experiment_Info.ipynb, Jupyter, 128 lines
Projection_Density_Filtered_AllenSDK_Pipeline.ipynb, Jupyter, 572 lines, 3 matches
WholeBrain_Figs.ipynb, Jupyter, 96 lines

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:

it points to the authors' code: sdg5-create/MouseWMMatters

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

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".

sdg5-create/MouseWMMatters on GitHub (add a README there)

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.