BornAgain ≻ git-develop ≻ Documentation ≻ Examples ≻ Specular ≻ Basics ≻ Solid-liquid interface

Solid-liquid interface

Buried interfaces, for instance between a solid and a liquid, can be studied by sending the beam through the solid. In neutron reflectometry and GISANS, the beam typically enters a silicon or sapphire block through one of its side faces and is reflected at the interface between the solid and the liquid, at the opposite face of the block. Examples are studies of micelles under shear (Hamilton et al. 1994), of the crystallization of micelles (Wolff et al. 2004), and of colloids below an interface (Nouhi et al. 2017).

In BornAgain, the sample is described with the liquid on top and the solid block as substrate. A negative grazing angle denotes a beam that comes from below, through the substrate. As for a beam from above, the angle is the actual glancing angle in the medium of incidence, here the sapphire. The refraction at the side face of the block, where the beam enters, is not modeled: the side face is assumed to be perpendicular to the beam, or its effect to be accounted for by the user.

This example compares a bare sapphire/D₂O interface with one carrying a 30 nm thick titanium film. Since the scattering-length density of D₂O exceeds that of sapphire, the beam is totally reflected below the critical angle of about 0.16°. Above the critical angle, the Ti film produces pronounced interference fringes: its scattering-length density is negative, far below that of either neighbor, whereas the bare interface reflects only weakly because sapphire and D₂O have similar scattering-length densities.

Notes:

  • QzScan does not support beams from below; use AlphaScan or LambdaScan.
  • For polarized neutrons and a magnetized substrate, all magnetic fields must be parallel or antiparallel to the field of the substrate.

Result

Solid-liquid interface result

Sample

Solid-liquid interface sample

Python script

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# dependencies = ["bornagain>=25,<26"]
# ///
"""
Neutron reflectometry at a buried solid-liquid interface.

The beam enters a sapphire block through a side face and is reflected at
the interface between sapphire and heavy water (D2O), with or without a
thin titanium film deposited on the sapphire. In the sample, the liquid
is on top and the sapphire block is the substrate; a negative grazing
angle denotes a beam that comes from below, through the substrate. The
angle is the glancing angle inside the sapphire.

Since the scattering-length density of D2O exceeds that of sapphire, the
beam is totally reflected below the critical angle. Above it, the Ti
film, whose scattering-length density is far below that of either
neighbor, produces pronounced interference fringes.
"""
import bornagain as ba
ba.require_versions("bornagain>=25,<26")
from bornagain import angstrom, deg, nm


def get_sample(with_layer):
    d2o_color = (0.55, 0.75, 0.95)
    d2o = ba.SLDMaterial("D2O", d2o_color, 6.36e-6, 0)
    ti_color = (0.55, 0.55, 0.60)
    ti = ba.SLDMaterial("Ti", ti_color, -1.95e-6, 0)
    sapphire_color = (0.30, 0.62, 0.86)
    sapphire = ba.SLDMaterial("Sapphire", sapphire_color, 5.70e-6, 0)

    autocorr = ba.SelfAffineFractalModel(0.3*nm, 0.7, 25*nm)
    roughness = ba.Roughness(autocorr, ba.ErfTransient())

    sample = ba.Sample()
    sample.addLayer(ba.Layer(d2o))
    if with_layer:
        sample.addLayer(ba.Layer(ti, 30*nm, roughness))
    sample.addLayer(ba.Layer(sapphire, roughness))
    return sample


def simulate(with_layer, title):
    n = 500
    # Negative angles: the beam comes from below, through the substrate.
    scan = ba.AlphaScan(n, -2*deg, -2*deg/n)
    scan.setWavelength(6*angstrom)
    result = ba.SpecularSimulation(scan, get_sample(with_layer)).simulate()
    result.setTitle(title)
    return result


if __name__ == '__main__':
    ba.showSample3D(get_sample(True), sample_size=60*nm, seed=0)
    results = [
        simulate(False, "sapphire / D2O"),
        simulate(True, "sapphire / Ti / D2O"),
    ]
    ba.plot_multicurve(results)
    ba.plt.show()
auto/Examples/specular/basics/SolidLiquidInterface.py