/
_fine_cal.py
559 lines (505 loc) · 20.4 KB
/
_fine_cal.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
# Authors: Eric Larson <larson.eric.d@gmail.com>
# License: BSD-3-Clause
# Copyright the MNE-Python contributors.
from collections import defaultdict
from functools import partial
import numpy as np
from scipy.optimize import fmin_cobyla
from .._fiff.pick import pick_info, pick_types
from .._fiff.tag import _coil_trans_to_loc, _loc_to_coil_trans
from ..bem import _check_origin
from ..io import BaseRaw
from ..transforms import _find_vector_rotation
from ..utils import (
_check_fname,
_check_option,
_ensure_int,
_pl,
_reg_pinv,
_validate_type,
check_fname,
logger,
verbose,
)
from .maxwell import (
_col_norm_pinv,
_get_grad_point_coilsets,
_prep_fine_cal,
_prep_mf_coils,
_read_cross_talk,
_trans_sss_basis,
)
@verbose
def compute_fine_calibration(
raw,
n_imbalance=3,
t_window=10.0,
ext_order=2,
origin=(0.0, 0.0, 0.0),
cross_talk=None,
calibration=None,
verbose=None,
):
"""Compute fine calibration from empty-room data.
Parameters
----------
raw : instance of Raw
The raw data to use. Should be from an empty-room recording,
and all channels should be good.
n_imbalance : int
Can be 1 or 3 (default), indicating the number of gradiometer
imbalance components. Only used if gradiometers are present.
t_window : float
Time window to use for surface normal rotation in seconds.
Default is 10.
%(ext_order_maxwell)s
Default is 2, which is lower than the default (3) for
:func:`mne.preprocessing.maxwell_filter` because it tends to yield
more stable parameter estimates.
%(origin_maxwell)s
%(cross_talk_maxwell)s
calibration : dict | None
Dictionary with existing calibration. If provided, the magnetometer
imbalances and adjusted normals will be used and only the gradiometer
imbalances will be estimated (see step 2 in Notes below).
%(verbose)s
Returns
-------
calibration : dict
Fine calibration data.
count : int
The number of good segments used to compute the magnetometer
parameters.
See Also
--------
mne.preprocessing.maxwell_filter
Notes
-----
This algorithm proceeds in two steps, both optimizing the fit between the
data and a reconstruction of the data based only on an external multipole
expansion:
1. Estimate magnetometer normal directions and scale factors. All
coils (mag and matching grad) are rotated by the adjusted normal
direction.
2. Estimate gradiometer imbalance factors. These add point magnetometers
in just the gradiometer difference direction or in all three directions
(depending on ``n_imbalance``).
Magnetometer normal and coefficient estimation (1) is typically the most
time consuming step. Gradiometer imbalance parameters (2) can be
iteratively reestimated (for example, first using ``n_imbalance=1`` then
subsequently ``n_imbalance=3``) by passing the previous ``calibration``
output to the ``calibration`` input in the second call.
MaxFilter processes at most 120 seconds of data, so consider cropping
your raw instance prior to processing. It also checks to make sure that
there were some minimal usable ``count`` number of segments (default 5)
that were included in the estimate.
.. versionadded:: 0.21
"""
n_imbalance = _ensure_int(n_imbalance, "n_imbalance")
_check_option("n_imbalance", n_imbalance, (1, 3))
_validate_type(raw, BaseRaw, "raw")
ext_order = _ensure_int(ext_order, "ext_order")
origin = _check_origin(origin, raw.info, "meg", disp=True)
_check_option("raw.info['bads']", raw.info["bads"], ([],))
picks = pick_types(raw.info, meg=True, ref_meg=False)
if raw.info["dev_head_t"] is not None:
raise ValueError(
'info["dev_head_t"] is not None, suggesting that the '
"data are not from an empty-room recording"
)
info = pick_info(raw.info, picks) # make a copy and pick MEG channels
mag_picks = pick_types(info, meg="mag", exclude=())
grad_picks = pick_types(info, meg="grad", exclude=())
# Get cross-talk
ctc, _ = _read_cross_talk(cross_talk, info["ch_names"])
# Check fine cal
_validate_type(calibration, (dict, None), "calibration")
#
# 1. Rotate surface normals using magnetometer information (if present)
#
cals = np.ones(len(info["ch_names"]))
time_idxs = raw.time_as_index(np.arange(0.0, raw.times[-1], t_window))
if len(time_idxs) <= 1:
time_idxs = np.array([0, len(raw.times)], int)
else:
time_idxs[-1] = len(raw.times)
count = 0
locs = np.array([ch["loc"] for ch in info["chs"]])
zs = locs[mag_picks, -3:].copy()
if calibration is not None:
_, calibration, _ = _prep_fine_cal(info, calibration)
for pi, pick in enumerate(mag_picks):
idx = calibration["ch_names"].index(info["ch_names"][pick])
cals[pick] = calibration["imb_cals"][idx].item()
zs[pi] = calibration["locs"][idx][-3:]
elif len(mag_picks) > 0:
cal_list = list()
z_list = list()
logger.info(
f"Adjusting normals for {len(mag_picks)} magnetometers "
f"(averaging over {len(time_idxs) - 1} time intervals)"
)
for start, stop in zip(time_idxs[:-1], time_idxs[1:]):
logger.info(
f" Processing interval {start / info['sfreq']:0.3f} - "
f"{stop / info['sfreq']:0.3f} s"
)
data = raw[picks, start:stop][0]
if ctc is not None:
data = ctc.dot(data)
z, cal, good = _adjust_mag_normals(info, data, origin, ext_order)
if good:
z_list.append(z)
cal_list.append(cal)
count = len(cal_list)
if count == 0:
raise RuntimeError("No usable segments found")
cals[:] = np.mean(cal_list, axis=0)
zs[:] = np.mean(z_list, axis=0)
if len(mag_picks) > 0:
for ii, new_z in enumerate(zs):
z_loc = locs[mag_picks[ii]]
# Find sensors with same NZ and R0 (should be three for VV)
idxs = _matched_loc_idx(z_loc, locs)
# Rotate the direction vectors to the plane defined by new normal
_rotate_locs(locs, idxs, new_z)
for ci, loc in enumerate(locs):
info["chs"][ci]["loc"][:] = loc
del calibration, zs
#
# 2. Estimate imbalance parameters (always done)
#
if len(grad_picks) > 0:
extra = "X direction" if n_imbalance == 1 else ("XYZ directions")
logger.info(f"Computing imbalance for {len(grad_picks)} gradimeters ({extra})")
imb_list = list()
for start, stop in zip(time_idxs[:-1], time_idxs[1:]):
logger.info(
f" Processing interval {start / info['sfreq']:0.3f} - "
f"{stop / info['sfreq']:0.3f} s"
)
data = raw[picks, start:stop][0]
if ctc is not None:
data = ctc.dot(data)
out = _estimate_imbalance(info, data, cals, n_imbalance, origin, ext_order)
imb_list.append(out)
imb = np.mean(imb_list, axis=0)
else:
imb = np.zeros((len(info["ch_names"]), n_imbalance))
#
# Put in output structure
#
assert len(np.intersect1d(mag_picks, grad_picks)) == 0
imb_cals = [
cals[ii : ii + 1] if ii in mag_picks else imb[ii]
for ii in range(len(info["ch_names"]))
]
calibration = dict(ch_names=info["ch_names"], locs=locs, imb_cals=imb_cals)
return calibration, count
def _matched_loc_idx(mag_loc, all_loc):
return np.where(
[
np.allclose(mag_loc[-3:], loc[-3:]) and np.allclose(mag_loc[:3], loc[:3])
for loc in all_loc
]
)[0]
def _rotate_locs(locs, idxs, new_z):
new_z = new_z / np.linalg.norm(new_z)
old_z = locs[idxs[0]][-3:]
old_z = old_z / np.linalg.norm(old_z)
rot = _find_vector_rotation(old_z, new_z)
for ci in idxs:
this_trans = _loc_to_coil_trans(locs[ci])
this_trans[:3, :3] = np.dot(rot, this_trans[:3, :3])
locs[ci][:] = _coil_trans_to_loc(this_trans)
np.testing.assert_allclose(locs[ci][-3:], new_z, atol=1e-4)
def _vector_angle(x, y):
"""Get the angle between two vectors in degrees."""
return np.abs(
np.arccos(
np.clip(
(x * y).sum(axis=-1)
/ (np.linalg.norm(x, axis=-1) * np.linalg.norm(y, axis=-1)),
-1,
1.0,
)
)
)
def _adjust_mag_normals(info, data, origin, ext_order):
"""Adjust coil normals using magnetometers and empty-room data."""
# in principle we could allow using just mag or mag+grad, but MF uses
# just mag so let's follow suit
mag_scale = 100.0
picks_use = pick_types(info, meg="mag", exclude="bads")
picks_meg = pick_types(info, meg=True, exclude=())
picks_mag_orig = pick_types(info, meg="mag", exclude="bads")
info = pick_info(info, picks_use) # copy
data = data[picks_use]
cals = np.ones((len(data), 1))
angles = np.zeros(len(cals))
picks_mag = pick_types(info, meg="mag")
data[picks_mag] *= mag_scale
# Transform variables so we're only dealing with good mags
exp = dict(int_order=0, ext_order=ext_order, origin=origin)
all_coils = _prep_mf_coils(info, ignore_ref=True)
S_tot = _trans_sss_basis(exp, all_coils, coil_scale=mag_scale)
first_err = _data_err(data, S_tot, cals)
count = 0
# two passes: first do the worst, then do all in order
zs = np.array([ch["loc"][-3:] for ch in info["chs"]])
zs /= np.linalg.norm(zs, axis=-1, keepdims=True)
orig_zs = zs.copy()
match_idx = dict()
locs = np.array([ch["loc"] for ch in info["chs"]])
for pick in picks_mag:
match_idx[pick] = _matched_loc_idx(locs[pick], locs)
counts = defaultdict(lambda: 0)
for ki, kind in enumerate(("worst first", "in order")):
logger.info(f" Magnetometer normal adjustment ({kind}) ...")
S_tot = _trans_sss_basis(exp, all_coils, coil_scale=mag_scale)
for pick in picks_mag:
err = _data_err(data, S_tot, cals, axis=1)
# First pass: do worst; second pass: do all in order (up to 3x/sen)
if ki == 0:
order = list(np.argsort(err[picks_mag]))
cal_idx = 0
while len(order) > 0:
cal_idx = picks_mag[order.pop(-1)]
if counts[cal_idx] < 3:
break
if err[cal_idx] < 2.5:
break # move on to second loop
else:
cal_idx = pick
counts[cal_idx] += 1
assert cal_idx in picks_mag
count += 1
old_z = zs[cal_idx].copy()
objective = partial(
_cal_sss_target,
old_z=old_z,
all_coils=all_coils,
cal_idx=cal_idx,
data=data,
cals=cals,
match_idx=match_idx,
S_tot=S_tot,
origin=origin,
ext_order=ext_order,
)
# Figure out the additive term for z-component
zs[cal_idx] = fmin_cobyla(
objective, old_z, cons=(), rhobeg=1e-3, rhoend=1e-4, disp=False
)
# Do in-place adjustment to all_coils
cals[cal_idx] = 1.0 / np.linalg.norm(zs[cal_idx])
zs[cal_idx] *= cals[cal_idx]
for idx in match_idx[cal_idx]:
_rotate_coil(zs[cal_idx], old_z, all_coils, idx, inplace=True)
# Recalculate S_tot, taking into account rotations
S_tot = _trans_sss_basis(exp, all_coils)
# Reprt results
old_err = err[cal_idx]
new_err = _data_err(data, S_tot, cals, idx=cal_idx)
angles[cal_idx] = np.abs(
np.rad2deg(_vector_angle(zs[cal_idx], orig_zs[cal_idx]))
)
ch_name = info["ch_names"][cal_idx]
logger.debug(
f" Optimization step {count:3d} | "
f"{ch_name} ({counts[cal_idx]}) | "
f"res {old_err:5.2f}→{new_err:5.2f}% | "
f"×{cals[cal_idx, 0]:0.3f} | {angles[cal_idx]:0.2f}°"
)
last_err = _data_err(data, S_tot, cals)
# Chunk is usable if all angles and errors are both small
reason = list()
max_angle = np.max(angles)
if max_angle >= 5.0:
reason.append(f"max angle {max_angle:0.2f} >= 5°")
each_err = _data_err(data, S_tot, cals, axis=-1)[picks_mag]
n_bad = (each_err > 5.0).sum()
if n_bad:
reason.append(f"{n_bad} residual{_pl(n_bad)} > 5%")
reason = ", ".join(reason)
if reason:
reason = f" ({reason})"
good = not bool(reason)
assert np.allclose(np.linalg.norm(zs, axis=1), 1.0)
logger.info(f" Fit mismatch {first_err:0.2f}→{last_err:0.2f}%")
logger.info(f' Data segment {"" if good else "un"}usable{reason}')
# Reformat zs and cals to be the n_mags (including bads)
assert zs.shape == (len(data), 3)
assert cals.shape == (len(data), 1)
imb_cals = np.ones(len(picks_meg))
imb_cals[picks_mag_orig] = cals[:, 0]
return zs, imb_cals, good
def _data_err(data, S_tot, cals, idx=None, axis=None):
if idx is None:
idx = slice(None)
S_tot = S_tot / cals
data_model = np.dot(np.dot(S_tot[idx], _col_norm_pinv(S_tot.copy())[0]), data)
err = 100 * (
np.linalg.norm(data_model - data[idx], axis=axis)
/ np.linalg.norm(data[idx], axis=axis)
)
return err
def _rotate_coil(new_z, old_z, all_coils, idx, inplace=False):
"""Adjust coils."""
# Turn NX and NY to the plane determined by NZ
old_z = old_z / np.linalg.norm(old_z)
new_z = new_z / np.linalg.norm(new_z)
rot = _find_vector_rotation(old_z, new_z) # additional coil rotation
this_sl = all_coils[5][idx]
this_rmag = np.dot(rot, all_coils[0][this_sl].T).T
this_cosmag = np.dot(rot, all_coils[1][this_sl].T).T
if inplace:
all_coils[0][this_sl] = this_rmag
all_coils[1][this_sl] = this_cosmag
subset = (
this_rmag,
this_cosmag,
np.zeros(this_rmag.shape[0], int),
1,
all_coils[4][[idx]],
{0: this_sl},
)
return subset
def _cal_sss_target(
new_z, old_z, all_coils, cal_idx, data, cals, S_tot, origin, ext_order, match_idx
):
"""Evaluate objective function for SSS-based magnetometer calibration."""
cals[cal_idx] = 1.0 / np.linalg.norm(new_z)
exp = dict(int_order=0, ext_order=ext_order, origin=origin)
S_tot = S_tot.copy()
# Rotate necessary coils properly and adjust correct element in c
for idx in match_idx[cal_idx]:
this_coil = _rotate_coil(new_z, old_z, all_coils, idx)
# Replace correct row of S_tot with new value
S_tot[idx] = _trans_sss_basis(exp, this_coil)
# Get the GOF
return _data_err(data, S_tot, cals, idx=cal_idx)
def _estimate_imbalance(info, data, cals, n_imbalance, origin, ext_order):
"""Estimate gradiometer imbalance parameters."""
mag_scale = 100.0
n_iterations = 3
mag_picks = pick_types(info, meg="mag", exclude=())
grad_picks = pick_types(info, meg="grad", exclude=())
data = data.copy()
data[mag_picks, :] *= mag_scale
del mag_picks
grad_imb = np.zeros((len(grad_picks), n_imbalance))
exp = dict(origin=origin, int_order=0, ext_order=ext_order)
all_coils = _prep_mf_coils(info, ignore_ref=True)
grad_point_coils = _get_grad_point_coilsets(info, n_imbalance, ignore_ref=True)
S_orig = _trans_sss_basis(exp, all_coils, coil_scale=mag_scale)
S_orig /= cals[:, np.newaxis]
# Compute point gradiometers for each grad channel
this_cs = np.array([mag_scale], float)
S_pt = np.array(
[_trans_sss_basis(exp, coils, None, this_cs) for coils in grad_point_coils]
)
for k in range(n_iterations):
S_tot = S_orig.copy()
# In theory we could zero out the homogeneous components with:
# S_tot[grad_picks, :3] = 0
# But in practice it doesn't seem to matter
S_recon = S_tot[grad_picks]
# Add influence of point magnetometers
S_tot[grad_picks, :] += np.einsum("ij,ijk->jk", grad_imb.T, S_pt)
# Compute multipolar moments
mm = np.dot(_col_norm_pinv(S_tot.copy())[0], data)
# Use good channels to recalculate
prev_imb = grad_imb.copy()
data_recon = np.dot(S_recon, mm)
assert S_pt.shape == (n_imbalance, len(grad_picks), S_tot.shape[1])
khi_pts = (S_pt @ mm).transpose(1, 2, 0)
assert khi_pts.shape == (len(grad_picks), data.shape[1], n_imbalance)
residual = data[grad_picks] - data_recon
assert residual.shape == (len(grad_picks), data.shape[1])
d = (residual[:, np.newaxis, :] @ khi_pts)[:, 0]
assert d.shape == (len(grad_picks), n_imbalance)
dinv, _, _ = _reg_pinv(khi_pts.swapaxes(-1, -2) @ khi_pts, rcond=1e-6)
assert dinv.shape == (len(grad_picks), n_imbalance, n_imbalance)
grad_imb[:] = (d[:, np.newaxis] @ dinv)[:, 0]
# This code is equivalent but hits a np.linalg.pinv bug on old NumPy:
# grad_imb[:] = np.sum( # dot product across the time dim
# np.linalg.pinv(khi_pts) * residual[:, np.newaxis], axis=-1)
deltas = np.linalg.norm(grad_imb - prev_imb) / max(
np.linalg.norm(grad_imb), np.linalg.norm(prev_imb)
)
logger.debug(
f" Iteration {k + 1}/{n_iterations}: "
f"max ∆ = {100 * deltas.max():7.3f}%"
)
imb = np.zeros((len(data), n_imbalance))
imb[grad_picks] = grad_imb
return imb
def read_fine_calibration(fname):
"""Read fine calibration information from a ``.dat`` file.
The fine calibration typically includes improved sensor locations,
calibration coefficients, and gradiometer imbalance information.
Parameters
----------
fname : path-like
The filename.
Returns
-------
calibration : dict
Fine calibration information. Key-value pairs are:
- ``ch_names``
List of str of the channel names.
- ``locs``
Coil location and orientation parameters.
- ``imb_cals``
For magnetometers, the calibration coefficients.
For gradiometers, one or three imbalance parameters.
"""
# Read new sensor locations
fname = _check_fname(fname, overwrite="read", must_exist=True)
check_fname(fname, "cal", (".dat",))
ch_names, locs, imb_cals = list(), list(), list()
with open(fname) as fid:
for line in fid:
if line[0] in "#\n":
continue
vals = line.strip().split()
if len(vals) not in [14, 16]:
raise RuntimeError(
"Error parsing fine calibration file, "
"should have 14 or 16 entries per line "
f"but found {len(vals)} on line:\n{line}"
)
# `vals` contains channel number
ch_name = vals[0]
if len(ch_name) in (3, 4): # heuristic for Neuromag fix
try:
ch_name = int(ch_name)
except ValueError: # something other than e.g. 113 or 2642
pass
else:
ch_name = "MEG" + "%04d" % ch_name
# (x, y, z), x-norm 3-vec, y-norm 3-vec, z-norm 3-vec
# and 1 or 3 imbalance terms
ch_names.append(ch_name)
locs.append(np.array(vals[1:13], float))
imb_cals.append(np.array(vals[13:], float))
locs = np.array(locs)
return dict(ch_names=ch_names, locs=locs, imb_cals=imb_cals)
def write_fine_calibration(fname, calibration):
"""Write fine calibration information to a ``.dat`` file.
Parameters
----------
fname : path-like
The filename to write out.
calibration : dict
Fine calibration information.
"""
fname = _check_fname(fname, overwrite=True)
check_fname(fname, "cal", (".dat",))
keys = ("ch_names", "locs", "imb_cals")
with open(fname, "wb") as cal_file:
for ch_name, loc, imb_cal in zip(*(calibration[key] for key in keys)):
cal_line = np.concatenate([loc, imb_cal]).round(6)
cal_line = " ".join(f"{c:0.6f}" for c in cal_line)
cal_file.write(f"{ch_name} {cal_line}\n".encode("ASCII"))