SANS2D: I(Q) workflow for a single run (sample)#

This notebook describes in detail the steps that are undertaken in the sans.to_I_of_Q workflow.

It assumes the detector data has been recorded in event mode, while the monitor data has been histogrammed.

The data used in this notebook has been published in Manasi et al. (2021), and we kindly thank the authors for allowing us to use their data.

Note: It uses sample run for simplicity and it is not intended to describe complete data reduction pipeline. The complete pipeline is described in SANS2D reduction.

Outline:

We will begin by loading the data files containing the sample and the direct (empty sample holder) measurements.
We will then apply some corrections to beamline components specific to the SANS2D beamline.
This will be followed by some masking of some saturated or defect detector pixels
Both sample and direct measurement, as well as their monitors, will then be converted to wavelength
From the direct run, and the direct beam function, the normalization term will be computed
Both sample measurement and normalization term will be converted to \(Q\)
Finally, the sample counts (as a function of \(Q\)) will be divided by the normalization term (as a function of \(Q\))

[1]:

import scipp as sc
from ess import loki, sans
from ess.logging import configure_workflow
import scippneutron as scn

Set up the logging systems of scipp (including scippneutron and ess) and Mantid.

[2]:

logger = configure_workflow('sans2d_I_of_Q', filename='sans2d.log')

Define reduction parameters#

We define here whether to include the effects of gravity, and the binning in wavelength and in \(Q\) to be used.

[3]:

# Include effects of gravity?
gravity = True

# Wavelength binning
wavelength_bins = sc.linspace(
    dim='wavelength', start=2.0, stop=16.0, num=141, unit='angstrom'
)

# Q binning
q_bins = sc.linspace(dim='Q', start=0.01, stop=0.6, num=141, unit='1/angstrom')

Inspecting the monitor data#

The monitor counts play a major role in normalizing the detector counts. From the two loaded runs, we extract the data from the incident and transmission monitors.

[5]:

monitors = {
    'sample-incident': sample.attrs["monitor2"].value,
    'sample-transmission': sample.attrs["monitor4"].value,
    'direct-incident': direct.attrs["monitor2"].value,
    'direct-transmission': direct.attrs["monitor4"].value,
}

The monitor data contains background noise, which should be removed for best results when normalizing. Because incident and transmission monitors are located at different distances along the beamline path, it is more useful to inspect the counts as a function of wavelength instead of time-of-flight.

To compute the wavelength of the neutrons, we use Scipp’s transform_coords method (see here for more information about using transform_coords). In order to use transform_coords, we need to define a coordinate transformation graph. The sans module provides some pre-defined graphs, one of which is applicable for monitors.

[6]:

monitor_graph = sans.conversions.sans_monitor()
sc.show_graph(monitor_graph, simplified=True)

[6]:

../../_images/instruments_loki_sans2d_to_I_of_Q_11_0.svg

It is then trivial to convert the monitor data to wavelength using

[7]:

monitors = {
    key: mon.transform_coords('wavelength', graph=monitor_graph)
    for key, mon in monitors.items()
}

We now plot them on the same figure to asses the level of background noise

[8]:

sc.plot(monitors, norm='log', grid=True)

[8]:

../../_images/instruments_loki_sans2d_to_I_of_Q_15_0.svg

From this, we define a wavelength range between 0.7 Å and 17.1 Å where data is not considered to be background.

[9]:

non_background_range = sc.array(
    dims=['wavelength'], values=[0.7, 17.1], unit='angstrom'
)

Then, we subtract a mean background value from each monitor, and rebin the data to the wavelength binning defined at the start of the notebook.

[10]:

processed_monitors = sans.i_of_q.preprocess_monitor_data(
    monitors, non_background_range=non_background_range, wavelength_bins=wavelength_bins
)

sample_monitors = {
    'incident': processed_monitors['sample-incident'],
    'transmission': processed_monitors['sample-transmission'],
}
direct_monitors = {
    'incident': processed_monitors['direct-incident'],
    'transmission': processed_monitors['direct-transmission'],
}

Masking bad detector pixels#

Note: We use programmatic masks here and not those stored in xml files.

Now that the monitor data is cleaned and binned to the correct wavelength range, we turn to the detector data. The first step is to mask noisy and saturated pixels. We mask the edges of the square-shaped detector panel with a simple distance relation. We also mask the region close to the beam center, where the sample holder is visible as a dark patch with an arm extending to the north-east.

[11]:

mask_edges = (
    sc.abs(sample.coords['position'].fields.x) > sc.scalar(0.48, unit='m')
) | (sc.abs(sample.coords['position'].fields.y) > sc.scalar(0.45, unit='m'))

summed = sample.sum('tof')
holder_mask = (
    (summed.data < sc.scalar(100, unit='counts'))
    & (sample.coords['position'].fields.x > sc.scalar(0, unit='m'))
    & (sample.coords['position'].fields.x < sc.scalar(0.42, unit='m'))
    & (sample.coords['position'].fields.y < sc.scalar(0.05, unit='m'))
    & (sample.coords['position'].fields.y > sc.scalar(-0.15, unit='m'))
)

sample.masks['edges'] = mask_edges
sample.masks['holder_mask'] = holder_mask

A good sanity check is to view the masks on the instrument view:

[12]:

scn.instrument_view(sample.hist(), pixel_size=0.0075)

[12]:

Beam center finder#

The beam is not guaranteed to travel through the center of the detector panel, and we thus have to apply a horizontal and vertical offset to our pixel positions so that the beam centre is at x = y = 0. This is necessary for subsequent azimuthal averaging of the data counts into \(Q\) bins.

The beam_center utility in the sans module is designed for this. It requires us to define a \(Q\) range over which convergence will be checked.

[13]:

q_range = sc.linspace('Q', 0.02, 0.3, 71, unit='1/angstrom')

center = sans.beam_center(
    data=sample,
    data_monitors=sample_monitors,
    direct_monitors=direct_monitors,
    wavelength_bins=wavelength_bins,
    q_bins=q_range,
    gravity=gravity,
)
print(center)

# Now shift pixels positions to get the correct beam center
sample.coords['position'] -= center

<scipp.Variable> ()    vector3              [m]  (0.0945643, -0.082074, 0)

We once again use the instrument view to verify the beam center has been found and applied correctly.

[14]:

scn.instrument_view(sample.hist(), pixel_size=0.0075)

[14]:

Coordinate transformation graph#

To compute the wavelength \(\lambda\), the scattering angle \(\theta\), and the \(Q\) vector for our data, we construct a coordinate transformation graph.

It is based on classical conversions from tof and pixel position to \(\lambda\) (wavelength), \(\theta\) (theta) and \(Q\) (Q), but takes into account the Earth’s gravitational field, which bends the flight path of the neutrons, to compute the scattering angle \(\theta\).

The angle can be found using the following expression (Seeger & Hjelm 1991)

\[\theta = \frac{1}{2}\sin^{-1}\left(\frac{\sqrt{ x^{2} + \left( y + \frac{g m_{\rm n}}{2 h^{2}} \lambda^{2} L_{2}^{2} \right)^{2} } }{L_{2}}\right)\]

where \(x\) and \(y\) are the spatial coordinates of the pixels in the horizontal and vertical directions, respectively, \(m_{\rm n}\) is the neutron mass, \(L_{2}\) is the distance between the sample and a detector pixel, \(g\) is the acceleration due to gravity, and \(h\) is Planck’s constant.

The monitors require a slightly different conversion graph, as the flight path of the neutrons hitting them does not scatter through the sample, it links the source to the monitor with a straight line.

The conversion graphs for the detectors and the monitors are defined in the sans module, and can be obtained via

[15]:

graph = sans.conversions.sans_elastic(gravity=gravity)

sc.show_graph(graph, simplified=True)

[15]:

../../_images/instruments_loki_sans2d_to_I_of_Q_29_0.svg

Mask Bragg edges in wavelength#

We will now take out the wavelength regions with Bragg peaks from the beam stop and detector window, although in reality the peaks appear only close to the beam stop, and will make little difference to \(I(Q)\).

This could be implemented as masking specific wavelength bins for a specific region in space, but for now we keep it simple.

[17]:

mask = sc.DataArray(
    data=sc.array(dims=['wavelength'], values=[True]),
    coords={
        'wavelength': sc.array(
            dims=['wavelength'], values=[2.21, 2.59], unit='angstrom'
        )
    },
)
masking_args = dict(mask=mask, name='bragg_peaks')
sample = sans.common.mask_range(sample.bin(wavelength=1), **masking_args)

sample.hist(wavelength=200).sum('spectrum').plot()

[17]:

../../_images/instruments_loki_sans2d_to_I_of_Q_33_0.svg

Adding wavelength masks the monitor data#

Because the monitor data is histogrammed (it does not contain events), the wavelength masking is applied slightly differently.

[18]:

sample_monitors = {
    key: sans.common.mask_range(mon, **masking_args)
    for key, mon in sample_monitors.items()
}
direct_monitors = {
    key: sans.common.mask_range(mon, **masking_args)
    for key, mon in direct_monitors.items()
}

Convert to Q#

Using the coordinate transformation graph as above, we can compute the momentum vector \(Q\), and then merge all the events in the detector pixel bins, so as to obtain an intensity that depends only on \(Q\).

This is done with the convert_to_q_and_merge_spectra helper.

[24]:

wavelength_bands = sc.concat(
    [wavelength_bins.min(), wavelength_bins.max()], dim='wavelength'
)

[25]:

sample_q = sans.i_of_q.convert_to_q_and_merge_spectra(
    data=sample,
    graph=graph,
    wavelength_bands=wavelength_bands,
    q_bins=q_bins,
    gravity=gravity,
)

[26]:

sc.plot(sample_q.hist(), norm='log')

[26]:

../../_images/instruments_loki_sans2d_to_I_of_Q_48_0.svg

Convert denominator to Q#

Converting the denominator to \(Q\) is achieved in the same way

[27]:

denominator_q = sans.i_of_q.convert_to_q_and_merge_spectra(
    data=denominator,
    graph=graph,
    wavelength_bands=wavelength_bands,
    q_bins=q_bins,
    gravity=gravity,
)

sc.plot(denominator_q, norm='log')

[27]:

../../_images/instruments_loki_sans2d_to_I_of_Q_50_0.svg

References#

Heenan R. K., Penfold J., King S. M., 1997, SANS at Pulsed Neutron Sources: Present and Future Prospects, J. Appl. Cryst., 30, 1140-1147

Heybrock S., Wynen J.-L., Vaytet N., 2023, Systematic underestimation of uncertainties by widespread neutron-scattering data-reduction software, Journal of Neutron Research

Manasi I., Andalibi M. R., Atri R. S., Hooton J., King S. M., Edler K. J., 2021, Self-assembly of ionic and non-ionic surfactants in type IV cerium nitrate and urea based deep eutectic solvent, J. Chem. Phys. 155, 084902

Seeger P. A., Hjelm R. P. Jnr, 1991, Small-angle neutron scattering at pulsed spallation sources, J. Appl. Cryst., 24, 467-478

SANS2D: I(Q) workflow for a single run (sample)

Contents

SANS2D: I(Q) workflow for a single run (sample)#

Define reduction parameters#

Loading data files#

Inspecting the monitor data#

Masking bad detector pixels#

Beam center finder#

Coordinate transformation graph#

Convert the data to wavelength#

Mask Bragg edges in wavelength#

Adding wavelength masks the monitor data#

Compute normalization term#

Transmission fraction#

Direct beam function#

The denominator term#

Convert to Q#

Convert denominator to Q#

Normalize the sample#

References#