Processing NeXus Choppers#

When choppers are loaded from NeXus, they typically contain a number of fields that need to be processed before they can be used for computing wavelength ranges, etc. This guide shows how to extract the relevant data from such a NeXus chopper and create a scippneutron.chopper.DiskChopper object.

[1]:

import matplotlib.pyplot as plt
import scipp as sc

Here, we use fake data which roughly represents what a real chopper loaded from NeXus looks like. ScippNeutron has a function for generating this data:

[2]:

from scippneutron.data import chopper_mockup

chopper = chopper_mockup()
chopper

[2]:

scipp.DataGroup

(time: None, slit: 4)

delay
scipp
DataGroup
(time: 1)
position
scipp
Variable
()
vector3
m
[ 0. 0. 60.]
radius
scipp
Variable
()
float64
m
0.35
rotation_speed
scipp
DataGroup
(time: 180)
slit_height
scipp
Variable
()
float64
m
0.1
slit_edges
scipp
Variable
(slit: 4)
float64
deg
30.0, 160.0, 210.0, 280.0
slits
int
()
2
top_dead_center
scipp
DataGroup
(time: 2354)

We can see that there is some information about the slits and geometry of the chopper as well as some timing-related data. Take a look at the NXdisk_chopper documentation for an overview of the fields.

In this case, there already is a position. This typically needs to be computed first, see scippnexus.compute_positions.

Some fields are nested data groups which happens when a NeXus file contains NXlogs. We can extract the relevant arrays from them using extract_chopper_from_nexus:

[3]:

from scippneutron.chopper import extract_chopper_from_nexus

chopper = extract_chopper_from_nexus(chopper)
chopper

[3]:

scipp.DataGroup

(time: None, slit: 4)

type
DiskChopperType
()
DiskChopperType.single
delay
scipp
DataArray
()
int64
ns
3050
position
scipp
Variable
()
vector3
m
[ 0. 0. 60.]
radius
scipp
Variable
()
float64
m
0.35
rotation_speed
scipp
DataArray
(time: 180)
float64
Hz
1.287e-05, 0.359, ..., 0.352, -4.904e-07
slit_height
scipp
Variable
()
float64
m
0.1
slit_edges
scipp
Variable
(slit: 4)
float64
deg
30.0, 160.0, 210.0, 280.0
slits
int
()
2
top_dead_center
scipp
Variable
(time: 2354)
datetime64
ns
2023-01-19T08:11:06.217830400, 2023-01-19T08:11:08.799053824, ..., 2023-01-19T08:14:39.174524416, 2023-01-19T08:14:40.640919296

Some data varies with time, which can complicate the data processing. Instead, we compute corresponding time-independent quantities from the raw chopper data.

Compute Chopper Phase#

DiskChopper does not use TDC directly for time calculations but instead the chopper phase \(\phi\). According to the disk chopper docs, the phase is defined as

\[\phi = \omega (t_0 + \delta_t - T_0),\]

where \(t_0\) is a TDC timestamp and \(T_0\) a pulse time.

We already determined the TDC timestamps above. In practice, we would get \(T_0\) from the input NeXus file, but here, we simply make one up:

[16]:

pulse_time = sc.datetime('2023-01-19T08:12:03.442912915', unit='ns')

Note

The pulse time is typically an array of timestamps and it can be difficult to determine which pulse goes with which chopper period. While the choice is technically arbitrary, the times calculated by DiskChopper are relative to the chosen pulse time.

If the chopper rotates at the pulse frequency or an integer multiple of it, we can select any pulse time and TDC timestamp and simply use phase = phase % (2 * sc.constants.pi) below. This corresponds to selecting the pulse and TDC times that are closest to each other.

(We multiply by 1 rad to get the proper rad*Hz unit in omega.)

[17]:

omega = 2*sc.constants.pi * frequency.data * sc.scalar(1, unit='rad')
phase = omega * (tdc_in_phase[0] + chopper['delay'].data - pulse_time)
phase = phase.to(unit='rad')
phase

[17]:

scipp.Variable (264 Bytes)

- ()
  float64
  rad
  596.900084607312
```
Values:
array(596.90008461)
```

Build `DiskChopper`#

Finally, we can assemble all data into a scippneutron.chopper.DiskChopper object.

The rotation speed gets rounded (resulting in 14Hz) because DiskChopper requires it to be a near exact integer multiple of the pulse frequency or vice versa:

rotation_speed = N * pulse_frequency
rotation_speed = pulse_frequency / N

where N is an integer number.

[18]:

processed = chopper.copy()
processed['rotation_speed'] = sc.round(frequency.data)
processed['phase'] = phase

The input data does not contain a beam position (the angle between the beam and TDC). This probably means that it is 0. But since DiskChopper does not make that assumption we have to be explicit:

[19]:

processed['beam_position'] = sc.scalar(0.0, unit='rad')

[20]:

from scippneutron.chopper import DiskChopper

disk_chopper = DiskChopper.from_nexus(processed)
disk_chopper

[20]:

DiskChopper

(slit: 2)

axle_position
scipp
Variable
()
vector3
m
[ 0. 0. 60.]
frequency
scipp
Variable
()
float64
Hz
14.0
beam_angle
scipp
Variable
()
float64
rad
0.0
phase
scipp
Variable
()
float64
rad
596.900084607312
slit_begin
scipp
Variable
(slit: 2)
float64
deg
30.0, 210.0
slit_end
scipp
Variable
(slit: 2)
float64
deg
160.0, 280.0
slit_height
scipp
Variable
(slit: 2)
float64
m
0.1, 0.1
radius
scipp
Variable
()
float64
m
0.35

Processing NeXus Choppers#

Identify In-phase Regions#

Extract Plateau#

Compute Chopper Phase#

Build `DiskChopper`#

Processing NeXus Choppers#

Identify In-phase Regions#

Extract Plateau#

Compute Chopper Phase#

Build DiskChopper#

Build `DiskChopper`#