pytdo 0.2.2.2__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pytdo/__init__.py +46 -0
- pytdo/__main__.py +15 -0
- pytdo/assets/config_default.toml +81 -0
- pytdo/config/__init__.py +6 -0
- pytdo/config/_config.py +26 -0
- pytdo/config/_types.py +16 -0
- pytdo/config/models.py +63 -0
- pytdo/gui/__init__.py +20 -0
- pytdo/gui/_core.py +509 -0
- pytdo/gui/_workers.py +86 -0
- pytdo/gui/widgets/__init__.py +8 -0
- pytdo/gui/widgets/_configuration_tab.py +20 -0
- pytdo/gui/widgets/_graphs.py +241 -0
- pytdo/gui/widgets/_main_buttons.py +72 -0
- pytdo/gui/widgets/_param_content.py +120 -0
- pytdo/processors/__init__.py +5 -0
- pytdo/processors/_tdo.py +997 -0
- pytdo/processors/_types.py +22 -0
- pytdo/py.typed +0 -0
- pytdo/sp.py +267 -0
- pytdo-0.2.2.2.dist-info/METADATA +101 -0
- pytdo-0.2.2.2.dist-info/RECORD +24 -0
- pytdo-0.2.2.2.dist-info/WHEEL +4 -0
- pytdo-0.2.2.2.dist-info/entry_points.txt +3 -0
|
@@ -0,0 +1,241 @@
|
|
|
1
|
+
"""The graphs area that holds all the plots."""
|
|
2
|
+
|
|
3
|
+
import pyqtgraph as pg
|
|
4
|
+
from PyQt6 import QtWidgets
|
|
5
|
+
from PyQt6.QtCore import QEvent, Qt, pyqtSignal, pyqtSlot
|
|
6
|
+
|
|
7
|
+
|
|
8
|
+
class GraphsWidget(QtWidgets.QWidget):
|
|
9
|
+
"""
|
|
10
|
+
The graphs area with all the plots.
|
|
11
|
+
|
|
12
|
+
Signals
|
|
13
|
+
-------
|
|
14
|
+
sig_roi1_changed : emits when the draggable field-window moved in tdo(B).
|
|
15
|
+
sig_roi2_changed : emits when the draggable field-window moved in tdo_detrend(B).
|
|
16
|
+
"""
|
|
17
|
+
|
|
18
|
+
sig_roi1_changed = pyqtSignal()
|
|
19
|
+
sig_roi2_changed = pyqtSignal()
|
|
20
|
+
|
|
21
|
+
def __init__(self):
|
|
22
|
+
super().__init__()
|
|
23
|
+
|
|
24
|
+
# Flags
|
|
25
|
+
self._mouse_pan_mode = True
|
|
26
|
+
self._sync_roi = True
|
|
27
|
+
|
|
28
|
+
# Create grid
|
|
29
|
+
grid = QtWidgets.QGridLayout()
|
|
30
|
+
|
|
31
|
+
# Create empty canvases in tabs
|
|
32
|
+
field_tab = self.create_field_plot()
|
|
33
|
+
signal_tab = self.create_signal_plot()
|
|
34
|
+
tdo_tab = self.create_tdo_plot()
|
|
35
|
+
fft_tab = self.create_fft_plot()
|
|
36
|
+
|
|
37
|
+
# Get pens
|
|
38
|
+
self.init_plot_style()
|
|
39
|
+
|
|
40
|
+
# Add Tabs to the grid
|
|
41
|
+
grid.addWidget(field_tab, 0, 0, 1, 1)
|
|
42
|
+
grid.addWidget(signal_tab, 0, 1, 1, 3)
|
|
43
|
+
grid.addWidget(tdo_tab, 1, 0, 1, 2)
|
|
44
|
+
grid.addWidget(fft_tab, 1, 2, 1, 2)
|
|
45
|
+
|
|
46
|
+
# Force stretch factors
|
|
47
|
+
grid.setColumnStretch(0, 1)
|
|
48
|
+
grid.setColumnStretch(1, 1)
|
|
49
|
+
grid.setColumnStretch(2, 1)
|
|
50
|
+
grid.setColumnStretch(3, 1)
|
|
51
|
+
grid.setRowStretch(0, 1)
|
|
52
|
+
grid.setRowStretch(1, 1)
|
|
53
|
+
|
|
54
|
+
# Create widget
|
|
55
|
+
self.setLayout(grid)
|
|
56
|
+
|
|
57
|
+
@property
|
|
58
|
+
def time2frame_scale(self) -> float:
|
|
59
|
+
return self._time2frame_scale
|
|
60
|
+
|
|
61
|
+
@time2frame_scale.setter
|
|
62
|
+
def time2frame_scale(self, value: float):
|
|
63
|
+
self._time2frame_scale = value
|
|
64
|
+
self.field.getAxis("top").setScale(self.time2frame_scale)
|
|
65
|
+
self.dfield.getAxis("top").setScale(self.time2frame_scale)
|
|
66
|
+
|
|
67
|
+
def create_field_plot(self) -> QtWidgets.QTabWidget:
|
|
68
|
+
tab = QtWidgets.QTabWidget(self)
|
|
69
|
+
|
|
70
|
+
# magnetic field (integrated)
|
|
71
|
+
self.field = pg.PlotWidget(title="Magnetic field")
|
|
72
|
+
self.field.setLabel("bottom", "time (s)")
|
|
73
|
+
self.field.setLabel("left", "field (T)")
|
|
74
|
+
self.field.showGrid(y=True)
|
|
75
|
+
|
|
76
|
+
# pickup coil voltage (measured)
|
|
77
|
+
self.dfield = pg.PlotWidget(title="Pickup")
|
|
78
|
+
self.dfield.setLabel("bottom", "time (s)")
|
|
79
|
+
self.dfield.setLabel("left", "pickup (V)")
|
|
80
|
+
self.dfield.showGrid(y=True)
|
|
81
|
+
|
|
82
|
+
tab.addTab(self.field, "B(t)")
|
|
83
|
+
tab.addTab(self.dfield, "Pickup")
|
|
84
|
+
|
|
85
|
+
return tab
|
|
86
|
+
|
|
87
|
+
def create_signal_plot(self) -> QtWidgets.QTabWidget:
|
|
88
|
+
tab = QtWidgets.QTabWidget(self)
|
|
89
|
+
|
|
90
|
+
# TDO signal versus field
|
|
91
|
+
self.sig_field = pg.PlotWidget(title="Signal versus field")
|
|
92
|
+
self.sig_field.setLabel("bottom", "field (T)")
|
|
93
|
+
self.sig_field.setLabel("left", "TDO frequency (Hz)")
|
|
94
|
+
self.sig_field.showGrid(y=True)
|
|
95
|
+
self.roi = pg.LinearRegionItem() # field-window selector
|
|
96
|
+
self.sig_field.addItem(self.roi, ignoreBounds=True)
|
|
97
|
+
self.roi.sigRegionChangeFinished.connect(self.roi1_changed)
|
|
98
|
+
self.sig_field.getPlotItem().addLegend()
|
|
99
|
+
|
|
100
|
+
# TDO signal versus time
|
|
101
|
+
self.sig_time = pg.PlotWidget(title="Signal versus time")
|
|
102
|
+
self.sig_time.setLabel("bottom", "time (s)")
|
|
103
|
+
self.sig_time.setLabel("left", "TDO frequency (Hz)")
|
|
104
|
+
self.sig_time.showGrid(y=True)
|
|
105
|
+
|
|
106
|
+
tab.addTab(self.sig_field, "TDO(B)")
|
|
107
|
+
tab.addTab(self.sig_time, "TDO(t)")
|
|
108
|
+
|
|
109
|
+
return tab
|
|
110
|
+
|
|
111
|
+
def create_tdo_plot(self) -> QtWidgets.QTabWidget:
|
|
112
|
+
tab = QtWidgets.QTabWidget(self)
|
|
113
|
+
|
|
114
|
+
# vs field
|
|
115
|
+
self.tdo_field = pg.PlotWidget(title="Oscillatory part versus field")
|
|
116
|
+
self.tdo_field.setLabel("bottom", "field (T)")
|
|
117
|
+
self.tdo_field.setLabel("left", "TDO detrended")
|
|
118
|
+
self.tdo_field.showGrid(y=True)
|
|
119
|
+
self.tdo_field.getPlotItem().addLegend()
|
|
120
|
+
self.roi2 = pg.LinearRegionItem() # field-window selector
|
|
121
|
+
self.tdo_field.addItem(self.roi2, ignoreBounds=True)
|
|
122
|
+
self.roi2.sigRegionChangeFinished.connect(self.roi2_changed)
|
|
123
|
+
|
|
124
|
+
# vs 1/B
|
|
125
|
+
self.tdo_inverse_field = pg.PlotWidget(title="Oscillatory part versus 1/B")
|
|
126
|
+
self.tdo_inverse_field.setLabel("bottom", "1/B (T^-1)")
|
|
127
|
+
self.tdo_inverse_field.setLabel("left", "TDO detrended")
|
|
128
|
+
self.tdo_inverse_field.showGrid(y=True)
|
|
129
|
+
|
|
130
|
+
tab.addTab(self.tdo_field, "TDO detrended(B)")
|
|
131
|
+
tab.addTab(self.tdo_inverse_field, "TDO detrended(1/B)")
|
|
132
|
+
|
|
133
|
+
return tab
|
|
134
|
+
|
|
135
|
+
def create_fft_plot(self) -> QtWidgets.QTabWidget:
|
|
136
|
+
tab = QtWidgets.QTabWidget(self)
|
|
137
|
+
|
|
138
|
+
# vs field
|
|
139
|
+
self.fft = pg.PlotWidget(title="Fourier transform")
|
|
140
|
+
self.fft.setLabel("bottom", "B-frequency (T)")
|
|
141
|
+
self.fft.setLabel("left", "magnitude")
|
|
142
|
+
self.fft.showGrid(y=True)
|
|
143
|
+
self.fft.getPlotItem().addLegend()
|
|
144
|
+
|
|
145
|
+
tab.addTab(self.fft, "FFT")
|
|
146
|
+
|
|
147
|
+
return tab
|
|
148
|
+
|
|
149
|
+
def init_plot_style(self):
|
|
150
|
+
"""Set up PyQtGraph line styles."""
|
|
151
|
+
w0 = 1
|
|
152
|
+
self.pen_field = pg.mkPen("#c7c7c7", width=w0)
|
|
153
|
+
self.pen_bup = pg.mkPen("#2ca02cff", width=w0)
|
|
154
|
+
self.pen_bdown = pg.mkPen("#d62728ff", width=w0)
|
|
155
|
+
self.pen_fitbup = pg.mkPen("#2ca02cb1", width=w0)
|
|
156
|
+
self.pen_fitdown = pg.mkPen("#d62728b1", width=w0)
|
|
157
|
+
|
|
158
|
+
@pyqtSlot()
|
|
159
|
+
def roi1_changed(self):
|
|
160
|
+
"""Update ROI in the TDO detrended panel when the ROI in the TDO panel moved."""
|
|
161
|
+
self.sig_roi1_changed.emit()
|
|
162
|
+
if not self._sync_roi:
|
|
163
|
+
return
|
|
164
|
+
|
|
165
|
+
roi1 = self.roi.getRegion() # TDO panel
|
|
166
|
+
roi2 = self.roi2.getRegion() # TDO detrend panel
|
|
167
|
+
|
|
168
|
+
if roi1 != roi2:
|
|
169
|
+
self.roi2.setRegion(self.roi.getRegion())
|
|
170
|
+
|
|
171
|
+
@pyqtSlot()
|
|
172
|
+
def roi2_changed(self):
|
|
173
|
+
"""Update ROI in the TDO panel when the ROI in the TDO detrended panel moved."""
|
|
174
|
+
self.sig_roi2_changed.emit()
|
|
175
|
+
if not self._sync_roi:
|
|
176
|
+
return
|
|
177
|
+
|
|
178
|
+
roi1 = self.roi.getRegion() # TDO panel
|
|
179
|
+
roi2 = self.roi2.getRegion() # TDO detrend panel
|
|
180
|
+
|
|
181
|
+
if roi1 != roi2:
|
|
182
|
+
self.roi.setRegion(self.roi2.getRegion())
|
|
183
|
+
|
|
184
|
+
def enable_rois(self):
|
|
185
|
+
"""Enable moving ROIs."""
|
|
186
|
+
self.roi.setMovable(True)
|
|
187
|
+
self.roi2.setMovable(True)
|
|
188
|
+
|
|
189
|
+
def disable_rois(self):
|
|
190
|
+
"""Disable moving ROIs."""
|
|
191
|
+
self.roi.setMovable(False)
|
|
192
|
+
self.roi2.setMovable(False)
|
|
193
|
+
|
|
194
|
+
def clear_all_plots(self):
|
|
195
|
+
"""Clear plots."""
|
|
196
|
+
self.field.clearPlots()
|
|
197
|
+
self.dfield.clearPlots()
|
|
198
|
+
self.sig_time.clearPlots()
|
|
199
|
+
self.sig_field.clearPlots()
|
|
200
|
+
self.tdo_field.clearPlots()
|
|
201
|
+
self.tdo_inverse_field.clearPlots()
|
|
202
|
+
self.fft.clearPlots()
|
|
203
|
+
|
|
204
|
+
def event(self, ev: QEvent | None):
|
|
205
|
+
"""Handle mouse selection while holding CTRL to make a ROI zoom in plots."""
|
|
206
|
+
if ev is None:
|
|
207
|
+
return super().event(None)
|
|
208
|
+
|
|
209
|
+
# Switch to rectangular zoom selection on the first Ctrl key press event
|
|
210
|
+
if ev.type() == QEvent.Type.KeyPress and ev.key() == Qt.Key.Key_Control:
|
|
211
|
+
if self._mouse_pan_mode:
|
|
212
|
+
self.switch_mouse_pan_mode(False)
|
|
213
|
+
|
|
214
|
+
# Switch back to pan mode on left click when releasing the Ctrl key
|
|
215
|
+
if ev.type() == QEvent.Type.KeyRelease and ev.key() == Qt.Key.Key_Control:
|
|
216
|
+
self.switch_mouse_pan_mode(True)
|
|
217
|
+
|
|
218
|
+
return super().event(ev)
|
|
219
|
+
|
|
220
|
+
def switch_mouse_pan_mode(self, state: bool):
|
|
221
|
+
"""
|
|
222
|
+
Switch mouse behavior from panning to ROI-zooming when holding CTRL.
|
|
223
|
+
|
|
224
|
+
Parameters
|
|
225
|
+
----------
|
|
226
|
+
state : bool
|
|
227
|
+
If True, all plots are set to pan mode, otherwise they are set in ROI-zoom
|
|
228
|
+
mode.
|
|
229
|
+
"""
|
|
230
|
+
# Get mode
|
|
231
|
+
mode = pg.ViewBox.PanMode if state else pg.ViewBox.RectMode
|
|
232
|
+
self._mouse_pan_mode = state
|
|
233
|
+
|
|
234
|
+
# Set mode
|
|
235
|
+
self.field.getPlotItem().getViewBox().setMouseMode(mode)
|
|
236
|
+
self.dfield.getPlotItem().getViewBox().setMouseMode(mode)
|
|
237
|
+
self.sig_time.getPlotItem().getViewBox().setMouseMode(mode)
|
|
238
|
+
self.sig_field.getPlotItem().getViewBox().setMouseMode(mode)
|
|
239
|
+
self.tdo_field.getPlotItem().getViewBox().setMouseMode(mode)
|
|
240
|
+
self.tdo_inverse_field.getPlotItem().getViewBox().setMouseMode(mode)
|
|
241
|
+
self.fft.getPlotItem().getViewBox().setMouseMode(mode)
|
|
@@ -0,0 +1,72 @@
|
|
|
1
|
+
"""The grid with main action buttons."""
|
|
2
|
+
|
|
3
|
+
from PyQt6 import QtWidgets
|
|
4
|
+
from PyQt6.QtCore import pyqtSignal
|
|
5
|
+
|
|
6
|
+
|
|
7
|
+
class MainButtonsWidget(QtWidgets.QWidget):
|
|
8
|
+
sig_load = pyqtSignal()
|
|
9
|
+
sig_extract = pyqtSignal()
|
|
10
|
+
sig_removebg = pyqtSignal()
|
|
11
|
+
sig_fft = pyqtSignal()
|
|
12
|
+
sig_tdocsv = pyqtSignal()
|
|
13
|
+
sig_rescsv = pyqtSignal()
|
|
14
|
+
sig_save_nexus = pyqtSignal()
|
|
15
|
+
|
|
16
|
+
def __init__(self):
|
|
17
|
+
super().__init__()
|
|
18
|
+
|
|
19
|
+
grid = QtWidgets.QGridLayout()
|
|
20
|
+
|
|
21
|
+
self.button_load = QtWidgets.QPushButton("Load data", self)
|
|
22
|
+
self.button_extract = QtWidgets.QPushButton("Extract TDO", self)
|
|
23
|
+
self.button_removebg = QtWidgets.QPushButton("Remove background", self)
|
|
24
|
+
self.button_fft = QtWidgets.QPushButton("FFT in 1/B", self)
|
|
25
|
+
self.button_tdocsv = QtWidgets.QPushButton("Export TDO as CSV", self)
|
|
26
|
+
self.button_rescsv = QtWidgets.QPushButton("Export results as CSV", self)
|
|
27
|
+
self.button_save_nexus = QtWidgets.QPushButton("Save as NeXus", self)
|
|
28
|
+
|
|
29
|
+
self.disable_buttons()
|
|
30
|
+
|
|
31
|
+
self.connect_buttons()
|
|
32
|
+
|
|
33
|
+
grid.addWidget(self.button_load, 0, 0)
|
|
34
|
+
grid.addWidget(self.button_extract, 0, 1)
|
|
35
|
+
grid.addWidget(self.button_removebg, 1, 0)
|
|
36
|
+
grid.addWidget(self.button_fft, 1, 1)
|
|
37
|
+
|
|
38
|
+
grid_save = QtWidgets.QHBoxLayout()
|
|
39
|
+
grid_save.addWidget(self.button_tdocsv)
|
|
40
|
+
grid_save.addWidget(self.button_rescsv)
|
|
41
|
+
grid_save.addWidget(self.button_save_nexus)
|
|
42
|
+
|
|
43
|
+
grid.addLayout(grid_save, 2, 0, 1, 2)
|
|
44
|
+
|
|
45
|
+
self.setLayout(grid)
|
|
46
|
+
|
|
47
|
+
def connect_buttons(self):
|
|
48
|
+
self.button_load.clicked.connect(self.sig_load.emit)
|
|
49
|
+
self.button_extract.clicked.connect(self.sig_extract.emit)
|
|
50
|
+
self.button_removebg.clicked.connect(self.sig_removebg.emit)
|
|
51
|
+
self.button_fft.clicked.connect(self.sig_fft.emit)
|
|
52
|
+
self.button_tdocsv.clicked.connect(self.sig_tdocsv.emit)
|
|
53
|
+
self.button_rescsv.clicked.connect(self.sig_rescsv.emit)
|
|
54
|
+
self.button_save_nexus.clicked.connect(self.sig_save_nexus.emit)
|
|
55
|
+
|
|
56
|
+
def disable_buttons(self):
|
|
57
|
+
self.button_load.setEnabled(False)
|
|
58
|
+
self.button_extract.setEnabled(False)
|
|
59
|
+
self.button_removebg.setEnabled(False)
|
|
60
|
+
self.button_fft.setEnabled(False)
|
|
61
|
+
self.button_tdocsv.setEnabled(False)
|
|
62
|
+
self.button_rescsv.setEnabled(False)
|
|
63
|
+
self.button_save_nexus.setEnabled(False)
|
|
64
|
+
|
|
65
|
+
def enable_buttons(self):
|
|
66
|
+
self.button_load.setEnabled(False)
|
|
67
|
+
self.button_extract.setEnabled(True)
|
|
68
|
+
self.button_removebg.setEnabled(True)
|
|
69
|
+
self.button_fft.setEnabled(True)
|
|
70
|
+
self.button_tdocsv.setEnabled(True)
|
|
71
|
+
self.button_rescsv.setEnabled(True)
|
|
72
|
+
self.button_save_nexus.setEnabled(True)
|
|
@@ -0,0 +1,120 @@
|
|
|
1
|
+
import numpy as np
|
|
2
|
+
from pyuson.gui.widgets import BaseParamContent
|
|
3
|
+
|
|
4
|
+
|
|
5
|
+
class ParamContent(BaseParamContent):
|
|
6
|
+
PARAMS_TO_PARSE = ["poly_window", "fft_window"]
|
|
7
|
+
children_parameters = [
|
|
8
|
+
dict(
|
|
9
|
+
name="pickup_surface",
|
|
10
|
+
type="float",
|
|
11
|
+
limits=[0, np.inf],
|
|
12
|
+
value=None,
|
|
13
|
+
suffix="m²",
|
|
14
|
+
siPrefix=False,
|
|
15
|
+
readonly=True,
|
|
16
|
+
title="Pickup surface",
|
|
17
|
+
)
|
|
18
|
+
]
|
|
19
|
+
|
|
20
|
+
children_settings = [
|
|
21
|
+
dict(
|
|
22
|
+
name="max_time",
|
|
23
|
+
type="float",
|
|
24
|
+
limits=[0, np.inf],
|
|
25
|
+
step=0.1,
|
|
26
|
+
value=1,
|
|
27
|
+
suffix="s",
|
|
28
|
+
siPrefix=True,
|
|
29
|
+
title="Max. time",
|
|
30
|
+
),
|
|
31
|
+
dict(
|
|
32
|
+
name="barycenters_fwindow",
|
|
33
|
+
type="float",
|
|
34
|
+
limits=[0, np.inf],
|
|
35
|
+
step=1e3,
|
|
36
|
+
value=1,
|
|
37
|
+
suffix="Hz",
|
|
38
|
+
siPrefix=True,
|
|
39
|
+
title="Barycenters: frequency window",
|
|
40
|
+
),
|
|
41
|
+
dict(
|
|
42
|
+
name="barycenters_fast",
|
|
43
|
+
type="bool",
|
|
44
|
+
limits=[True, False],
|
|
45
|
+
value=True,
|
|
46
|
+
title="Barycenters: fast algo.",
|
|
47
|
+
),
|
|
48
|
+
dict(
|
|
49
|
+
name="spectro_nperseg",
|
|
50
|
+
type="int",
|
|
51
|
+
limits=[2, np.inf],
|
|
52
|
+
value=1024,
|
|
53
|
+
step=1024,
|
|
54
|
+
title="Spectro: n/segment",
|
|
55
|
+
),
|
|
56
|
+
dict(
|
|
57
|
+
name="spectro_win_size",
|
|
58
|
+
type="int",
|
|
59
|
+
limits=[2, np.inf],
|
|
60
|
+
value=2048,
|
|
61
|
+
step=1024,
|
|
62
|
+
title="Spectro: FFT win. size",
|
|
63
|
+
),
|
|
64
|
+
dict(
|
|
65
|
+
name="spectro_noverlap",
|
|
66
|
+
type="int",
|
|
67
|
+
limits=[-1, np.inf],
|
|
68
|
+
value=-1,
|
|
69
|
+
step=512,
|
|
70
|
+
title="Spectro: n overlap",
|
|
71
|
+
),
|
|
72
|
+
dict(name="poly_window", type="str", value="", title="Fit: field window"),
|
|
73
|
+
dict(
|
|
74
|
+
name="poly_deg",
|
|
75
|
+
type="int",
|
|
76
|
+
value=3,
|
|
77
|
+
step=1,
|
|
78
|
+
limits=[1, 10],
|
|
79
|
+
title="Fit: degree",
|
|
80
|
+
),
|
|
81
|
+
dict(
|
|
82
|
+
name="npoints_interp_inverse",
|
|
83
|
+
type="int",
|
|
84
|
+
value=100000,
|
|
85
|
+
step=5e4,
|
|
86
|
+
limits=[1000, np.inf],
|
|
87
|
+
title="n points interp. 1/B",
|
|
88
|
+
),
|
|
89
|
+
dict(
|
|
90
|
+
name="fft_window",
|
|
91
|
+
type="str",
|
|
92
|
+
value="-1, 1",
|
|
93
|
+
title="FFT: field window",
|
|
94
|
+
),
|
|
95
|
+
dict(
|
|
96
|
+
name="fft_pad_mult",
|
|
97
|
+
type="int",
|
|
98
|
+
value=100,
|
|
99
|
+
step=100,
|
|
100
|
+
title="FFT: padding size mult.",
|
|
101
|
+
),
|
|
102
|
+
dict(
|
|
103
|
+
name="max_bfreq",
|
|
104
|
+
type="float",
|
|
105
|
+
value=70000,
|
|
106
|
+
step=1e4,
|
|
107
|
+
limits=[1, np.inf],
|
|
108
|
+
suffix="T",
|
|
109
|
+
siPrefix=True,
|
|
110
|
+
title="Max. B-frequency",
|
|
111
|
+
),
|
|
112
|
+
dict(
|
|
113
|
+
name="offset",
|
|
114
|
+
type="float",
|
|
115
|
+
value=1000,
|
|
116
|
+
step=500,
|
|
117
|
+
limits=[0, np.inf],
|
|
118
|
+
title="Display: curve offset",
|
|
119
|
+
),
|
|
120
|
+
]
|