Powder diffraction data reduction

Powder diffraction data reduction#

This notebook will guide you through the data reduction for the powder diffraction experiment that you simulated with McStas yesterday.

The following is a basic outline of what this notebook will cover:

Loading the NeXus files that contain the data
Inspect/visualize the data contents
How to convert the raw event time-of-arrival coordinate to something more useful (\(\lambda\), \(d\), …)
Improve the estimate of neutron time-of-flight
Save the reduced data to disk, in a state that is ready for analysis/fitting.

import numpy as np
import scipp as sc
import plopp as pp
import powder_utils as utils

Exercise 3: Process the Vanadium run#

We now need to repeat the process (load data, correct time-of-flight, convert to d-spacing) for the Vanadium run.

folder = "../3-mcstas/output_sample_vanadium"

sample_van = utils.load_powder(folder)

van_dspacing.hist(two_theta=ntheta, dspacing=dbins).plot(norm="log", vmin=1.0e-3)

../_images/2e7c8568bbb9cb77f169f294f27f71bb9ab6e9b0392f66188f73ebfdc7ff7411.svg

Normalize by Vanadium#

The next step in our data reduction is to normalize our sample signal by the Vanadium counts.

Vanadium is an almost perfect incoherent scatterer (scatters equally in all directions) and the signal from that run can be used to correct for difference in detector exposure and sensitivity.

Performing accurate normalization is a complex subject, but in our simple idealised set-up, it basically boils down to a simple division operation.

We first histogram the sample and vanadium data using the same binning for both:

num = better_dspacing.hist(two_theta=ntheta, dspacing=dbins)
den = van_dspacing.hist(two_theta=num.coords["two_theta"], dspacing=dbins)

For best results, it is common practice to smooth the Vanadium signal before using it for normalization, to remove any noise that mostly comes from collection statistics rather than detector efficiency.

We thus smooth the Vandium histogram using a simple Gaussian filter. We will normalize the signal as a 1D histogram, so the data is first summed over the two_theta dimension. In Scipp, because of the physical units, we can define a physical kernel width as opposed to having to determine how many neighbours are necessary for good smoothing.

# Smooth the Vanadium run
from scipp.scipy.ndimage import gaussian_filter

smooth_vana = gaussian_filter(
    sc.values(den.sum("two_theta")), sigma=sc.scalar(0.03, unit="angstrom")
)

pp.plot(
    {"orig": den.sum("two_theta"), "smooth": smooth_vana}, title="Vanadium - smoothed"
)

../_images/619b0a2dc1ec707bb27ae82470753ec72efd58ea4966e4fc955a1c5b978a8a44.svg

Exercise 4: perform the normalization#

Finally, we divide the sample histogram num (summed over two_theta) by the smoothed Vanadium.

normed.plot()

../_images/3ea99d4d6fc82c136cb8b08978e03580adbef42de8751baf9869f8597ced4c39.svg

You can compare to the plot above (before normalization) and see that the relative intensities of the Si peaks have changed.

Save to disk#

We now need to save our reduced normalized data to a file, that will then be used by the analysis software in the next chapter.

For this, we use a small helper function:

utils.save_xye(
    "reduced_Si.xye",
    event_data=better_dspacing,  # Needed for saving metadata required for analysis
    normalized_histogram=normed,
)

Exercise 5: Process and normalize main sample: LBCO#

Repeat the process for the LBCO sample:

load data
correct time-of-flight
convert to d-spacing
normalize by Vanadium
save to disk

folder = "../3-mcstas/output_sample_LBCO"

Sciline workflow#

Pause here if you have not yet been introduced to Sciline!

Below we build a re-usable Sciline workflow for reducing the powder diffraction data. We wrap the operations that were carried out throughout this notebook into function that have the correct type-annotations, building a pipeline of connected steps.

The custom types have been created for you in the powder_utils module, and are imported from there.

Take some time to read through the code and understand the different parts. Ask questions if anything is unclear.

import sciline as sl
from powder_utils import *


def load(folder: Foldername[RunType]) -> RawData[RunType]:
    """Load raw data from file"""
    return RawData[RunType](utils.load_powder(folder))


def correct_beamline_params(
    data: RawData[RunType], source_position: SourcePosition, time_origin: TimeOrigin
) -> CorrectedData[RunType]:
    """Correct the source position and time origin for a better time-of-flight estimate"""
    corrected = data.copy(deep=False)
    corrected.coords["source_position"] = source_position
    corrected.coords["time_origin"] = time_origin
    return CorrectedData[RunType](corrected)


def to_dspacing(
    data: CorrectedData[RunType], graph: CoordTransformGraph
) -> DspacingData[RunType]:
    """Compute dspacing for events"""
    return DspacingData[RunType](data.transform_coords("dspacing", graph=graph))


def to_histogram(
    data: DspacingData[RunType],
    two_theta_bins: TwoThetaBins,
    dspacing_bins: DspacingBins,
) -> HistogramTwothetaDspacing[RunType]:
    """Histogram event data using two_theta and dspacing binning"""
    return HistogramTwothetaDspacing[RunType](
        data.hist(two_theta=two_theta_bins, dspacing=dspacing_bins)
    )


def smooth_vanadium(
    van: HistogramTwothetaDspacing[VanadiumRun], sigma: GaussianSmoothingSigma
) -> SmoothedVanadium:
    """Smooth the Vanadium data using a Gaussian kernel"""
    return SmoothedVanadium(
        gaussian_filter(sc.values(van.sum("two_theta")), sigma=sigma)
    )


def sum_over_two_theta(
    sample: HistogramTwothetaDspacing[SampleRun],
) -> SampleDspacing:
    """Sum the sample data over the two_theta dimension so we are left with dspacing"""
    return SampleDspacing(sample.sum("two_theta"))


def normalize(sample: SampleDspacing, van: SmoothedVanadium) -> NormalizedDspacing:
    """Normalize sample by vanadium"""
    return NormalizedDspacing(sample / van)


wf = sl.Pipeline(
    (
        load,
        correct_beamline_params,
        to_dspacing,
        to_histogram,
        smooth_vanadium,
        sum_over_two_theta,
        normalize,
    ),
    constraints={RunType: [SampleRun, VanadiumRun]},
)

wf.visualize()

../_images/4b3c7eea48792e98bb84dcd4ca7f50302fe0b33c1e8f76c1a54b81b0dbd029a0.svg

Exercise 6: Set the workflow parameters#

In the visualization above, the red boxes indicate missing values; parameters required by the computation that have yet to be set on the workflow.

Using the wf[TYPE] = VALUE syntax, set the missing parameters on the workflow.

Once you have done so, use wf.compute(NormalizedDspacing) to compute the final normalized result for the Si and LBCO samples, remembering to update the Foldername[SampleRun] for each case.

Solution:

Exercise 7 (optional): Modify the dspacing binning#

Change the number of bins used in the dspacing dimension on the workflow, and recompute the result.

Hint: use wf[DspacingBins] = ...

Solution:

Exercise 8: Debugging detector banks#

The detector team suspects that one of the two cylindrical banks is faulty (recording too many counts), and you have to help them find out which one (if any!).

Identify an intermediate result in the workflow graph that contains the necessary information.
Separate the events between left and right detector banks (hint: you can either use masks or smart indexing: da[da.coords['x'] < x0])
Histogram both banks using the dspacing bins
Plot both histograms on the same axes (hint: send a dict to the plotting function pp.plot({"left": left_hist, "right": right_hist}))

Solution:

Powder diffraction data reduction

Contents

Powder diffraction data reduction#

Process the run with a reference sample: Si#

Load the NeXus file data#

Visualize the data#

Coordinate transformations#

Exercise 1: convert raw data to d-spacing#

Histogram the data in d-spacing#

Exercise 2: Correct the time-of-flight#

Time-of-flight at a long-pulsed source#

Finding a new time-distance origin#

Exercise: find a new origin#

Exercise 3: Process the Vanadium run#

Normalize by Vanadium#

Exercise 4: perform the normalization#

Save to disk#

Exercise 5: Process and normalize main sample: LBCO#

Sciline workflow#

Exercise 6: Set the workflow parameters#

Exercise 7 (optional): Modify the dspacing binning#

Exercise 8: Debugging detector banks#