OSCR

Transcranial direct current stimulation enhances delayed retention after 5 days of lower-limb motor skill learning.

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, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 346 lines · 16 KB · MIT

  1. # coding: utf-8
  2. #############################################################################################
  3. # The following code was based in the example available at
  4. # https://github.com/clade/PyDAQmx/blob/master/PyDAQmx/example/MultiChannelAnalogInput.py
  5. #############################################################################################
  7. __author__ = 'Joaquim Leitão'
  9. import PyDAQmx
  10. import numpy
  12. # Constants definition
  13. DAQMX_MIN_ACTUATION_V = 0.0
  14. DAQMX_MAX_ACTUATION_V = 5.0
  15. DAQMX_MIN_READER_V = -10.0
  16. DAQMX_MAX_READER_V = 10.0
  17. VAL_VOLTS = PyDAQmx.DAQmx_Val_Volts
  18. GROUP_BY_CHANNEL = PyDAQmx.DAQmx_Val_GroupByChannel
  19. GROUP_BY_SCAN_NUMBER = PyDAQmx.DAQmx_Val_GroupByScanNumber
  20. VAL_RISING = PyDAQmx.DAQmx_Val_Rising
  21. VAL_CONT_SAMPS = PyDAQmx.DAQmx_Val_ContSamps
  22. VAL_FINITE_SAMPS = PyDAQmx.DAQmx_Val_FiniteSamps
  23. VAL_RSE = PyDAQmx.DAQmx_Val_RSE
  24. VAL_ACQUIRED_INTO_BUFFER = PyDAQmx.DAQmx_Val_Acquired_Into_Buffer
  27. class Actuator():
  28. """
  29. Actuator class, responsible for actuating in a given channel of the NI-USB Data Acquisition Hardware
  30. """
  32. def __init__(self, physical_channels=["ao0"]):
  33. """
  34. Class Constructor
  35. :param physical_channels: A list of physical channels used to acquire the data
  36. """
  37. # Check for argument's type
  38. if not isinstance(physical_channels, list) and not isinstance(physical_channels, str):
  39. raise TypeError("Wrong type for argument channels_samples: Expected <class 'dict'> or <class 'str'> "
  40. "and found " + str(type(physical_channels)))
  42. # Get the set of physical channels from which we are going to extract the data and do the same for the names of
  43. # the channels
  44. self.physical_channels = self.__parse(physical_channels)
  46. if self.physical_channels is None:
  47. raise TypeError("Non-output channels specified to be used in the Actuator class. Only output channels are "
  48. "allowed")
  50. # Create tasks, one for each physical channel
  51. tasks = []
  52. for i in range(len(self.physical_channels)):
  53. channel = self.physical_channels[i]
  54. task = PyDAQmx.Task()
  55. tasks.append(task)
  56. # Create Voltage Channel to read from the given physical channel
  57. task.CreateAOVoltageChan("Dev1/" + str(channel), "", DAQMX_MIN_ACTUATION_V, DAQMX_MAX_ACTUATION_V,
  58. VAL_VOLTS, None) # Create Voltage Channel
  59. # Save all the tasks
  60. self.tasks = dict([(self.physical_channels[i], tasks[i]) for i in range(len(tasks))])
  62. @staticmethod
  63. def __parse(data):
  64. """
  65. Private Method that parses a list or a string containing either a set of physical_channels or a set of channel's
  66. names into a list
  67. :param data: The mentioned list or string
  68. :return: The parsed data in the list format, or None if wrong or invalid data is provided
  69. """
  70. if isinstance(data, str):
  71. current_data = [data]
  72. else:
  73. current_data = data
  75. # Remove duplicates
  76. current_data = list(set(current_data))
  78. # Check if all the channels are output channels
  79. for current_channel in current_data:
  80. if "ao" not in current_channel:
  81. return None
  82. return current_data
  84. def execute_all_tasks(self, num_samps_channel, message, auto_start=1, timeout=0):
  85. """
  86. Executes all the tasks created. Ideally this should be use to send the same message to a set of actuators
  87. :param num_samps_channel: The number of samples, per channel, to write
  88. :param message: The message to send to the actuator
  89. :param auto_start: Specifies whether or not this function automatically starts the task if you do not start it.
  90. :param timeout:The amount of time, in seconds, to wait for this function to write all the samples
  91. (-1 for inifinite)
  92. :return: A boolean value: True is all the tasks started without major problems; False otherwise
  93. """
  94. for name in self.physical_channels:
  95. result = self.execute_task(name, num_samps_channel, message, auto_start, timeout)
  96. if not result:
  97. return False
  98. return True
  100. def execute_task(self, name, num_samps_channel, message, auto_start=1, timeout=0):
  101. """
  102. Executes a given task, starting its actuation (That is, sends a given message to a given actuator)
  103. :param name: The name of the task to execute
  104. :param num_samps_channel: The number of samples, per channel, to write
  105. :param message: The message to send to the actuator
  106. :param auto_start: Specifies whether or not this function automatically starts the task if you do not start it.
  107. :param timeout: The amount of time, in seconds, to wait for this function to write all the samples
  108. (-1 for inifinite)
  109. :return: A boolean value, indicating the success or failure of the execution
  110. """
  111. # TODO: CHANGE "name" TO BE A LIST: FUNCTION SHOULD ALSO CHANGE NAME
  113. if not (isinstance(message, int) or isinstance(message, float)):
  114. raise TypeError("Wrong message type for the task to be executed in channel " + str(name) + ". Message should "
  115. "be an interger or float between 0 and 5")
  116. message = float(message)
  118. # Message has to be a numpy array, so lets convert it to the desired data type
  119. message = numpy.array(message)
  121. # Check for the limits of the message
  122. message[message > DAQMX_MAX_ACTUATION_V] = DAQMX_MAX_ACTUATION_V
  123. message[message < DAQMX_MIN_ACTUATION_V] = DAQMX_MIN_ACTUATION_V
  125. if name in self.tasks.keys():
  126. # Get the task
  127. task = self.tasks[name]
  128. # Start the task
  129. task.StartTask()
  130. # Write to buffer
  131. task.WriteAnalogF64(num_samps_channel, auto_start, timeout, GROUP_BY_CHANNEL, message, None,
  132. None)
  133. task.StopTask()
  134. return True
  135. return False
  138. class Reader():
  139. """
  140. Reader class, responsible for collecting data from the NI-USB Data Acquisition Hardware
  141. """
  143. def __init__(self, channels_samples={"ai0": 1}):
  144. """
  145. Class Constructor
  146. :param channels_samples: A dictionary with a mapping between the physical channels used to acquire the data and
  147. the number of samples to collect from each one of them
  148. """
  149. # Check for argument's type
  150. if not isinstance(channels_samples, dict):
  151. raise TypeError("Wrong type for argument channels_samples: Expected <class 'dict'> and found " +
  152. str(type(channels_samples)))
  154. # Get the set of physical channels from which we are going to extract the data and do the same for the names of
  155. # the channels
  156. self.physical_channels = self.__parse(channels_samples)
  157. self.n_samples = []
  159. tasks = []
  160. for channel in self.physical_channels:
  161. current_samples = channels_samples[channel]
  162. # current_samples should be an integer higher than 0. If it is not, assume the default value: 1
  163. if current_samples <= 0:
  164. current_samples = 1
  165. # Store the number of samples to read from that channel
  166. self.n_samples.append(current_samples)
  167. # Create the tasks, one to read in each channel
  168. task = PyDAQmx.Task()
  169. # Create Voltage Channel to read from the given physical channel
  170. task.CreateAIVoltageChan("Dev1/" + str(channel), "", VAL_RSE, DAQMX_MIN_READER_V, DAQMX_MAX_READER_V, VAL_VOLTS,
  171. None)
  172. # Set the source of the sample clock - Acquire infinite number of samples and enabling to read the maximum
  173. # number of samples per second: 10000.0
  174. task.CfgSampClkTiming("", 1000.0, VAL_RISING, VAL_CONT_SAMPS, current_samples)
  175. # Add the task to the list of tasks
  176. tasks.append(task)
  177. # Save all the tasks
  178. self.tasks = dict([(self.physical_channels[i], tasks[i]) for i in range(len(tasks))])
  180. @staticmethod
  181. def __parse(channels_samples):
  182. """
  183. Private Method that parses a dictionary with a mapping between the physical channels used to acquire the data and
  184. the number of samples to collect from each one of them, returning a list with the keys of the dictionary (the physical
  185. channels to be used), or raises an exception if anything went wrong
  186. :param channels_samples: The mentioned dictionary
  187. :return: A list with the physical channels to be used
  188. """
  190. # Get keys and values of the dictionary
  191. keys = list(channels_samples.keys())
  192. values = list(channels_samples.values())
  194. # Check if all the channels are output channels
  195. for current_channel in keys:
  196. if "ai" not in current_channel:
  197. raise TypeError("Non-input channels specified to be used in the Reader class. Only input channels are "
  198. "allowed")
  200. for current_samples in values:
  201. if not isinstance(current_samples, int):
  202. raise TypeError("Invalid argument for the 'channels_samples' parameter. Expected dictionary with keys of type "
  203. "<class 'str'> and values type <class 'int'>")
  205. return keys
  207. def start_tasks(self):
  208. for current in self.tasks.keys():
  209. task = self.tasks[current]
  210. task.StartTask()
  212. def change_collected_samples(self, channel, number_samples):
  213. """
  214. Changes the number of samples collected in the specified physical channel
  215. :param channel: The desired physical channel
  216. :param number_samples: The new number of samples to collect
  217. """
  219. if not isinstance(number_samples, int):
  220. raise TypeError("Wrong type for parameter 'number_samples'. Expected <class 'int'> and found "
  221. + str(type(number_samples)))
  222. elif number_samples <= 0:
  223. # Invalid number of samples -- Simply return false
  224. return False
  225. elif channel in self.physical_channels:
  226. # Create a new task for the given channel that is going to
  227. task = PyDAQmx.Task()
  228. task.CreateAIVoltageChan("Dev1/" + str(channel), "", VAL_RSE, DAQMX_MIN_READER_V, DAQMX_MAX_READER_V,
  229. VAL_VOLTS, None)
  230. # Set the source of the sample clock - Acquire infinite number of samples and enabling to read the maximum
  231. # number of samples per second: 10000.0
  232. task.CfgSampClkTiming("", 10000.0, VAL_RISING, VAL_CONT_SAMPS, number_samples)
  233. self.tasks[channel] = task
  235. index = self.physical_channels.index(channel)
  236. self.n_samples[index] = number_samples
  238. return True
  239. else:
  240. raise TypeError("Attempt to change number of collected samples from a physical channel not already added")
  242. def add_tasks(self, channel_samples):
  243. """
  244. Adds a task to the set of tasks
  245. :param channel_samples: A dictionary with a mapping between the physical channels used to acquire the data and
  246. the number of samples to collect from each one of them
  247. """
  248. # Check for argument's type
  249. if not isinstance(channel_samples, dict):
  250. raise TypeError("Wrong type for argument channels_samples: Expected <class 'dict'> and found " +
  251. str(type(channel_samples)))
  253. # Get the list of channels
  254. physical_channels = self.__parse(channel_samples)
  256. if physical_channels is None:
  257. raise TypeError("Non-input channels specified to be used in the Reader class. Only input channels are "
  258. "allowed")
  260. for channel in physical_channels:
  261. current_samples = channel_samples[channel]
  262. # Update the list of physical channels
  263. self.physical_channels.append(channel)
  264. # Store the number of samples to collect for each of the given channels
  265. self.n_samples.append(current_samples)
  266. # Create a task and the voltage channel and store it
  267. task = PyDAQmx.Task()
  268. task.CreateAIVoltageChan("Dev1/" + str(channel), "", VAL_RSE, DAQMX_MIN_READER_V, DAQMX_MAX_READER_V,
  269. VAL_VOLTS, None)
  270. # Set the source of the sample clock - Acquire infinite number of samples and enabling to read the maximum
  271. # number of samples per second: 10000.0
  272. task.CfgSampClkTiming("", 10000.0, VAL_RISING, VAL_CONT_SAMPS, current_samples)
  273. self.tasks[channel] = task
  275. def remove_task(self, physical_channel):
  276. """
  277. Removes a given Task from the set of active Tasks
  278. :param physical_channel: The task to remove
  279. :return: True in case of success, otherwise returns False
  280. """
  281. # Check if the given physical channel is in the list of physical channels
  282. if physical_channel in self.physical_channels:
  283. # Get the index of the given physical channel in the list of physical channels
  284. index = self.physical_channels.index(physical_channel)
  285. # Remove the element from the list of physical channels
  286. self.physical_channels.remove(physical_channel)
  287. # Remove the number of samples associated with the given channel
  288. self.n_samples.remove(self.n_samples[index])
  290. # Remove the task
  291. del self.tasks[physical_channel]
  293. return True
  295. def read_all(self, timeout=0.01, num_samples=None):
  296. """
  297. Reads data from all the active physical channels
  298. :param timeout: The amount of time, in seconds, to wait for the function to read the sample(s)
  299. (-1 for infinite)
  300. :param num_samples: A list with the number of samples to acquire for each channel
  301. :return: Returns a dictionary with the data read from all the active physical channels
  302. """
  304. if num_samples is None:
  305. return dict([(name, self.read(name, timeout)) for name in self.physical_channels])
  306. elif not isinstance(num_samples, dict):
  307. raise TypeError("Wrong type for argument num_samples: Expected <class 'dict'> and found " +
  308. str(type(num_samples)))
  310. contents = {}
  311. for name in self.physical_channels:
  312. current_number_samples = num_samples[name]
  313. contents[name] = self.read(name, timeout, current_number_samples)
  314. return contents
  316. def read(self, name=None, timeout=0.01, num_samples=None):
  317. """
  318. Reads data from a given physical channel
  319. :param name: The name of the channel from which we are going to read the data
  320. :param timeout: The amount of time, in seconds, to wait for the function to read the sample(s)
  321. (-1 for infinite)
  322. :param num_samples: The number of samples to acquire
  323. :return: Returns an array with the data read
  324. """
  325. if name is None:
  326. name = self.physical_channels[0]
  327. if num_samples is None:
  328. index = self.physical_channels.index(name)
  329. num_samps_channel = self.n_samples[index]
  330. else:
  331. num_samps_channel = num_samples
  333. # Get task handle
  334. task = self.tasks[name]
  335. # Prepare the data to be read
  336. data = numpy.zeros((num_samps_channel,), dtype=numpy.float64)
  337. read = PyDAQmx.int32()
  338. # Start the task
  339. task.StartTask()
  340. # Read the data and return it!
  341. task.ReadAnalogF64(num_samps_channel, timeout, GROUP_BY_CHANNEL, data, num_samps_channel,
  342. PyDAQmx.byref(read), None)
  343. # Stop the task
  344. task.StopTask()
  345. # Return in a list instead of numpy.array
  346. return data.tolist()

daqmxlib.py at commit fda7e1f, under MIT · at the source

Overview

Authors: August Lomholt Kvistad1, Lasse Jespersen1, Jonas Rud Bjørndal1, Lasse Christiansen2,3, Anke Ninija Karabanov1, Jesper Lundbye‐Jensen1
ORCID iDs: August Lomholt Kvistad, Lasse Jespersen, Jonas Rud Bjørndal, Lasse Christiansen, Anke Ninija Karabanov, Jesper Lundbye‐Jensen
  1. Movement & Neuroscience, Department of Nutrition, Exercise and Sports University of Copenhagen Copenhagen Denmark
  2. Danish Research Centre for Magnetic Resonance, Department of Radiology and Nuclear Medicine Copenhagen University Hospital – Amager and Hvidovre Copenhagen Denmark
  3. Department of Neuroscience University of Copenhagen Copenhagen Denmark
Institutions: University of Copenhagen (Denmark); Amager Hospital (Denmark); Copenhagen University Hospital (Denmark)
Journal: The Journal of physiology, volume 604, issue 17, pages 7375-7399
Dates: received 20 February 2026; accepted 24 June 2026; published online 25 July 2026; in print 1 September 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1113/jp291217 · PMID 42501065 · PMCID PMC13532859 · OpenAlex W7171093061
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: other (modality), human (organism)
Methods: Spectral & time-frequency, Machine learning, Preprocessing, Evoked potentials, Statistics, fMRI & imaging, Physiology & signal measures
Keywords: Bayesian analysis, motor skill learning, tDCS, transcranial electric stimulation
MeSH: Learning*, Lower Extremity*, Motor Cortex*, Motor Skills*, Transcranial Direct Current Stimulation*, Adult, Evoked Potentials, Motor, Female, Humans, Male, Young Adult (* major topic)
Journal subjects: Neuroscience
Topic: Transcranial Magnetic Stimulation Studies (Neurology, Neuroscience), according to OpenAlex
Funding: Team Danmark; Novo Nordisk Fonden (NNF.22SA0078293); Lundbeck Foundation (R336–2020–1035, R436‐2023–1137)
Citations: not cited yet (Europe PMC); 103 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.

MovementAndNeuroscience/TrackIt-LiteV2

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: fda7e1ff0fd1425a45b624f40e7c4b11b489f136, 24 July 2025
Languages: Python (71), JavaScript (18)
Size: 579 files, 89 scripts
Software Heritage: not archived
Found in: the text, “Sequential visuomotor dynamic ankle flexion task”
Holds: README, license file, documentation
Not found: CITATION.cff, environment file, tests, continuous integration
Tools: NumPy (32 files), Pillow (7 files), Matplotlib (4 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
91 files
At the source: github.com/MovementAndNeuroscience/TrackIt-LiteV2

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;
  • 89 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

Datasets cited

Code and data availability statement

The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1113/jp291217.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 2, 28 September 2026

  • Publisher: n/a → Wiley

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 6 authors, 4 keywords, 11 MeSH terms, 3 funders, 93 references.

Cite

This paper

Kvistad, A. L., Jespersen, L., Bjørndal, J. R., Christiansen, L., Karabanov, A. N., & Lundbye‐Jensen, J. (2026). Transcranial direct current stimulation enhances delayed retention after 5 days of lower-limb motor skill learning. The Journal of physiology, 604(17), 7375-7399. https://doi.org/10.1113/jp291217

BibTeX

@article{kvistad2026transcranial,
author = {Kvistad, August Lomholt and Jespersen, Lasse and Bjørndal, Jonas Rud and Christiansen, Lasse and Karabanov, Anke Ninija and Lundbye‐Jensen, Jesper},
title = {{Transcranial direct current stimulation enhances delayed retention after 5 days of lower-limb motor skill learning}},
journal = {The Journal of physiology},
year = {2026},
month = jul,
volume = {604},
number = {17},
pages = {7375--7399},
publisher = {Wiley},
issn = {0022-3751},
doi = {10.1113/jp291217},
url = {https://doi.org/10.1113/jp291217},
pmid = {42501065},
pmcid = {PMC13532859}
}

RIS

TY - JOUR
AU - Kvistad, August Lomholt
AU - Jespersen, Lasse
AU - Bjørndal, Jonas Rud
AU - Christiansen, Lasse
AU - Karabanov, Anke Ninija
AU - Lundbye‐Jensen, Jesper
TI - Transcranial direct current stimulation enhances delayed retention after 5 days of lower-limb motor skill learning
T2 - The Journal of physiology
J2 - J Physiol
PY - 2026
DA - 2026/07/25
VL - 604
IS - 17
SP - 7375
EP - 7399
SN - 0022-3751
PB - Wiley
DO - 10.1113/jp291217
UR - https://doi.org/10.1113/jp291217
LA - en
ER -

CSL-JSON

{
"id": "10.1113/jp291217",
"type": "article-journal",
"title": "Transcranial direct current stimulation enhances delayed retention after 5 days of lower-limb motor skill learning",
"container-title": "The Journal of physiology",
"author": [
{
"family": "Kvistad",
"given": "August Lomholt"
},
{
"family": "Jespersen",
"given": "Lasse"
},
{
"family": "Bjørndal",
"given": "Jonas Rud"
},
{
"family": "Christiansen",
"given": "Lasse"
},
{
"family": "Karabanov",
"given": "Anke Ninija"
},
{
"family": "Lundbye‐Jensen",
"given": "Jesper"
}
],
"container-title-short": "J Physiol",
"volume": "604",
"issue": "17",
"page": "7375-7399",
"DOI": "10.1113/jp291217",
"PMID": "42501065",
"PMCID": "PMC13532859",
"ISSN": "0022-3751",
"publisher": "Wiley",
"URL": "https://doi.org/10.1113/jp291217",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
25
]
]
}
}

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.3390/bioengineering13050502 [code]
Effects of Transcranial Direct Current Stimulation over the Left Sensorimotor Cortex on Bimanual Force Control: A Computational and Experimental Investigation.
Journal: Bioengineering (Basel, Switzerland)
In common: Matplotlib, NumPy, other, 3 references
[2] doi:10.7554/elife.111876 [code]
Distinct sensorimotor encoding in tuft dendrites and somata associated with action, correction, and learning.
Journal: eLife
In common: Pillow, Matplotlib, NumPy, 2 references
[3] doi:10.1038/s41598-026-45549-3
Effects of single-session anodal transcranial direct current stimulation (tDCS) on cognitive and motor performance in athletes and healthy adults: a systematic review and meta-analysis.
Journal: Scientific reports
In common: other, 3 references
[4] doi:10.1038/s41467-026-74869-1 [code]
Complementary roles of cell-type-specific plasticity in shaping neocortical dynamics for learning action timing.
Journal: Nature communications
In common: 3 references
[5] doi:10.1038/s43856-026-01595-6 [code]
Non-vectorial integration of intersectional short-pulse stimulation enables enhanced deep brain modulation and effective seizure control.
Journal: Communications medicine
In common: 3 references
[6] doi:10.1016/j.celrep.2026.117419 [code]
Conserved role of primary motor cortex in the control of prehension in mice and macaques.
Journal: Cell reports
In common: Matplotlib, NumPy, 2 references
[7] doi:10.1038/s41593-026-02362-5 [code]
Replay of procedural memory is independent of the hippocampus.
Journal: Nature neuroscience
In common: Pillow, Matplotlib, NumPy, 1 reference
[8] doi:10.1016/j.isci.2026.116705 [code]
Spatiotemporal characteristics of visual cortical responses to transpalpebral electrical stimulation.
Journal: iScience
In common: Pillow, Matplotlib, NumPy, 1 reference
[9] doi:10.1016/j.isci.2026.116498 [code]
The Tower Foraging Park: A paradigm for studying cognitive and motor processes underlying behavioral flexibility in freely moving mice.
Journal: iScience
In common: Pillow, Matplotlib, NumPy, 1 reference
[10] doi:10.3390/bioengineering13070773 [code]
From API to Action: A Multi-Model Comparison of OpenAI, Anthropic, Google, and Meta LLMs for Clinical Trial Data Extraction.
Journal: Bioengineering (Basel, Switzerland)
In common: Matplotlib, NumPy, other, 1 reference

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

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