Visualizing and reducing WFM imaging data with Scipp¶

How to start¶

Before starting you must:

Have conda installed
conda env create -f ess-notebooks-stable.yml python=3.7 . The yaml environment file is part of this repository.
fetch the data git clone git@github.com:scipp/ess-notebooks-data.git somewhere local
Generate the dataconfig.py file using make_config.py located in same directory as this notebook. In general, you simply need to point make_config.py to the root directory of data you cloned above. Refer to the help make_config.py --help for more information.

Experimental Summary¶

This script has been developed to measure local strain \(\varepsilon\) defined as \(\varepsilon = \Delta L/L_{0}\) in a FCC steel sample under elastic strain in a stress rig. The measurements were measured at V20, HZB, Berlin, in September 2018 by Peter Kadletz.

\(\lambda = 2 d \sin\theta\), where \(2\theta = \pi\) (transmission), edges characterise the Bragg condition and hence \(\lambda = 2 d\). Therefore strain is easily computed from the wavelength measurement of a Bragg edge directly, using un-loaded vs loaded experimental runs (and reference mesurements).

The known Miller indices of the crystal structure (FCC) are used to predict the wavelength of the Bragg edges, which is bound by the reachable wavelength extents of the instrument. This provides an approximate region to apply a fit. A complement error function is used to fit each Bragg edge, and a refined centre location (\(\lambda\)) for the edge is used in the strain measurement. Because each Bragg edge can be identified individually, one can determine anisotropic strain across the unit cell in the reachable crystallographic directions.

2d0d5d041e674aa09170551863bb4083

Setup¶

[1]:

import numpy as np
import matplotlib.pyplot as plt
plt.ioff()

import scipp as sc
import scippneutron as sn
from scipp import plot

import os
import sys

import ess.v20.imaging as imaging
import ess.wfm as wfm

import dataconfig

local_data_path = os.path.join('ess-notebooks', 'v20', 'imaging',
                               'gp2-stress-experiments')
data_dir = os.path.join(dataconfig.data_root, local_data_path)
instrument_file = os.path.join(data_dir, 'V20_Definition_GP2.xml')
tofs_path = os.path.join(data_dir, 'GP2_Stress_time_values.txt')
raw_data_dir = os.path.join(data_dir)

[2]:

def load_component_info(file, advanced_geometry=False):
    instrument = sn.load(filename=file,
                         mantid_alg='LoadEmptyInstrument',
                         mantid_args={'StoreInADS': False})
    geometry = {key: value for key, value in instrument.coords.items()}
    # Assume the detector is square
    npix = int(np.sqrt(instrument.sizes["spectrum"]))
    geometry["position"] = sc.fold(geometry["position"],
                                   dim='spectrum', dims=['y', 'x'], shape=[npix, npix])
    geometry["x"] = geometry["position"].fields.x['y', 0]
    geometry["y"] = geometry["position"].fields.y['x', 0]
    del geometry["spectrum"]
    del geometry["empty"]
    return geometry

Bragg edge fitting¶

We will first carry out Bragg-edge fitting on the sum of all counts in the sample.

Calculate expected Bragg edge positions¶

[24]:

def create_Braggedge_list(lattice_constant, miller_indices):
    '''
    :param miller-indices: like [(1,1,0),(2,0,0),...]
    :type miller-indices: list of tuples
    '''
    coords = [str((h, k, l)) for h, k, l in miller_indices]
    interplanar_distances = [
        2. * lattice_constant / np.sqrt(h**2 + k**2 + l**2)
        for h, k, l in miller_indices
    ]

    d = sc.DataArray(
        sc.array(dims=["bragg-edge"],
                 values=np.array(interplanar_distances),
                 unit=sc.units.angstrom))
    d.coords["miller-indices"] = sc.array(dims=["bragg-edge"],
                                          values=coords)
    return d

[25]:

# Bragg edge position, in Angstrom, taken from COD entry 9008469
FCC_a = 3.5

# These miller indices for the given unit cell yield bragg edges
# between the maximum and minimum wavelength range.
indices_FCC = [(1, 1, 1), (2, 0, 0), (2, 2, 0), (3, 1, 1)]

Bragg_edges_FCC = create_Braggedge_list(FCC_a, indices_FCC)
sc.table(Bragg_edges_FCC)

Run the fitting (currently using Mantid under the hood)¶

[26]:

def fit(Bragg_edges_FCC, reference, quiet=False):
    """
    Fit a list of Bragg edges using Mantid.
    """

    x_min_sides = [0.05, 0.1, 0.1, 0.05]
    x_max_sides = [0.1, 0.05, 0.1, 0.1]
    fit_list = []

    for edge_index in range(Bragg_edges_FCC.shape[0]):

        bragg_edge = Bragg_edges_FCC.coords["miller-indices"]["bragg-edge",
                                                              edge_index]

        # Initial guess
        xpos_guess = Bragg_edges_FCC["bragg-edge", edge_index].value
        x_min_fit = xpos_guess - xpos_guess * abs(x_min_sides[edge_index])
        x_max_fit = xpos_guess + xpos_guess * abs(x_max_sides[edge_index])

        if not quiet:
            print(
                "Now fitting Bragg edge {} at {:.3f} A (between {:.3f} A and {:.3f} A) across image groups"
                .format(bragg_edge, xpos_guess, x_min_fit, x_max_fit))

        # Call Mantid fitting
        params_s, diff_s = sn.mantid.fit(
            reference,
            mantid_args={
                'Function':
                f'name=LinearBackground,A0={270},A1={-10};name=UserFunction,Formula=h*erf(a*(x-x0)),h={200},a={-11},x0={xpos_guess}',
                'StartX': x_min_fit,
                'EndX': x_max_fit
            })

        v_and_var_s = [
            params_s.data['parameter', i]
            for i in range(params_s['parameter', :].shape[0])
        ]
        params = dict(zip(params_s.coords["parameter"].values, v_and_var_s))

        fit_list.append(params)

    return fit_list

[27]:

fit_params = fit(Bragg_edges_FCC, reference=summed["sample"])

Now fitting Bragg edge <scipp.Variable> ()     string  [dimensionless]  ["(1, 1, 1)"] at 4.041 A (between 3.839 A and 4.446 A) across image groups
Now fitting Bragg edge <scipp.Variable> ()     string  [dimensionless]  ["(2, 0, 0)"] at 3.500 A (between 3.150 A and 3.675 A) across image groups
Now fitting Bragg edge <scipp.Variable> ()     string  [dimensionless]  ["(2, 2, 0)"] at 2.475 A (between 2.227 A and 2.722 A) across image groups
Now fitting Bragg edge <scipp.Variable> ()     string  [dimensionless]  ["(3, 1, 1)"] at 2.111 A (between 2.005 A and 2.322 A) across image groups

[28]:

import scipy as sp
fig, ax = plt.subplots()
summed["sample"].plot(ax=ax)
for i, f in enumerate(fit_params):
    x = np.linspace(f['f1.x0'].value - 0.3, f['f1.x0'].value + 0.3, 100)
    y=f['f1.h'].value*sp.special.erf(f['f1.a'].value*(x-f['f1.x0'].value)) + (f['f0.A0'].value + f['f0.A1'].value*x)
    ax.plot(x, y, color="C{}".format(i+1), label=Bragg_edges_FCC.coords['miller-indices'].values[i])
ax.legend()
fig

[28]:

../_images/imaging_bragg-edge-imaging-2D_43_0.png

Create a strain map¶

We can create a strain map by fitting the Bragg edges inside each tile of the image.

[29]:

# Make an empty container to receive the strain values
strain_map = sc.zeros_like(normalized["sample_elastic"]["wavelength", 0])

iprog = 0
step = 5

# Loop over all the tiles
for j in range(nbins):
    for i in range(nbins):

        prog = int(100 * (i + j*nbins) / (nbins*nbins))
        if prog % step == 0 and prog == iprog:
            print(prog, "% complete")
            iprog += step

        if sc.greater(sc.sum(normalized["sample_elastic"]['y', j]['x', i], "wavelength").data,
                      0.0*sc.units.one).value:
            elastic_fit = fit(Bragg_edges_FCC,
                                    reference=normalized["sample_elastic"]['y', j]['x', i], quiet=True)
            strain_map['y', j]['x', i] = sc.values(0.5 * (elastic_fit[0]['f1.x0'] - fit_params[0]['f1.x0']))

0 % complete
5 % complete
10 % complete
15 % complete
20 % complete
25 % complete
30 % complete
35 % complete
40 % complete
45 % complete
50 % complete
55 % complete
60 % complete
65 % complete
70 % complete
75 % complete
80 % complete
85 % complete
90 % complete
95 % complete

[30]:

plot(strain_map, vmin=-0.02*sc.units.one, vmax=0.02*sc.units.one,
     cmap="RdBu", title="Lattice strain $\epsilon$ (1, 1, 1)", resampling_mode='mean')

Visualizing and reducing WFM imaging data with Scipp¶

How to start¶

Experimental Summary¶

Setup¶

Reduction¶

Load the data files and instrument geometry¶

Raw data visualization¶

Converting time coordinate to TOF¶

Crop to relevant Tof section¶

Transmission Masking¶

Convert to wavelength¶

Apply mean filter¶

Other visualizations¶

Show difference between sample and elastic¶

Group detector pixels to increase signal to noise¶

Normalization¶

Bragg edge fitting¶

Calculate expected Bragg edge positions¶

Run the fitting (currently using Mantid under the hood)¶

Create a strain map¶