OSCR

Modeling reaction-diffusion processes in simplified to complex astroglial branchlet geometries using different simulation tools.

Code ↔ Paper

21 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 21 matches
  1. [1] § Methods › Cell morphologies › Morphology preparation for NEURON simulations. ↔ simulation_codes.zip/NEURON/preprocessing/mesh_to_swc.py, lines 1 to 45 · score 0.98 · Cartesian voxel, occupied voxel, local radii, SWC format, realistic astrocyte branchlet, voxel tree · Report a mismatch
  2. [2] § Methods › Cellular mechanisms › Diffusion model. ↔ simulation_codes.zip/STEPS/STEPS_rxd.py, lines 1 to 71 · score 0.96 · target injection volume, chosen coordinate, matched volume, volume reached, center distance, selected tetrahedra · Report a mismatch
  3. [3] § Methods › Cell morphologies › Geodesic computing of 3D calcium diffusion in realistic morphologies. ↔ simulation_codes.zip/STEPS/STEPS_diffusion.py, lines 1 to 61 · score 0.95 · accessible intracellular pathways, geodesic coordinate, intracellular space, diffusion distances, geodesic distances, tetrahedral volume · Report a mismatch
  4. [4] § Methods › Cellular mechanisms › Diffusion model. ↔ simulation_codes.zip/STEPS/STEPS_diffusion.py, lines 1 to 61 · score 0.94 · target injection volume, matched volume, volume reached, center distance, selected tetrahedra, source tetrahedron · Report a mismatch
  5. [5] § Methods › Cell morphologies › Geodesic computing of 3D calcium diffusion in realistic morphologies. ↔ simulation_codes.zip/STEPS/STEPS_diffusion_deterministic.py, lines 1 to 66 · score 0.86 · matched simulation, iso volume, Geodesic distance, calcium injection, calcium ion, Dijkstra · Report a mismatch
  6. [6] § Methods › Cell morphologies › Geodesic computing of 3D calcium diffusion in realistic morphologies. ↔ simulation_codes.zip/STEPS/STEPS_diffusion_deterministic.py, lines 1 to 66 · score 0.86 · geodesic coordinate, intracellular space, geodesic distances, tetrahedral volume, calcium distributions, astrocyte branchlet · Report a mismatch
  7. [7] § Methods › Cellular mechanisms › Reaction–diffusion model. ↔ simulation_codes.zip/STEPS/STEPS_rxd.py, lines 1 to 71 · score 0.77 · calmodulin species, calcium calmodulin reaction, calmodulin molecules, reaction scheme, calcium ions, uniformly · Report a mismatch
  8. [8] § Methods › Cellular mechanisms › Reaction–diffusion model. ↔ simulation_codes.zip/NEURON/NEURON_3D_rd_cylinder.py, lines 1 to 50 · score 0.74 · calmodulin species, calcium calmodulin reaction, distributed uniformly, reaction scheme, bound, molecules · Report a mismatch
  9. [9] § Methods › Cell morphologies › Geodesic computing of 3D calcium diffusion in realistic morphologies. ↔ simulation_codes.zip/MCell4/mcell_geodesic_binning.py, lines 1 to 62 · score 0.73 · geodesic binning, particle coordinates, tetrahedral mesh, profiles, MCell, concentrations · Report a mismatch
  10. [10] § Results › Calcium dynamics in simplified and complex astrocyte geometries › Reaction–diffusion simulations. ↔ simulation_codes.zip/MCell4/mcell_axial_binning.py, lines 1 to 71 · score 0.70 · tetrahedralized cylinder mesh, cylindrical geometries, simplified geometries, STEPS simulations, MCell, diffusion simulation · Report a mismatch
  11. [11] § Results › Calcium dynamics in simplified and complex astrocyte geometries › Calcium diffusion simulations. ↔ simulation_codes.zip/NEURON/NEURON_3D_diffusion_cylinder.py, lines 1 to 45 · score 0.68 · intracellular space, injection site, diffusion dynamics, calcium diffusion, discretizing, bins · Report a mismatch
  12. [12] § Results › Calcium dynamics in simplified and complex astrocyte geometries › Reaction–diffusion simulations. ↔ simulation_codes.zip/STEPS/STEPS_rxd_deterministic.py, lines 1 to 67 · score 0.67 · TetODE, stochastic STEPS, Ca4CaM, reaction diffusion model, Reaction diffusion simulations, solvers · Report a mismatch
  13. [13] § Methods › Cell morphologies › Acquisition and processing of astrocyte morphologies. ↔ simulation_codes.zip/NEURON/preprocessing/mesh_to_swc.py, lines 1 to 45 · score 0.66 · Euclidean distance transform, Surface meshes, axis, exported, resolution, Python · Report a mismatch
  14. [14] § Methods › Cell morphologies › Acquisition and processing of astrocyte morphologies. ↔ python/neuroglancer/local_volume.py, lines 51 to 162 · score 0.65 · marching cubes, segmentation volume, deviation, edge, Neuroglancer, surface · Report a mismatch
  15. [15] § Methods › Simulation setup ↔ simulation_codes.zip/MCell4/mcell_axial_binning.py, lines 1 to 71 · score 0.61 · axial binning, axial distance, MCell, cylinder, diffusion simulations, injection · Report a mismatch
  16. [16] § Methods › Cell morphologies › Mesh preparation for MCell and STEPS simulations. ↔ simulation_codes.zip/geometry/msh_to_surface_obj.py, lines 152 to 239 · score 0.57 · enclosed volume, surface area, outward, oriented, triangles, manifold · Report a mismatch
  17. [17] § Methods › Cellular mechanisms ↔ simulation_codes.zip/NEURON/NEURON_1D_rd_cylinder.py, lines 1 to 49 · score 0.55 · calmodulin molecules, calcium calmodulin, calcium ions, interaction, reaction diffusion, Cellular · Report a mismatch
  18. [18] § Methods › Cell morphologies › Mesh preparation for MCell and STEPS simulations. ↔ simulation_codes.zip/geometry/msh_to_surface_obj.py, lines 152 to 239 · score 0.55 · outward orientation, fans, triangles, surface, edge, nodes · Report a mismatch
  19. [19] § Methods › Simulation tools › NEURON. ↔ simulation_codes.zip/NEURON/NEURON_1D_diffusion_cylinder.py, lines 1 to 49 · score 0.54 · single neurons, HOC, reaction diffusion, cylinders, cellular, rxd · Report a mismatch
  20. [20] § Methods › Cell morphologies ↔ simulation_codes.zip/NEURON/NEURON_1D_diffusion_cylinder.py, lines 1 to 49 · score 0.53 · cylinder morphologies, domains, cylindrical, localized, reaction diffusion, cellular · Report a mismatch
  21. [21] § Methods › Cell morphologies › Acquisition and processing of astrocyte morphologies. ↔ python/examples/flood_filling_simulation.py, lines 69 to 186 · score 0.51 · flood filling, Neuroglancer, segmented, volume, morphologies · 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

Python · 372 lines · 12 KB · GPL-3.0 · 2 matches

  1. #!/usr/bin/env python3
  2. """
  3. Voxel-based conversion of surface or tetrahedral meshes to SWC morphologies
  4. for NEURON simulations.
  6. Last updated: 20.8.2026
  7. Author: Laura Keto
  9. Description
  10. -----------
  11. This script converts realistic astrocyte branchlet morphologies represented
  12. as surface meshes (OBJ/OFF/PLY) or tetrahedral meshes (.msh) into tree-based
  13. SWC morphologies suitable for use in the NEURON simulator.
  15. The procedure follows a voxel-tree approach:
  17. 1. The input mesh is voxelized at a specified spatial resolution.
  18. 2. Optional morphological closing is applied to remove small discontinuities.
  19. 3. Occupied voxels are interpreted as nodes in a connectivity graph.
  20. 4. A breadth-first search (BFS) spanning tree is constructed over the voxel set.
  21. 5. Local radii are estimated using a Euclidean distance transform.
  22. 6. The resulting tree is exported in SWC format.
  24. The resulting SWC morphology can be imported into NEURON and used together
  25. with the 3D RxD module, which internally discretizes the geometry on a
  26. Cartesian voxel grid.
  28. Important implementation note
  29. -----------------------------
  30. Voxel grid indices are treated as (x, y, z) and **are not reversed**.
  31. This follows the `trimesh.VoxelGrid.matrix` convention and avoids
  32. unintended axis flips in the reconstructed geometry.
  34. Example usage
  35. -------------
  36. python mesh_to_swc.py mouse_cx_1.obj mouse_cx_1_voxeltree_p005.swc \
  37. --pitch_um 0.05 --mode raw --conn 6 --min_radius_um 0.03
  38. """
  40. import argparse
  41. from pathlib import Path
  43. import numpy as np
  44. import trimesh
  45. from scipy.ndimage import distance_transform_edt, binary_closing
  48. # ---------------------------------------------------------------------
  49. # Input mesh loading
  50. # ---------------------------------------------------------------------
  52. def load_surface_mesh_any(path: str, scale: float) -> trimesh.Trimesh:
  53. """
  54. Load a surface mesh (OBJ, OFF, PLY, etc.) using trimesh.
  56. If the file contains multiple geometries (Scene or list),
  57. they are concatenated into a single mesh. Optional scaling
  58. can be applied to convert units if necessary.
  59. """
  60. m = trimesh.load(path, process=True)
  61. if isinstance(m, trimesh.Scene):
  62. m = trimesh.util.concatenate(tuple(g for g in m.dump() if isinstance(g, trimesh.Trimesh)))
  63. elif isinstance(m, list):
  64. m = trimesh.util.concatenate(tuple(m))
  65. if not isinstance(m, trimesh.Trimesh):
  66. raise RuntimeError("Could not load a surface mesh.")
  67. if scale != 1.0:
  68. m = m.copy()
  69. m.apply_scale(scale)
  70. return m
  73. def load_msh_boundary_surface(path: str, scale: float) -> trimesh.Trimesh:
  74. """
  75. Extract the boundary surface from a tetrahedral .msh mesh.
  77. Boundary faces are identified as triangular faces that belong
  78. to exactly one tetrahedron. The resulting surface mesh is then
  79. returned as a trimesh.Trimesh object.
  80. """
  81. import meshio
  82. msh = meshio.read(path)
  83. pts = msh.points[:, :3].astype(np.float64)
  84. if scale != 1.0:
  85. pts = pts * float(scale)
  87. tet = None
  88. for k in ("tetra", "tetra10"):
  89. if k in msh.cells_dict:
  90. tet = msh.cells_dict[k]
  91. if k == "tetra10":
  92. tet = tet[:, :4]
  93. break
  94. if tet is None:
  95. raise RuntimeError("No tetra/tetra10 cells found in .msh")
  96. tet = tet.astype(np.int64)
  98. faces = np.vstack([
  99. tet[:, [0, 1, 2]],
  100. tet[:, [0, 1, 3]],
  101. tet[:, [0, 2, 3]],
  102. tet[:, [1, 2, 3]],
  103. ])
  104. faces_sorted = np.sort(faces, axis=1)
  105. uniq, counts = np.unique(faces_sorted, axis=0, return_counts=True)
  106. boundary = uniq[counts == 1].astype(np.int64)
  108. return trimesh.Trimesh(vertices=pts, faces=boundary, process=False)
  111. # ---------------------------------------------------------------------
  112. # Voxelization utilities
  113. # ---------------------------------------------------------------------
  115. def _robust_voxel_origin(vg, mesh):
  116. """
  117. Determine the spatial origin of the voxel grid.
  119. This attempts to extract the origin from the voxel grid object.
  120. If unavailable, the lower mesh bounding box corner is used.
  121. """
  122. if hasattr(vg, "origin"):
  123. return np.asarray(vg.origin, dtype=float)
  124. if hasattr(vg, "transform"):
  125. T = np.asarray(vg.transform, dtype=float)
  126. return T[:3, 3]
  127. return mesh.bounds[0].astype(float)
  130. def make_ball_struct(radius_vox: int):
  131. """
  132. Construct a spherical structuring element for morphological operations.
  133. """
  134. r = int(radius_vox)
  135. if r <= 0:
  136. return np.ones((1, 1, 1), dtype=bool)
  137. ax = np.arange(-r, r + 1)
  138. X, Y, Z = np.meshgrid(ax, ax, ax, indexing="ij")
  139. return (X * X + Y * Y + Z * Z) <= (r * r)
  142. def voxelize(mesh: trimesh.Trimesh, pitch_um: float, mode: str,
  143. close_radius_vox: int, close_iters: int):
  144. """
  145. Convert a surface mesh into an occupied voxel grid.
  147. Parameters
  148. ----------
  149. pitch_um : float
  150. Voxel size (µm).
  151. mode : str
  152. 'raw' = surface voxelization
  153. 'filled' = filled interior voxelization
  154. close_radius_vox : int
  155. Radius for optional morphological closing (voxels).
  156. close_iters : int
  157. Number of closing iterations.
  158. """
  160. vg = mesh.voxelized(pitch=pitch_um)
  162. if mode == "raw":
  163. pass
  164. elif mode == "filled":
  165. try:
  166. vg = vg.fill()
  167. except Exception:
  168. pass
  169. else:
  170. raise ValueError("--mode must be raw or filled")
  172. if hasattr(vg, "matrix"):
  173. occ = np.asarray(vg.matrix, dtype=bool)
  174. else:
  175. occ = np.asarray(vg.encoding.dense, dtype=bool)
  177. origin = _robust_voxel_origin(vg, mesh)
  179. if close_radius_vox > 0 and close_iters > 0:
  180. st = make_ball_struct(close_radius_vox)
  181. v = occ
  182. for _ in range(int(close_iters)):
  183. v = binary_closing(v, structure=st)
  184. occ = np.asarray(v, dtype=bool)
  186. return occ, origin
  189. # ---------------------------------------------------------------------
  190. # Connectivity graph and spanning tree construction
  191. # ---------------------------------------------------------------------
  193. def neighbor_offsets(conn: int):
  194. """
  195. Define voxel neighborhood offsets.
  197. conn = 6 : face connectivity
  198. conn = 26 : full cubic neighborhood
  199. """
  200. if conn == 6:
  201. return np.array([
  202. (1, 0, 0), (-1, 0, 0),
  203. (0, 1, 0), (0, -1, 0),
  204. (0, 0, 1), (0, 0, -1),
  205. ], dtype=int)
  206. elif conn == 26:
  207. offs = []
  208. for dx in (-1, 0, 1):
  209. for dy in (-1, 0, 1):
  210. for dz in (-1, 0, 1):
  211. if dx == dy == dz == 0:
  212. continue
  213. offs.append((dx, dy, dz))
  214. return np.array(offs, dtype=int)
  215. else:
  216. raise ValueError("--conn must be 6 or 26")
  219. def pick_root(occ_idx_xyz, prefer="minx"):
  220. """
  221. Select a root voxel for tree construction.
  222. """
  223. if prefer == "minx":
  224. x = occ_idx_xyz[:, 0]
  225. return int(np.argmin(x))
  226. elif prefer == "center":
  227. c = occ_idx_xyz.mean(axis=0)
  228. d = np.sum((occ_idx_xyz - c[None, :])**2, axis=1)
  229. return int(np.argmin(d))
  230. else:
  231. raise ValueError("--root_prefer must be minx or center")
  234. def bfs_spanning_tree(occ_bool: np.ndarray, occ_idx: np.ndarray, conn: int, root_k: int):
  235. """
  236. Construct a spanning tree over the occupied voxel graph using BFS.
  238. Each voxel becomes a node, and edges correspond to voxel adjacency.
  239. The BFS tree ensures a valid SWC parent-child hierarchy.
  240. """
  241. N = occ_idx.shape[0]
  242. X, Y, Z = occ_bool.shape
  244. index_map = -np.ones((X, Y, Z), dtype=np.int64)
  245. for i, (x, y, z) in enumerate(occ_idx):
  246. index_map[x, y, z] = i
  248. offs = neighbor_offsets(conn)
  250. parent = -np.ones(N, dtype=np.int64)
  251. seen = np.zeros(N, dtype=bool)
  252. q = [int(root_k)]
  253. seen[root_k] = True
  254. order = [int(root_k)]
  256. while q:
  257. u = q.pop(0)
  258. x, y, z = occ_idx[u]
  259. for dx, dy, dz in offs:
  260. x2, y2, z2 = x + dx, y + dy, z + dz
  261. if not (0 <= x2 < X and 0 <= y2 < Y and 0 <= z2 < Z):
  262. continue
  263. v = index_map[x2, y2, z2]
  264. if v < 0:
  265. continue
  266. if not seen[v]:
  267. seen[v] = True
  268. parent[v] = u
  269. q.append(int(v))
  270. order.append(int(v))
  272. return order, parent, seen
  275. # ---------------------------------------------------------------------
  276. # SWC export
  277. # ---------------------------------------------------------------------
  279. def write_swc(out_path: Path, order, parent, xyz_um, radii_um, swc_type: int, header_lines):
  280. """
  281. Write the generated voxel-tree morphology to an SWC file.
  282. """
  283. out_path.parent.mkdir(parents=True, exist_ok=True)
  284. nid = {v: i + 1 for i, v in enumerate(order)}
  285. with out_path.open("w") as f:
  286. for h in header_lines:
  287. f.write(h.rstrip("\n") + "\n")
  288. for v in order:
  289. x, y, z = xyz_um[v]
  290. r = float(radii_um[v])
  291. p = int(parent[v])
  292. pid = -1 if p < 0 else nid[p]
  293. f.write(f"{nid[v]} {swc_type} {x:.6f} {y:.6f} {z:.6f} {r:.6f} {pid}\n")
  294. print(f"[done] wrote {out_path.resolve()}")
  297. # ---------------------------------------------------------------------
  298. # Main execution
  299. # ---------------------------------------------------------------------
  301. def main():
  302. ap = argparse.ArgumentParser()
  303. ap.add_argument("input", help="OBJ/OFF/PLY... surface mesh OR .msh tet mesh")
  304. ap.add_argument("swc", help="Output SWC path")
  306. ap.add_argument("--pitch_um", type=float, default=0.05)
  307. ap.add_argument("--mode", choices=["raw", "filled"], default="raw")
  308. ap.add_argument("--close_radius_vox", type=int, default=0)
  309. ap.add_argument("--close_iters", type=int, default=0)
  311. ap.add_argument("--conn", type=int, choices=[6, 26], default=6)
  312. ap.add_argument("--root_prefer", choices=["minx", "center"], default="minx")
  314. ap.add_argument("--min_radius_um", type=float, default=None)
  315. ap.add_argument("--scale", type=float, default=1.0)
  316. ap.add_argument("--type", type=int, default=3)
  318. args = ap.parse_args()
  320. ext = args.input.lower().split(".")[-1]
  321. if ext == "msh":
  322. mesh = load_msh_boundary_surface(args.input, args.scale)
  323. print(f"[input] msh boundary surface: watertight={mesh.is_watertight} faces={len(mesh.faces)}")
  324. else:
  325. mesh = load_surface_mesh_any(args.input, args.scale)
  326. print(f"[input] surface mesh: watertight={mesh.is_watertight} faces={len(mesh.faces)}")
  328. occ, origin = voxelize(mesh, args.pitch_um, args.mode, args.close_radius_vox, args.close_iters)
  329. n_occ = int(occ.sum())
  330. print(f"[vox] mode={args.mode} pitch_um={args.pitch_um} shape={occ.shape} occupied={n_occ} origin={origin}")
  331. if n_occ == 0:
  332. raise RuntimeError("Empty voxelization. Check units/pitch.")
  334. # Occupied indices are (x, y, z) in this version.
  335. occ_idx = np.argwhere(occ)
  337. # Radii from EDT.
  338. edt_um = distance_transform_edt(occ) * float(args.pitch_um)
  339. radii_um = edt_um[tuple(occ_idx.T)].astype(np.float64) - 0.5 * float(args.pitch_um)
  340. min_r = float(args.min_radius_um) if args.min_radius_um is not None else 0.5 * float(args.pitch_um)
  341. radii_um = np.maximum(radii_um, min_r)
  343. # World coordinates at voxel centers: (x, y, z) directly (no flip).
  344. xyz_um = (occ_idx.astype(np.float64) + 0.5) * float(args.pitch_um) + origin
  346. root_k = pick_root(occ_idx, prefer=args.root_prefer)
  347. order, parent, seen = bfs_spanning_tree(occ, occ_idx, args.conn, root_k)
  349. reached = int(seen.sum())
  350. if reached < n_occ:
  351. print(f"[warn] not fully connected: reached {reached}/{n_occ}. SWC will contain only root component.")
  353. print(f"[tree] nodes={len(order)} conn={args.conn} root_prefer={args.root_prefer}")
  354. print(f"[radii] min/med/max = {float(radii_um.min()):.6g} / {float(np.median(radii_um)):.6g} / {float(radii_um.max()):.6g}")
  356. header = [
  357. "# voxel-tree SWC (space-filling noodles; NO axis reversal)",
  358. f"# input: {args.input}",
  359. f"# pitch_um: {args.pitch_um}",
  360. f"# mode: {args.mode}",
  361. f"# close_radius_vox: {args.close_radius_vox}",
  362. f"# close_iters: {args.close_iters}",
  363. f"# conn: {args.conn}",
  364. f"# min_radius_um: {min_r}",
  365. f"# origin: {origin.tolist()}",
  366. ]
  368. write_swc(Path(args.swc), order, parent, xyz_um, radii_um, args.type, header)
  371. if __name__ == "__main__":
  372. main()

mesh_to_swc.py, under GPL-3.0 · at the source

Overview

Authors: Laura Keto1, Saana Seppälä1, Derek Ndubuaku1, Annika Mäki1, Tuomo Mäki-Marttunen1, Marja-Leena Linne1, Tiina Manninen1
ORCID iDs: Laura Keto, Saana Seppälä, Derek Ndubuaku, Annika Mäki, Tiina Manninen
  1. Faculty of Medicine and Health Technology, Tampere University, Tampere, Finland
Institutions: Tampere University (Finland)
Journal: PLoS computational biology, volume 22, issue 10, article e1014878
Dates: received 13 April 2026; accepted 6 October 2026; published online 28 October 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1371/journal.pcbi.1014878 · PMID 42950104 · PMCID PMC13716318 · OpenAlex W7204149251
Open access: gold, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: human (organism), mouse (organism), computational (subfield)
Methods: Connectivity, Preprocessing, fMRI & imaging
MeSH: Astrocytes*, Models, Biological*, Models, Neurological*, Animals, Calcium, Calmodulin, Computational Biology, Computer Simulation, Diffusion, Humans, Mice (* major topic)
Topic: Neural dynamics and brain function (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: European Commission; Academy of Finland; Suomen Kulttuurirahasto; HORIZON EUROPE Framework Programme
Citations: not cited yet (Europe PMC); 89 references in the paper

Abstract

Computational modeling of spatial biochemical processes in neuroscience is increasingly important as advances in experimental and imaging techniques provide detailed insights into cellular organization. Reaction–diffusion models are commonly used to study the diffusion and interactions of ions and molecules within neuronal cells, and multiple open-access simulation platforms have been developed to support such analysis. However, a comprehensive analysis of commonly used simulation tools, including MCell, STEPS, NeuroRD, and NEURON, remains lacking, particularly for realistic glial cell geometries, as these tools were originally developed for neurons. Here, we present a systematic analysis of these four simulation environments by implementing equivalent calcium diffusion and calcium–calmodulin reaction–diffusion models across a range of spatial domains. These include simplified geometries (cylinders and rectangular cuboids) as well as biologically realistic astroglial morphologies derived from electron microscopy data, including mouse Bergmann glia and mouse and human cortical astrocytes. Using matched kinetic parameters and diffusion constants, we examine simulation outputs and morphological variations across platforms under comparable conditions. We find that all tools produce overall consistent results for the systems considered, indicating that each can reliably capture diffusion and reaction–diffusion dynamics in simplified and complex geometries. At the same time, we show that the structural heterogeneity of branchlets from human astrocytes and mouse Bergmann glia gives rise to distinct calcium signaling, demonstrating that fine-scale morphology critically shapes astroglial dynamics and must be accurately captured by simulation frameworks. In addition, notable differences emerge in geometry representation, implementation strategies, computational aspects, and usability of the tools. By highlighting key trade-offs between geometric fidelity, flexibility, and computational cost in modeling intracellular biochemical processes, these findings provide practical guidance for selecting appropriate simulation tools. More broadly, our results support the use of reaction–diffusion modeling in morphologically realistic astrocytic environments and contribute to enabling mechanistic studies of localized signaling events at synaptic and perisynaptic sites.

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

Repositories

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

google/neuroglancer

License: Apache-2.0
State: the link answers, verified on 27 October 2026
Evidence: files inventoried
Commit: bcecdb0cbb877191e20cfa358803f6e7547583c2, 26 October 2026
Languages: TypeScript (710), Python (133), C++ (23), JavaScript (20), Shell (11), C/C++ (6), Go (3), NEURON (1), Jupyter (1), Rust (1), C (1)
Size: 2,071 files, 910 scripts
Software Heritage: archived
Found in: the text, “Introduction”
Holds: README, license file, environment (pyproject.toml, setup.py, uv.lock, docs/pyproject.toml, python/Dockerfile, src/mesh/draco/Dockerfile, src/sliceview/compresso/Dockerfile, src/sliceview/crackle/Dockerfile, src/sliceview/jxl/compile.Dockerfile, src/sliceview/jxl/optimize.Dockerfile, src/sliceview/png/Dockerfile), tests, continuous integration, documentation, 1 notebook
Not found: CITATION.cff
Tools: NumPy (67 files), Pillow (3 files), SciPy (3 files), pandas (1 file)
Availability: 2 checks, the latest on 27 October 2026: the link answers
  • 27 October 2026: the link answers
  • 27 September 2026: the link answers
912 files
At the source: github.com/google/neuroglancer

Zenodo 22041896

License: GPL-3.0
State: the link answers, verified on 30 October 2026
Evidence: files inventoried
Size: 4 files
Software Heritage: not checked
Found in: “Data Availability”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (15 files), Matplotlib (11 files), NEURON (6 files), SciPy (4 files)
Availability: 1 check, the latest on 30 October 2026: the link answers (HTTP 200)
  • 30 October 2026: the link answers (HTTP 200)
24 files
At the source: doi.org/10.5281/zenodo.22041896

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:

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

All relevant information to build computational models is within the article and its Supporting information file (S1 Appendix). Geometric data for cylinder and rectangular cuboid structures and all codes utilized in this work are available on Zenodo at https://doi.org/10.5281/zenodo.22041896 under the GNU General Public License. The real cell morphology data used in this study were obtained from the mouse cerebellar cortex dataset available at BossDB (https://bossdb.org/project/nguyen_thomas2022), mouse cortex dataset available at MICrONS Consortium (https://www.microns-explorer.org/), and human temporal cortex dataset available at H01 (https://h01-release.storage.googleapis.com/landing.html).

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

Recorded: type, language, journal, volume, issue, pages, dates, 7 authors, 11 MeSH terms, 4 funders, 84 references.

Cite

This paper

Keto, L., Seppälä, S., Ndubuaku, D., Mäki, A., Mäki-Marttunen, T., Linne, M.-L., & Manninen, T. (2026). Modeling reaction-diffusion processes in simplified to complex astroglial branchlet geometries using different simulation tools. PLoS computational biology, 22(10), e1014878. https://doi.org/10.1371/journal.pcbi.1014878

BibTeX

@article{keto2026modeling,
author = {Keto, Laura and Seppälä, Saana and Ndubuaku, Derek and Mäki, Annika and Mäki-Marttunen, Tuomo and Linne, Marja-Leena and Manninen, Tiina},
title = {{Modeling reaction-diffusion processes in simplified to complex astroglial branchlet geometries using different simulation tools}},
journal = {PLoS computational biology},
year = {2026},
month = oct,
volume = {22},
number = {10},
pages = {e1014878},
publisher = {PLOS},
issn = {1553-734X},
doi = {10.1371/journal.pcbi.1014878},
url = {https://doi.org/10.1371/journal.pcbi.1014878},
pmid = {42950104},
pmcid = {PMC13716318}
}

RIS

TY - JOUR
AU - Keto, Laura
AU - Seppälä, Saana
AU - Ndubuaku, Derek
AU - Mäki, Annika
AU - Mäki-Marttunen, Tuomo
AU - Linne, Marja-Leena
AU - Manninen, Tiina
TI - Modeling reaction-diffusion processes in simplified to complex astroglial branchlet geometries using different simulation tools
T2 - PLoS computational biology
J2 - PLoS Comput Biol
PY - 2026
DA - 2026/10/28
VL - 22
IS - 10
SP - e1014878
SN - 1553-734X
PB - PLOS
DO - 10.1371/journal.pcbi.1014878
UR - https://doi.org/10.1371/journal.pcbi.1014878
LA - en
ER -

CSL-JSON

{
"id": "10.1371/journal.pcbi.1014878",
"type": "article-journal",
"title": "Modeling reaction-diffusion processes in simplified to complex astroglial branchlet geometries using different simulation tools",
"container-title": "PLoS computational biology",
"author": [
{
"family": "Keto",
"given": "Laura"
},
{
"family": "Seppälä",
"given": "Saana"
},
{
"family": "Ndubuaku",
"given": "Derek"
},
{
"family": "Mäki",
"given": "Annika"
},
{
"family": "Mäki-Marttunen",
"given": "Tuomo"
},
{
"family": "Linne",
"given": "Marja-Leena"
},
{
"family": "Manninen",
"given": "Tiina"
}
],
"container-title-short": "PLoS Comput Biol",
"volume": "22",
"issue": "10",
"page": "e1014878",
"DOI": "10.1371/journal.pcbi.1014878",
"PMID": "42950104",
"PMCID": "PMC13716318",
"ISSN": "1553-734X",
"publisher": "PLOS",
"URL": "https://doi.org/10.1371/journal.pcbi.1014878",
"language": "en",
"issued": {
"date-parts": [
[
2026,
10,
28
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1371/journal.pcbi.1013503 [code]
Modeling neuron-astrocyte interactions in neural networks using distributed simulation.
Journal: PLoS computational biology
In common: pandas, NumPy, 12 references, author Tiina Manninen
[2] doi:10.1007/s12021-023-09622-w [code]
Analysis of Network Models with Neuron-Astrocyte Interactions.
Journal: Neuroinformatics
In common: SciPy, Matplotlib, NumPy, 9 references, author Tiina Manninen
[3] doi:10.7554/elife.69013 [code]
Combining hypothesis- and data-driven neuroscience modeling in FAIR workflows.
Journal: eLife
In common: NEURON, pandas, SciPy, 2 other tools, 10 references
[4] doi:10.1038/s43588-024-00745-x [code]
Spatial modeling algorithms for reactions and transport in biological cells.
Journal: Nature computational science
In common: pandas, SciPy, Matplotlib, 1 other tool, 9 references
[5] doi:10.1093/bib/bbac491 [code]
Ultraliser: a framework for creating multiscale, high-fidelity and geometrically realistic 3D models for in silico neuroscience.
Journal: Briefings in bioinformatics
In common: Pillow, pandas, SciPy, 2 other tools, 8 references
[6] doi:10.3389/fninf.2022.883742 [code]
STEPS 4.0: Fast and memory-efficient molecular simulations of neurons at the nanoscale.
Journal: Frontiers in neuroinformatics
In common: pandas, SciPy, Matplotlib, 1 other tool, 7 references
[7] doi:10.1038/s42003-024-06276-5 [code]
Vesicle and reaction-diffusion hybrid modeling with STEPS.
Journal: Communications biology
In common: NEURON, pandas, SciPy, 2 other tools, 5 references
[8] doi:10.1093/bib/bbae393 [code]
Synthesis of geometrically realistic and watertight neuronal ultrastructure manifolds for in silico modeling.
Journal: Briefings in bioinformatics
In common: NEURON, NumPy, computational, 5 references
[9] doi:10.3389/fninf.2022.884046 [code]
Modernizing the NEURON Simulator for Sustainability, Portability, and Performance.
Journal: Frontiers in neuroinformatics
In common: NEURON, Pillow, pandas, 3 other tools, computational, 4 references
[10] doi:10.7554/elife.103324 [code]
DendroTweaks, an interactive approach for unraveling dendritic dynamics.
Journal: eLife
In common: NEURON, pandas, SciPy, 2 other tools, mouse, 5 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.1371/journal.pcbi.1014878.svg)](https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014878)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014878.svg
   :target: https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014878
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014878"><img src="https://openscicode.org/badge/doi/10.1371/journal.pcbi.1014878.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.