A multilayer fitting model#

One of the main tools in EasyReflectometry is the item library. This allows the user to define their model, using specific parameters for their system of interest (if it is included in the item library). These items will impose necessary constraints and computational efficiencies based on the item that is used.

In this tutorial, we will look at one of these items, that of a RepeatingMultiLayer (documented here). This tutorial is based on an example from the BornAgain documentation looking at specular reflectivity analysis. Before performing analysis, we should import the packages that we need.

[1]:

import numpy as np
import scipp as sc
import EasyReflectometry
import refl1d
from EasyReflectometry.data import load
from EasyReflectometry.sample import Layer, Structure
from EasyReflectometry.sample.material import Material
from EasyReflectometry.sample.item import RepeatingMultiLayer
from EasyReflectometry.experiment.model import Model
from EasyReflectometry.interface import InterfaceFactory as Interface
from EasyReflectometry.fitting import Fitter
from EasyReflectometry.plot import plot

As mentioned in the previous tutorial, we share the version of the software packages we will use.

[2]:

print(f'numpy: {np.__version__}')
print(f'scipp: {sc.__version__}')
print(f'EasyReflectometry: {EasyReflectometry.__version__}')
print(f'Refl1D: {refl1d.__version__}')

numpy: 1.23.3
scipp: 0.13.1
EasyReflectometry: 0.0.2
Refl1D: 0.8.15

Building our model#

The system that was used to produce the data shown above is based on a silicon subphase, with a repeating multilayer of nickel and titanium grown upon it. Typcially, under experimental conditions, the producer of the sample will know how many repeats there will be of the multilayer system (as these are grown using some vapour disposition or sputtering method that the producer controls). We show the model that will be used graphically below.

A slab model description of the repeating multilayer system.

A slab model description of the repeating multilayer, showing the four layers of vacuum, titanium, nickel and silicon, with the titanium/nickel layers being repeated 10 times.

To construct such a layer structure, first we create each of the materials and associated layers

[5]:

vacuum = Material.from_pars(0, 0, 'Vacuum')
ti = Material.from_pars(-1.9493, 0, 'Ti')
ni = Material.from_pars(9.4245, 0, 'Ni')
si = Material.from_pars(2.0704, 0, 'Si')

[6]:

superphase = Layer.from_pars(vacuum, 0, 0, 'Vacuum Superphase')
ti_layer = Layer.from_pars(ti, 40, 0, 'Ti Layer')
ni_layer = Layer.from_pars(ni, 70, 0, 'Ni Layer')
subphase = Layer.from_pars(si, 0, 0, 'Si Subphase')

Then, to produce the repeating multilayer, we use the RepeatingMultilayer item type. This can be constructed in a range of different ways, however here we pass a list of Layer type objects and a number of repetitions.

[7]:

rep_multilayer = RepeatingMultiLayer.from_pars([ti_layer, ni_layer], repetitions=10, name='NiTi Multilayer')
rep_multilayer

[7]:

NiTi Multilayer:
  Ti Layer/Ni Layer:
  - Ti Layer:
      material:
        Ti:
          sld: -1.949e-6 1 / angstrom ** 2
          isld: 0.000e-6 1 / angstrom ** 2
      thickness: 40.000 angstrom
      roughness: 0.000 angstrom
  - Ni Layer:
      material:
        Ni:
          sld: 9.425e-6 1 / angstrom ** 2
          isld: 0.000e-6 1 / angstrom ** 2
      thickness: 70.000 angstrom
      roughness: 0.000 angstrom
  repetitions: 10.0

From these objects, we can construct our structure and combine this with a scaling, background and resolution (since this data is simulated there is no background or resolution smearing).

[8]:

structure = Structure.from_pars(superphase, rep_multilayer, subphase, name='Multilayer Structure')
model = Model.from_pars(structure, 1, 0, 0, 'Multilayer Model')

In the analysis, we will only vary a single parameter, the thickness of titanium layer.

[9]:

ti_layer.thickness.bounds = (10, 60)

Choosing our calculation engine#

In the previous tutorial, we used the default refnx engine for our analysis. Here, we will change our engine to be Refl1D. This is achieved with the interface.switch('refl1d') method below.

[10]:

interface = Interface()
interface.switch('refl1d')
model.interface = interface
print(interface.current_interface.name)

refl1d

Performing an optimisation#

The easyScience framework allows us to access a broad range of optimisation methods. Below, we have selected the differential evolution method from lmfit.

[11]:

fitter = Fitter([model], [interface.fit_func])
analysed = fitter.fit(data, method='differential_evolution')
analysed

/opt/hostedtoolcache/Python/3.9.14/x64/lib/python3.9/site-packages/easyCore/Utils/UndoRedo.py:460: UnitStrippedWarning: The unit of the quantity is stripped when downcasting to ndarray.
  if new_value == old_value:

We can visualise the analysed model and SLD profile with the plot function.

[12]:

plot(analysed)

[12]:

The value of the titanium layer thickness that gives this best fit can be found from the relavant object. Note that the uncertainty of 0 is due to the use of the lmfit differential evolution algorithm, which does not include uncertainty analysis.

[13]:

ti_layer.thickness.value

[13]:

(29.98794608575187 ± 0) angstrom

This result of a thickness of 30 Å is the same as that which is used to produce the data.

A multilayer fitting model

Contents

A multilayer fitting model#

Reading in experimental data#

Building our model#

Choosing our calculation engine#

Performing an optimisation#