OSCR

Spatial-Jitter Model for Magnetoencephalography Sensor Arrays.

Code ↔ Paper

6 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 6 matches
  1. [1] § Methods › Realistic Geometry ↔ functions.py, lines 345–379 · score 0.67 · dense spherical sensor, inner product, VSH coefficients
  2. [2] § Methods › Realistic Geometry ↔ BEM_analysis_MeasCov.py, lines 112–181 · score 0.63 · source amplitudes, noise models, white noise, covariance, Simulations, sensor
  3. [3] § Methods › Spherical Conductor ↔ functions.py, lines 117–148 · score 0.62 · uniform distribution, half sphere, drawn, inside, radius
  4. [4] § Methods › Spherical Conductor ↔ functions.py, lines 345–379 · score 0.61 · inner product, VSH coefficients, sensor positions, magnetic field, quadrature, sphere
  5. [5] § Results › Realistic Geometry ↔ BEM_analysis_MeasCov.py, lines 112–181 · score 0.60 · covariance model, source amplitude, noise model, simulation, SNR, sensor
  6. [6] § Methods › Spherical Conductor ↔ source_depth.py, lines 30–75 · score 0.54 · Lebedev quadrature, spherical conductor, scalp measurements, spatial jitter, sphere, VSH

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 · 457 lines · 9.7 KB · MIT · 3 matches

  1. import numpy as np
  3. #Functions that are shared across the scripts used in the spatial-jitter simulations
  6. def BSph(r, rq, Q):
  7. """
  8. Calculate magnetic field due to a current dipole in a spherical conductor.
  9. Sarvas' formula is used'
  11. Parameters
  12. ----------
  13. r: array (1, 3)
  14. the position where the field is calculated
  15. rq: array (1, 3)
  16. the position of the dipole
  17. Q: array (1, 3)
  18. the dipole monent of the current dipole
  20. Returns
  21. -------
  23. B: array (1, 3)
  26. """
  28. mu04pi = 1e-7
  29. a = r-rq
  30. rn = np.linalg.norm(r)
  31. an = np.linalg.norm(a)
  33. F = an*(rn*an + rn**2 - np.dot(rq,r))
  34. nF1 = ((1/rn)*an**2 + (1/an)*np.dot(a,r) + 2*an + 2*rn)*r
  35. nF2 = -(an+ 2*rn + 1/an*np.dot(a,r))*rq
  37. nF = nF1+nF2
  38. B = mu04pi*(F*np.cross(Q,rq) - (np.dot(np.cross(Q,rq),r)*(nF)))/(F**2)
  40. return B
  42. def spectra(coefs, lmax):
  43. """
  44. Calculate the energy-spectral density from the VSH coefficients
  46. Parameters
  47. ----------
  48. coefs: array (Ncoefs)
  49. the VSH coefficients
  50. lmax: integer
  51. the maximum l-degree
  53. Returns
  54. -------
  56. s: array (lmax, 1)
  59. """
  61. s = np.zeros(lmax)
  63. lind = 0
  64. for l in range(1,lmax+1):
  65. temp = 0
  66. for m in range(-1*l,l+1):
  67. c = coefs[lind]
  68. temp += c**2
  69. lind += 1
  70. s[l-1] = temp
  72. return s
  74. def Bdim(r, n, t1, t2, rq, Q, dim):
  75. """
  76. Calculate the sensor output to a current dipole in a spherical conductor.
  77. Assumes rectangular sensor. Uses Sarvas' formula. Outputs the 3D magnetic field vector.
  79. Parameters
  80. ----------
  81. r: array (1,3)
  82. the position of the sensor
  83. n: array (1,3)
  84. the normal vector of the sensor
  85. t1: array (1,3)
  86. the first tangential vector of the sensor
  87. t2: array (1,3)
  88. the second tangential vector of the sensor
  89. rq: array (1,3)
  90. the position of the dipole
  91. Q: array (1,3)
  92. the dipole monent of the current dipole
  93. dim: float
  94. the sidelength of the sensor rectangle
  97. Returns
  98. -------
  100. res: array (1, 3)
  103. """
  105. ropm = np.zeros((4,3))
  106. ropm[0] = r + dim/4*t1 + dim/4*t2
  107. ropm[1] = r + dim/4*t1 - dim/4*t2
  108. ropm[2] = r - dim/4*t1 + dim/4*t2
  109. ropm[3] = r - dim/4*t1 - dim/4*t2
  110. res = np.zeros((1,3))
  111. for i in range(4):
  112. res += BSph(ropm[i], rq, Q)
  113. res /= 4
  115. return res
  117. def GetRandomPointsInAsphere(dim,N):
  118. """
  119. Get uniform-distributed random points inside a half sphere (z>0).
  121. Parameters
  122. ----------
  123. dim: float
  124. the radius of the half sphere
  125. N: integer
  126. the number of random points to be produced
  128. Returns
  129. -------
  131. xr: array (N, 1)
  132. yr: array (N, 1)
  133. zr: array (N, 1)
  135. """
  137. u = np.random.rand(N)
  138. rr = dim*np.cbrt(u)
  140. thetar = 2*np.pi*np.random.rand(N)
  142. phir = np.arccos(np.random.rand(N)) #random number drawn from [0,1] to produce points in the half sphere
  144. xr = rr*np.cos(thetar)*np.sin(phir)
  145. yr = rr*np.sin(thetar)*np.sin(phir)
  146. zr = rr*np.cos(phir)
  148. return xr, yr, zr
  150. def GetRandomPointsInACircle(dim,N):
  151. """
  152. Get uniform-distributed random points inside a circle.
  154. Parameters
  155. ----------
  156. dim: float
  157. the radius of the circle
  158. N: integer
  159. the number of random points to be produced
  161. Returns
  162. -------
  164. x: array (N, 1)
  165. y: array (N, 1)
  167. """
  169. u = np.random.rand(N)
  170. r = dim*np.sqrt(u)
  172. theta = 2*np.pi*np.random.rand(N)
  174. x = r*np.cos(theta)
  175. y = r*np.sin(theta)
  178. return x, y
  180. def jitpos_tang(r,dim,t1,t2):
  181. """
  182. Add tangential spatial jitter to the sensor positions.
  184. Parameters
  185. ----------
  186. r: array (N,3)
  187. the sensor positions
  188. dim: float
  189. the amount of spatial jitter to be added
  190. t1: array (N,3)
  191. the first tangential vectors of the sensors
  192. t2: array (N,3)
  193. the second tangential vectors of the sensors
  195. Returns
  196. -------
  198. r_ret: array (N, 3)
  201. """
  203. N = r.shape[0]
  204. x, y = GetRandomPointsInACircle(dim,N)
  207. r_ret = r + x[:,None]*t1 + y[:,None]*t2
  209. return r_ret
  211. def jitpos_normal(r,dim,n):
  212. """
  213. Add normal/radial spatial jitter to the sensor positions.
  215. Parameters
  216. ----------
  217. r: array (N,3)
  218. the sensor positions
  219. dim: float
  220. the amount of spatial jitter to be added
  221. n: array (N,3)
  222. the normal vectors of the sensors
  225. Returns
  226. -------
  228. r_ret: array (N, 3)
  230. """
  232. N = r.shape[0]
  234. z = np.random.rand(N)*dim
  236. r_ret = r + z[:,None]*n
  238. return r_ret
  240. def jitpos_3D(r,dim,t1,t2,n):
  241. """
  242. Add 3D spatial jitter to the sensor positions.
  244. Parameters
  245. ----------
  246. r: array (N,3)
  247. the sensor positions
  248. dim: float
  249. the amount of spatial jitter to be added
  250. n: array (N,3)
  251. the normal vectors of the sensors
  252. t1: array (N,3)
  253. the first tangential vectors of the sensors
  254. t2: array (N,3)
  255. the second tangential vectors of the sensors
  257. Returns
  258. -------
  260. r_ret: array (N, 3)
  262. """
  264. N = r.shape[0]
  266. x, y, z = GetRandomPointsInAsphere(dim,N)
  268. r_ret = r + x[:,None]*t1 + y[:,None]*t2+ z[:,None]*n
  270. return r_ret
  273. def jitori(theta):
  274. """
  275. Add orientation jitter to the sensor orientations.
  276. Each of the sensor axes is rotated by theta to a random direction.
  278. Parameters
  279. ----------
  280. theta: float
  281. the amount (in radians) how much the sensor axes are perturbed
  283. Returns
  284. -------
  286. ret: array (3, 3)
  287. rotation matrix that perturbs the sensor directions
  290. """
  292. #X-axis
  293. phi =np.random.rand()*2*np.pi
  294. u = np.zeros((1,3))
  295. u[0] = np.array((0, -1*np.sin(phi), np.cos(phi)))
  297. uxu = u.T@u
  298. ux = np.array(((0, -1*u[0,2], u[0,1]), (u[0,2],0, -1*u[0,0]), (-1*u[0,1], u[0,0], 0)))
  300. th = np.random.rand()*theta
  302. R = np.cos(th)*np.eye((3)) + np.sin(th)*ux + (1-np.cos(th))*uxu
  303. x = np.zeros((3,1))
  304. x[0] = 1
  305. new_x = R@x
  307. #Y-axis
  308. phi =np.random.rand()*2*np.pi
  309. u = np.zeros((1,3))
  310. u[0] = np.array((np.sin(phi), 0, -1*np.cos(phi)))
  312. uxu = u.T@u
  313. ux = np.array(((0, -1*u[0,2], u[0,1]), (u[0,2],0, -1*u[0,0]), (-1*u[0,1], u[0,0], 0)))
  315. th = np.random.rand()*theta
  317. R = np.cos(th)*np.eye((3)) + np.sin(th)*ux + (1-np.cos(th))*uxu
  318. y = np.zeros((3,1))
  319. y[1] = 1
  320. new_y= R@y
  322. #z-axis
  323. phi =np.random.rand()*2*np.pi
  324. u = np.zeros((1,3))
  325. u[0] = np.array((-1*np.sin(phi), np.cos(phi),0))
  327. uxu = u.T@u
  328. ux = np.array(((0, -1*u[0,2], u[0,1]), (u[0,2],0, -1*u[0,0]), (-1*u[0,1], u[0,0], 0)))
  330. th = np.random.rand()*theta
  332. R = np.cos(th)*np.eye((3)) + np.sin(th)*ux + (1-np.cos(th))*uxu
  333. z = np.zeros((3,1))
  334. z[2] = 1
  335. new_z= R@z
  337. ret = np.zeros((3,3))
  338. ret[0] = new_x.T
  339. ret[1] = new_y.T
  340. ret[2] = new_z.T
  342. return ret
  345. def CalculateCoefs(b,V,Rm,Rs,w,lvalues):
  346. """
  347. Calculate VSH coefficients according to the inner product formula.
  348. Only works for dense spherical sensor arrays defined at quadrature points for integrating over a sphere.
  349. Please check the manuscript.
  351. Parameters
  352. ----------
  353. b: array (Nx3)
  354. the magnetic field at the sensor positions
  355. V: array (Nx3xNc)
  356. Nc VSH basis functions normalized to unit energy
  357. Rm: float
  358. the radius of the sphere where the sensor array is
  359. Rs: float
  360. the radius of the sphere of the VSH expansion
  361. w: array (N)
  362. the quadrature weights at the sensor positions
  363. lvalues: array (Nc)
  364. the values of l-degrees at each index
  366. Returns
  367. -------
  369. coeffs: array (Nc, 1)
  371. """
  373. Nc = V.shape[2]
  374. mu0 = 1e-7 * 4 * np.pi
  375. coeffs = np.zeros((Nc))
  376. for i in range(Nc):
  377. dotp = np.sum(w*np.sum(b * V[:,:,i], axis=1))
  378. coeffs[i] = - Rm**(2*lvalues[i]+4)*dotp/(mu0*(2*lvalues[i]+1)*Rs**(2*lvalues[i]+1))
  379. return coeffs
  384. def rand_rotation_matrix(angle):
  385. """
  386. Generate a random rotation matrix. The matrix rotates a vector to a random direction by an angle.
  388. Parameters
  389. ----------
  390. angle: float
  391. rotation angle in radians
  393. Returns
  394. -------
  396. R: array (3, 3)
  398. """
  400. x1 = np.random.rand()
  401. x2 = np.random.rand()
  403. theta = np.arccos(2*x1-1)
  404. phi= 2*np.pi*x2
  406. v = np.array((np.sin(theta)*np.cos(phi), np.sin(theta)*np.sin(phi),np.cos(theta)))
  409. cn= 1-np.cos(angle)
  410. c = np.cos(angle)
  411. s = np.sin(angle)
  413. R = np.zeros((3,3))
  415. R[0,0] = v[0]**2*cn+c
  417. R[0,1] = v[0]*v[1]*cn-v[2]*s
  419. R[0,2] = v[0]*v[2]*cn+v[1]*s
  421. R[1,0] = v[0]*v[1]*cn+v[2]*s
  422. R[1,1] = v[1]**2*cn+c
  423. R[1,2] = v[1]*v[2]*cn-v[0]*s
  425. R[2,0] = v[0]*v[2]*cn-v[1]*s
  426. R[2,1] = v[1]*v[2]*cn+v[0]*s
  427. R[2,2] = v[2]**2*cn+c
  429. return R
  432. def rand_translation(dist):
  433. """
  434. Generate a random translation vector. Translates a vector to random direction by a some distance.
  436. Parameters
  437. ----------
  438. dist: float
  439. translation distance
  441. Returns
  442. -------
  444. v: array (1, 3)
  446. """
  448. x1 = np.random.rand()
  449. x2 = np.random.rand()
  451. theta = np.arccos(2*x1-1)
  452. phi= 2*np.pi*x2
  454. v = np.array((np.sin(theta)*np.cos(phi), np.sin(theta)*np.sin(phi),np.cos(theta)))*dist
  456. return v

functions.py at commit 3ec835c, under MIT · at the source

Overview

Authors: Joonas Iivanainen1
ORCID iDs: Joonas Iivanainen
  1. Department of Neuroscience and Biomedical Engineering, Aalto University, 02150 Espoo, Finland
Institutions: Aalto University (Finland)
Journal: IEEE transactions on medical imaging, volume 45, issue 7, pages 3908-3921
Dates: published online July 2026; in print July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1109/tmi.2026.3687982 · PMID 42043988 · PMCID PMC13503295 · OpenAlex W7155916499
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: MEG (modality), human (organism)
Methods: Preprocessing
Keywords: Magnetoencephalography, optically pumped magnetometer, SQUID, position error, jitter, magnetic field
MeSH: Magnetoencephalography*, Models, Neurological*, Signal Processing, Computer-Assisted*, Algorithms, Brain, Computer Simulation, Humans, Signal-To-Noise Ratio (* major topic)
Topic: Atomic and Subatomic Physics Research (Atomic and Molecular Physics, and Optics, Physics and Astronomy), according to OpenAlex
Funding: Research Council of Finland (368388); Jenny ja Antti Wihurin Rahasto (00240096); Instrumentariumin Tiedesäätiö (250008); NINDS NIH HHS (R01 NS104585); National Institute of Neurological Disorders and Stroke of the National Institutes of Health (R01NS104585)
Citations: cited by 2 papers (Europe PMC); 46 references in the paper

Abstract

Sampling jitter, i.e., random deviations in the time instants when samples are taken, causes frequency-dependent noise that reduces signal-to-noise ratio (SNR). This paper generalizes the concept of jitter to magnetoencephalography (MEG) sensor arrays that spatially sample the quasistatic magnetic field due to brain activity. It is shown that spatial jitter, i.e., random deviations in MEG sensor positions, causes spatial-frequency-dependent noise in the vector spherical harmonics domain that reduces the attainable SNR and spatial resolution in MEG. Similarly, the paper also considers noise due to random sensor orientation errors (‘orientation jitter’) and errors due to field integration by the finite-sized sensors (‘aperture error’). The analysis in this paper shows that on-scalp MEG measurements taken closer to the head are more resistant to spatial and orientation jitter at high spatial frequencies than off-scalp measurements taken further away. On the other hand, on-scalp measurements are affected more by aperture errors than off-scalp measurements. The paper also provides new insights to the effect of sensor noise on the spatial resolution of on- and off-scalp sensor arrays using a novel normalization of the vector spherical harmonics. The paper also simulates spatial-jitter phenomena with realistic sensor arrays based on optically pumped magnetometers and superconducting quantum interference device sensors. This realistic simulation shows that spatial jitter reduces SNR and affects how the measurements should be regularized in order to maximize SNR.

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

Repository

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

jiivana/SpatialJitter

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 3ec835c01f790e5a01659f8dad5846f0bfa3e11b, 31 March 2026
Languages: Python (13)
Size: 23 files, 13 scripts
Software Heritage: not archived
Found in: the acknowledgements
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (12 files), Matplotlib (9 files), SciPy (9 files), MNE-Python (5 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
14 files
At the source: github.com/jiivana/SpatialJitter

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;
  • 13 scripts, each with its path and the digest of its content;
  • 6 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.

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 → Institute of Electrical and Electronics Engineers

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 1 author, 6 keywords, 8 MeSH terms, 5 funders, 28 references.

Cite

This paper

Iivanainen, J. (2026). Spatial-Jitter Model for Magnetoencephalography Sensor Arrays. IEEE transactions on medical imaging, 45(7), 3908-3921. https://doi.org/10.1109/tmi.2026.3687982

BibTeX

@article{iivanainen2026spatial,
author = {Iivanainen, Joonas},
title = {{Spatial-Jitter Model for Magnetoencephalography Sensor Arrays}},
journal = {IEEE transactions on medical imaging},
year = {2026},
month = jul,
volume = {45},
number = {7},
pages = {3908--3921},
publisher = {Institute of Electrical and Electronics Engineers},
issn = {0278-0062},
doi = {10.1109/tmi.2026.3687982},
url = {https://doi.org/10.1109/tmi.2026.3687982},
pmid = {42043988},
pmcid = {PMC13503295}
}

RIS

TY - JOUR
AU - Iivanainen, Joonas
TI - Spatial-Jitter Model for Magnetoencephalography Sensor Arrays
T2 - IEEE transactions on medical imaging
J2 - IEEE Trans Med Imaging
PY - 2026
DA - 2026/07/01
VL - 45
IS - 7
SP - 3908
EP - 3921
SN - 0278-0062
PB - Institute of Electrical and Electronics Engineers
DO - 10.1109/tmi.2026.3687982
UR - https://doi.org/10.1109/tmi.2026.3687982
LA - en
ER -

CSL-JSON

{
"id": "10.1109/tmi.2026.3687982",
"type": "article-journal",
"title": "Spatial-Jitter Model for Magnetoencephalography Sensor Arrays",
"container-title": "IEEE transactions on medical imaging",
"author": [
{
"family": "Iivanainen",
"given": "Joonas"
}
],
"container-title-short": "IEEE Trans Med Imaging",
"volume": "45",
"issue": "7",
"page": "3908-3921",
"DOI": "10.1109/tmi.2026.3687982",
"PMID": "42043988",
"PMCID": "PMC13503295",
"ISSN": "0278-0062",
"publisher": "Institute of Electrical and Electronics Engineers",
"URL": "https://doi.org/10.1109/tmi.2026.3687982",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
1
]
]
}
}

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.1002/hbm.70368 [code]
The Mismatch Negativity Compared: EEG, SQUID‐MEG, and Novel 4 Helium‐OPMs
Journal: n/a
In common: MNE-Python, SciPy, Matplotlib, 1 other tool, MEG, 4 references
[2] doi:10.1038/s41598-025-08037-8 [code]
OPM-MEG reveals dynamics of beta bursts underlying attentional processes in sensory cortex
Journal: n/a
In common: NumPy, MEG, 6 references
[3] doi:10.1162/imag.a.1040 [code]
Novel 4 He-OPMs support waveform-specific beta burst analysis comparable to SQUID-MEG
Journal: n/a
In common: MNE-Python, SciPy, Matplotlib, 1 other tool, MEG, 3 references
[4] doi:10.1093/cercor/bhag075 [code]
Cortical dynamics of icon perception: effects of concreteness and attractiveness.
Journal: Cerebral cortex (New York, N.Y. : 1991)
In common: MNE-Python, SciPy, Matplotlib, 1 other tool, MEG, 3 references
[5] doi:10.1371/journal.pone.0351872 [code]
Decoding visual object recognition from EEG signals.
Journal: PloS one
In common: MNE-Python, SciPy, Matplotlib, 1 other tool, 3 references
[6] doi:10.1162/imag.a.1218 [code]
Reliability and signal comparison of OPM-MEG, fMRI & iEEG in a repeated movie viewing paradigm.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MEG, 4 references
[7] doi:10.1126/sciadv.aea3919 [code]
Hierarchical brain dynamics supporting visual perceptual transitions.
Journal: Science advances
In common: MNE-Python, SciPy, Matplotlib, 1 other tool, MEG, 2 references
[8] doi:10.1162/imag.a.1269 [code]
From early to contemporary normative modeling: Mapping individual differences in neurophysiological signals.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MNE-Python, SciPy, Matplotlib, 1 other tool, MEG, 2 references
[9] doi:10.1016/j.neuroimage.2026.122051 [code]
Determining hemispheric language dominance from MEG beta-power modulations: Concordance with fMRI.
Journal: NeuroImage
In common: MNE-Python, SciPy, Matplotlib, 1 other tool, MEG, 1 reference
[10] doi:10.1038/s41597-025-06397-4 [code]
MEG-SCANS - A comprehensive magnetoencephalography speech dataset with Stories, Chirps and Noisy Sentences
Journal: n/a
In common: MNE-Python, SciPy, Matplotlib, 1 other tool, MEG, 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.