OSCR

Macroscopic cerebral energy efficiency corresponds to neuron reorganization in awake and anesthetized mice

Code ↔ Paper

The paper beside its authors' code: matches between them have not been computed for this paper yet.

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 · 334 lines · 14 KB · Apache-2.0

  1. #Copyright 2015-2017 MathWorks, Inc.
  3. # This template is used to generate an __init__.py file for a particular deployable package.
  5. """ Package for executing deployed MATLAB functions """
  7. from __future__ import print_function
  8. import atexit
  9. import glob
  10. import importlib
  11. import os
  12. import os.path
  13. import pdb
  14. import platform
  15. import sys
  16. import weakref
  18. class _PathInitializer(object):
  19. PLATFORM_DICT = {'Windows': ['PATH','dll',''], 'Linux': ['LD_LIBRARY_PATH','so','libmw'], 'Darwin': ['DYLD_LIBRARY_PATH','dylib','libmw']}
  20. SUPPORTED_PYTHON_VERSIONS = ['2_7', '3_4', '3_5', '3_6']
  21. RUNTIME_VERSION_W_DOTS = '9.3'
  22. RUNTIME_VERSION_W_UNDERSCORES = '9_3'
  23. PACKAGE_NAME = 'STNeuroNetPkg'
  25. def set_interpreter_version(self):
  26. """Make sure the interpreter version is supported."""
  27. ver = sys.version_info
  28. version = '{0}_{1}'.format(ver[0], ver[1])
  30. if version in _PathInitializer.SUPPORTED_PYTHON_VERSIONS:
  31. self.interpreter_version = version
  32. else:
  33. version_with_dot = version.replace("_", ".")
  34. raise EnvironmentError("Python {0} is not supported.".format(version_with_dot))
  36. def __init__(self):
  37. """Initialize the variables."""
  38. self.arch = ''
  39. self.is_linux = False
  40. self.is_mac = False
  41. self.is_windows = False
  42. self.mr_handle = None
  43. self.ml_handle = None
  44. self.system = ''
  45. self.cppext_handle = None
  47. # path to the folder that stores Python extensions and shared libraries
  48. self.bin_dir = ''
  50. # path to the folder that stores pure Python matlab_pysdk.runtime code (_runtime_dir)
  51. self.runtime_dir = ''
  53. # path to the folder that stores the pure Python matlab mlarray code used for type conversion
  54. self.ml_dir = ''
  56. self.set_interpreter_version()
  57. self.get_platform_info()
  59. this_folder = os.path.dirname(os.path.realpath(__file__))
  60. self.path_file_name = os.path.join(this_folder, 'paths.{0}.txt'.format(self.arch))
  62. self.instances_of_this_package = set([])
  65. def read_path_file(self):
  66. """Look for a file that lists items to add to path. If present, read it and add the paths."""
  67. filtered_lines = []
  68. if os.path.isfile(self.path_file_name):
  69. pth_file = open(self.path_file_name, 'r')
  70. lines = pth_file.readlines()
  71. for line in lines:
  72. stripped_line = line.strip()
  73. if stripped_line and stripped_line[0] != '#':
  74. filtered_lines.append(stripped_line)
  75. length = len(filtered_lines)
  76. if length == 3:
  77. (bin_dir, runtime_dir, ml_dir) = filtered_lines
  78. if (not os.path.isdir(bin_dir)) or (not os.path.isdir(runtime_dir)) or (not os.path.isdir(ml_dir)):
  79. return False
  80. else:
  81. (self.bin_dir, self.runtime_dir, self.ml_dir) = (bin_dir, runtime_dir, ml_dir)
  82. return True
  83. else:
  84. return False
  86. def write_path_file(self):
  87. """Write a file that lists items to add to path. If present, it will be overwritten."""
  88. existing_contents = ''
  89. if os.path.isfile(self.path_file_name):
  90. path_file = open(self.path_file_name, 'r')
  91. existing_contents = path_file.readlines()
  92. path_file.close()
  94. path_file = open(self.path_file_name, 'w')
  95. if self.system == 'Windows':
  96. print('# bin dir: added to both OS path and system path', file=path_file)
  97. else:
  98. print('# bin dir: added to system path', file=path_file)
  99. print(self.bin_dir, file=path_file)
  100. print('', file=path_file)
  102. print('# runtime dir: added to system path', file=path_file)
  103. print(self.runtime_dir, file=path_file)
  104. print('', file=path_file)
  106. print('# matlab (mlarray) dir: added to system path', file=path_file)
  107. print(self.ml_dir, file=path_file)
  108. print('', file=path_file)
  110. if existing_contents:
  111. print(existing_contents, file=path_file)
  112. path_file.close()
  114. def get_platform_info(self):
  115. """Ask Python for the platform and architecture."""
  117. # This will return 'Windows', 'Linux', or 'Darwin' (for Mac).
  118. self.system = platform.system()
  119. if not self.system in _PathInitializer.PLATFORM_DICT:
  120. raise RuntimeError('{0} is not a supported platform.'.format(self.system))
  121. else:
  122. # path_var is the OS-dependent name of the path variable ('PATH', 'LD_LIBRARY_PATH', "DYLD_LIBRARY_PATH')
  123. (self.path_var, self.ext, self.lib_prefix) = _PathInitializer.PLATFORM_DICT[self.system]
  125. if self.system == 'Windows':
  126. self.is_windows = True
  127. bit_str = platform.architecture()[0]
  128. if bit_str == '64bit':
  129. self.arch = 'win64'
  130. elif bit_str == '32bit':
  131. self.arch = 'win32'
  132. else:
  133. raise RuntimeError('{0} is not supported.'.format(bit_str))
  134. elif self.system == 'Linux':
  135. self.is_linux = True
  136. self.arch = 'glnxa64'
  137. elif self.system == 'Darwin':
  138. self.is_mac = True
  139. self.arch = 'maci64'
  140. else:
  141. raise RuntimeError('Operating system {0} is not supported.'.format(self.system))
  143. def get_paths_from_os(self):
  144. """
  145. Look through the system path for a file whose name contains a runtime version
  146. corresponding to the one with which this package was produced.
  147. """
  149. # Concatenates the pieces into a string. The double parentheses are necessary.
  150. if self.system == 'Windows':
  151. file_to_find = ''.join((self.lib_prefix, 'mclmcrrt',
  152. _PathInitializer.RUNTIME_VERSION_W_UNDERSCORES, '.', self.ext))
  153. elif self.system == 'Linux':
  154. file_to_find = ''.join((self.lib_prefix, 'mclmcrrt', '.', self.ext, '.',
  155. _PathInitializer.RUNTIME_VERSION_W_DOTS))
  156. elif self.system == 'Darwin':
  157. file_to_find = ''.join((self.lib_prefix, 'mclmcrrt', '.',
  158. _PathInitializer.RUNTIME_VERSION_W_DOTS,
  159. '.', self.ext))
  160. else:
  161. raise RuntimeError('Operating system {0} is not supported.'.format(self.system))
  163. path_elements = []
  164. if self.path_var in os.environ:
  165. path_elements = os.environ[self.path_var].split(os.pathsep)
  166. if not path_elements:
  167. friendly_os_name = self.system
  168. if friendly_os_name == 'Darwin':
  169. friendly_os_name = 'Mac'
  170. raise RuntimeError('On {0}, you must set the environment variable "{1}" to a non-empty string. {2}'.format(
  171. friendly_os_name, self.path_var, 'For more details, see the package documentation.'))
  173. path_found = ''
  174. for elem in path_elements:
  175. filename = os.path.join(elem, file_to_find)
  176. if (os.path.isfile(filename)):
  177. path_found = elem
  178. break
  179. if not path_found:
  180. raise RuntimeError('Could not find an appropriate directory for MATLAB or the MATLAB runtime in {0}. Details: {1}'.format(
  181. self.path_var, file_to_find))
  183. # The last nonblank part of the path should be the arch (e.g., "win64").
  184. path_components = path_found.split(os.sep)
  185. if path_components[-1]:
  186. last_path_component = path_components[-1]
  187. else:
  188. # The directory name ended with a slash, so the last item in the list was an empty string. Go back one more.
  189. last_path_component = path_components[-2]
  191. if last_path_component != self.arch:
  192. raise RuntimeError('To call deployed MATLAB code on a {0} machine, you must run a {0} version of Python. Details: {1}'.format(
  193. last_path_component, path_found))
  195. matlabroot = os.path.dirname(os.path.dirname(os.path.normpath(path_found)))
  196. bin_dir = os.path.join(matlabroot, 'bin', self.arch)
  197. runtime_dir = os.path.join(matlabroot, 'toolbox', 'compiler_sdk', 'pysdk_py')
  198. ml_dir = os.path.join(runtime_dir, 'mlarray_dist')
  199. if not os.path.isdir(bin_dir):
  200. raise RuntimeError('Could not find the directory {0}'.format(bin_dir))
  201. if not os.path.isdir(runtime_dir):
  202. raise RuntimeError('Could not find the directory {0}'.format(runtime_dir))
  203. if not os.path.isdir(ml_dir):
  204. raise RuntimeError('Could not find the directory {0}'.format(ml_dir))
  205. (self.bin_dir, self.runtime_dir, self.ml_dir) = (bin_dir, runtime_dir, ml_dir)
  207. def update_paths(self):
  208. """Update the OS and Python paths."""
  210. #For Windows, add the bin_dir to the OS path. This is unnecessary
  211. #for Linux and Mac, where the OS can find this information via rpath.
  212. if self.is_windows:
  213. os.environ[self.path_var] = self.bin_dir + os.pathsep + os.environ[self.path_var]
  215. #Add all paths to the Python path.
  216. sys.path.insert(0, self.bin_dir)
  217. sys.path.insert(0, self.runtime_dir)
  218. sys.path.insert(0, self.ml_dir)
  220. def import_matlab_pysdk_runtime(self):
  221. """Import matlab_pysdk.runtime. Must be done after update_paths() and import_cppext() are called."""
  222. try:
  223. self.mr_handle = importlib.import_module('matlab_pysdk.runtime')
  224. except Exception as e:
  225. raise e
  227. if not hasattr(self.mr_handle, '_runtime_version_w_dots'):
  228. raise RuntimeError('Runtime version of package ({0}) does not match runtime version of previously loaded package'.format(
  229. _PathInitializer.RUNTIME_VERSION_W_DOTS))
  230. elif self.mr_handle._runtime_version_w_dots and (self.mr_handle._runtime_version_w_dots != _PathInitializer.RUNTIME_VERSION_W_DOTS):
  231. raise RuntimeError('Runtime version of package ({0}) does not match runtime version of previously loaded package ({1})'.format(
  232. _PathInitializer.RUNTIME_VERSION_W_DOTS,
  233. self.mr_handle._runtime_version_w_dots))
  234. else:
  235. self.mr_handle._runtime_version_w_dots = _PathInitializer.RUNTIME_VERSION_W_DOTS
  237. self.mr_handle._cppext_handle = self.cppext_handle
  239. def import_matlab(self):
  240. """Import the matlab package. Must be done after Python system path contains what it needs to."""
  241. try:
  242. self.ml_handle = importlib.import_module('matlab')
  243. except Exception as e:
  244. raise e
  246. def initialize_package(self):
  247. package_handle = self.mr_handle.DeployablePackage(self, self.PACKAGE_NAME, __file__)
  248. self.instances_of_this_package.add(weakref.ref(package_handle))
  249. package_handle.initialize()
  250. return package_handle
  252. def initialize_runtime(self, option_list):
  253. if not self.cppext_handle:
  254. raise RuntimeError('Cannot call initialize_application before import_cppext.')
  255. if self.is_mac:
  256. ignored_option_found = False
  257. for option in option_list:
  258. if option in ('-nodisplay', '-nojvm'):
  259. ignored_option_found = True
  260. break
  261. if ignored_option_found:
  262. print('WARNING: Options "-nodisplay" and "-nojvm" are ignored on Mac.')
  263. print('They must be passed to mwpython in order to take effect.')
  264. self.cppext_handle.initializeApplication(option_list)
  266. def terminate_runtime(self):
  267. if not self.cppext_handle:
  268. raise RuntimeError('Cannot call terminate_application before import_cppext.')
  269. self.cppext_handle.terminateApplication()
  271. def import_cppext(self):
  272. self.cppext_handle = importlib.import_module("matlabruntimeforpython" + self.interpreter_version)
  274. try:
  275. _pir = _PathInitializer()
  276. _pir.get_paths_from_os()
  278. _pir.update_paths()
  279. _pir.import_cppext()
  280. _pir.import_matlab_pysdk_runtime()
  281. _pir.import_matlab()
  282. except Exception as e:
  283. print("Exception caught during initialization of Python interface. Details: {0}".format(e))
  284. raise
  285. # We let the program exit normally.
  287. def initialize():
  288. """
  289. Initialize package and return a handle.
  291. Initialize a package consisting of one or more deployed MATLAB functions. The return
  292. value is used as a handle on which any of the functions can be executed. To wait
  293. for all graphical figures to close before continuing, call wait_for_figures_to_close()
  294. on the handle. To close the package, call terminate(), quit() or exit() (which are
  295. synonymous) on the handle. The terminate() function is executed automatically when the
  296. script or session ends.
  298. Returns
  299. handle - used to execute deployed MATLAB functions and to call terminate()
  300. """
  301. return _pir.initialize_package()
  303. def initialize_runtime(option_list):
  304. """
  305. Initialize runtime with a list of startup options.
  307. Initialize the MATLAB Runtime with a list of startup options that will affect
  308. all packages opened within the script or session. If it is not called
  309. explicitly, it will be executed automatically, with an empty list of options,
  310. by the first call to initialize(). Do not call initialize_runtime() after
  311. calling initialize().
  313. There is no corresponding terminate_runtime() call. The runtime is terminated
  314. automatically when the script or session ends.
  316. Parameters
  317. option_list - Python list of options; valid options are:
  318. -nodisplay (suppresses display functionality; Linux only)
  319. -nojvm (disables the Java Virtual Machine)
  320. """
  321. if option_list:
  322. if not isinstance(option_list, list) and not isinstance(option_list, tuple):
  323. raise SyntaxError('initialize_runtime takes a list or tuple of strings.')
  324. _pir.initialize_runtime(option_list)
  326. # terminate_runtime() is intentionally omitted. Instead, when running interactively,
  327. # the user should call exit(). When running a script, the runtime will automatically be
  328. # terminated when the script ends.
  330. @atexit.register
  331. def __exit_packages():
  332. for package in _pir.instances_of_this_package:
  333. if package() is not None:
  334. package().terminate()

__init__.py at commit 6537096, under Apache-2.0 · at the source

Overview

Authors: Da Wang1,2, Hui Li1, Jinggui Gao3, Yifan Zeng1,2, Mengyang Xu1,2,4,5, Binshi Bo6, Mengchao Pei6, Zhifeng Liang6, Ning Zhou1, Garth J. Thompson1,7
  1. iHuman Institute, ShanghaiTech University, Shanghai, China
  2. School of Life Science and Technology, ShanghaiTech University, Shanghai, China
  3. Department of Neurology, The First Affiliated Hospital of Shenzhen University, Shenzhen Second People's Hospital, Shenzhen, China
  4. Center for Excellence in Molecular Cell Science, Shanghai Institute of Biochemistry and Cell Biology, Chinese Academy of Sciences, Shanghai, China
  5. University of Chinese Academy of Sciences, Beijing, China
  6. CAS Center for Excellence in Brain Science and Intelligence Technology, Institute of Neuroscience, Chinese Academy of Sciences, Shanghai, China
  7. School of Pharmacy, Anhui University of Chinese Medicine, Hefei, China
Journal: Frontiers in neuroscience, volume 20, article 1949911
Dates: received 27 July 2026; accepted 17 September 2026; published online 9 October 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI · PMCID PMC13690678
Status: code verified (how the code is found and verified)
Categories: fMRI (modality), histology / microscopy (modality), human (organism), mouse (organism)
Methods: Spectral & time-frequency, Statistics, Smoothing, state filtering, decompositions, Preprocessing, Connectivity, Graphs, fMRI & imaging, Single-unit activity, calcium imaging
Keywords: calibrated fMRI, cerebral energy efficiency, CMRO2, relative cost, relative power
Citations: not cited yet (Europe PMC); 74 references in the paper

Abstract

Introduction: Non-invasive imaging of brain function and energy supply is crucial for diagnosing and treating brain disorders. Conventional imaging struggles to capture altered relationships between energy supply and demand caused by brain diseases. A novel method, thus far only tested non-invasively in human subjects, is to calculate relative power (rPWR) and relative cost (rCST) to assess cerebral energy efficiency. However, whether rPWR/rCST tracks individual changes and relate to neural activity remains unproven.

Methods: Our study examines awake and anesthetized male mice and compares rPWR/rCST with invasive two-photon microscopy.

Results: We found that rPWR/rCST distributions were similar between awake mice and humans, but changed in anesthetized mice, indicating a shift in the brain’s economic balance. Furthermore, changes in rPWR/rCST were linked to the reorganization of microscopic neural networks, observed with two-photon microscopy.

Discussion: Our work highlights the potential of rPWR/rCST for medical applications, and that neural network reorganization is linked to the brain’s economic balance.

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

Repository

Its files are read in the Code ↔ Paper reader above.

soltanianzadeh/STNeuroNet

License: Apache-2.0
State: the link answers, verified on 24 October 2026
Evidence: files inventoried
Commit: 6537096d8b2c05858320703418e2a3e2897be928, 12 September 2019
Languages: MATLAB (40), Python (17)
Size: 218 files, 57 scripts
Software Heritage: not archived
Found in: the end of the paper
Holds: README, license file, environment (environment.yml, Python Pkg/for_redistribution_files_only/Linux/setup.py, Python Pkg/for_redistribution_files_only/Windows10/setup.py)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: Image Processing Toolbox (22 files), NumPy (9 files), SciPy (6 files), TensorFlow (6 files), Signal Processing Toolbox (2 files), Statistics and Machine Learning Toolbox (2 files), Matplotlib (2 files), Optimization Toolbox (1 file)
Availability: 1 check, the latest on 24 October 2026: the link answers
  • 24 October 2026: the link answers
59 files
At the source: github.com/soltanianzadeh/STNeuroNet

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;
  • 57 scripts, each with its path and the digest of its content;
  • no match between paragraphs and code yet;
  • 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 statement

The original contributions presented in the study are included in the article/Supplementary material, further inquiries can be directed to the corresponding authors.

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

Recorded: type, language, journal, volume, pages, dates, 10 authors, 5 keywords, 73 references.

Cite

This paper

Wang, D., Li, H., Gao, J., Zeng, Y., Xu, M., Bo, B., Pei, M., Liang, Z., Zhou, N., & Thompson, G. J. (2026). Macroscopic cerebral energy efficiency corresponds to neuron reorganization in awake and anesthetized mice. Frontiers in neuroscience, 20, 1949911.

BibTeX

@article{wang2026macroscopic,
author = {Wang, Da and Li, Hui and Gao, Jinggui and Zeng, Yifan and Xu, Mengyang and Bo, Binshi and Pei, Mengchao and Liang, Zhifeng and Zhou, Ning and Thompson, Garth J.},
title = {{Macroscopic cerebral energy efficiency corresponds to neuron reorganization in awake and anesthetized mice}},
journal = {Frontiers in neuroscience},
year = {2026},
month = oct,
volume = {20},
pages = {1949911},
publisher = {Frontiers Media SA},
issn = {1662-4548},
pmcid = {PMC13690678}
}

RIS

TY - JOUR
AU - Wang, Da
AU - Li, Hui
AU - Gao, Jinggui
AU - Zeng, Yifan
AU - Xu, Mengyang
AU - Bo, Binshi
AU - Pei, Mengchao
AU - Liang, Zhifeng
AU - Zhou, Ning
AU - Thompson, Garth J.
TI - Macroscopic cerebral energy efficiency corresponds to neuron reorganization in awake and anesthetized mice
T2 - Frontiers in neuroscience
J2 - Front Neurosci
PY - 2026
DA - 2026/10/24
VL - 20
SP - 1949911
SN - 1662-4548
PB - Frontiers Media SA
LA - en
ER -

CSL-JSON

{
"id": "pmcid:PMC13690678",
"type": "article-journal",
"title": "Macroscopic cerebral energy efficiency corresponds to neuron reorganization in awake and anesthetized mice",
"container-title": "Frontiers in neuroscience",
"author": [
{
"family": "Wang",
"given": "Da"
},
{
"family": "Li",
"given": "Hui"
},
{
"family": "Gao",
"given": "Jinggui"
},
{
"family": "Zeng",
"given": "Yifan"
},
{
"family": "Xu",
"given": "Mengyang"
},
{
"family": "Bo",
"given": "Binshi"
},
{
"family": "Pei",
"given": "Mengchao"
},
{
"family": "Liang",
"given": "Zhifeng"
},
{
"family": "Zhou",
"given": "Ning"
},
{
"family": "Thompson",
"given": "Garth J."
}
],
"container-title-short": "Front Neurosci",
"volume": "20",
"page": "1949911",
"PMCID": "PMC13690678",
"ISSN": "1662-4548",
"publisher": "Frontiers Media SA",
"language": "en",
"issued": {
"date-parts": [
[
2026,
10,
24
]
]
}
}

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.1162/netn.a.28
Female 3xTg-AD mice demonstrate hyperexcitability phenotype of Alzheimer's disease in structure-function and function-behavior relationships.
Journal: Network neuroscience (Cambridge, Mass.)
In common: mouse, 9 references
[2] doi:10.1038/s41387-024-00343-w
Impaired brain glucose metabolism in glucagon-like peptide-1 receptor knockout mice.
Journal: Nutrition & diabetes
In common: fMRI, mouse, 8 references
[3] doi:10.1371/journal.pbio.3003619 [code]
Five energy metabolism pathways show distinct regional distributions and lifespan trajectories in the human brain.
Journal: PLoS biology
In common: Image Processing Toolbox, Statistics and Machine Learning Toolbox, SciPy, 2 other tools, 5 references
[4] doi:10.1038/s41593-025-02132-9 [code]
BOLD signal changes can oppose oxygen metabolism across the human cortex.
Journal: Nature neuroscience
In common: Optimization Toolbox, Image Processing Toolbox, SciPy, 2 other tools, fMRI, 3 references
[5] doi:10.1038/s41398-026-04025-2 [code]
Brain energetic landscapes shape state dysregulation in major depressive disorder: a morphological network controllability perspective.
Journal: Translational psychiatry
In common: Image Processing Toolbox, Statistics and Machine Learning Toolbox, SciPy, 2 other tools, 4 references
[6] doi:10.1162/imag.a.1060
The link to steady-state oxidative metabolism and hemodynamics varies across rs-fMRI metrics: A whole-brain assessment using macrovascular correction.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: fMRI, 6 references
[7] doi:10.1016/j.celrep.2024.114723
Spatiotemporal relationships between neuronal, metabolic, and hemodynamic signals in the awake and anesthetized mouse brain.
Journal: Cell reports
In common: fMRI, mouse, 6 references
[8] doi:10.1073/pnas.2527522123 [code]
Correspondence of large-scale functional brain network decline across aging mice and humans.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: Signal Processing Toolbox, Image Processing Toolbox, Statistics and Machine Learning Toolbox, 3 other tools, fMRI, mouse, 2 references
[9] doi:10.1162/imag.a.1092 [code]
The link between steady-state EEG and rs-fMRI metrics in healthy young adults: The effect of macrovascular correction.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Signal Processing Toolbox, fMRI, 5 references
[10] doi:10.1371/journal.pbio.3003277 [code]
Mapping cerebral blood perfusion and its links to multi-scale brain organization across the human lifespan.
Journal: PLoS biology
In common: Signal Processing Toolbox, Image Processing Toolbox, Statistics and Machine Learning Toolbox, 3 other tools, 2 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/repo/github.com/soltanianzadeh/stneuronet.svg)](https://openscicode.org/badge/repo/github.com/soltanianzadeh/stneuronet)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/repo/github.com/soltanianzadeh/stneuronet.svg
   :target: https://openscicode.org/badge/repo/github.com/soltanianzadeh/stneuronet
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/repo/github.com/soltanianzadeh/stneuronet"><img src="https://openscicode.org/badge/repo/github.com/soltanianzadeh/stneuronet.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.