Correlated roughness

Scattering from a multilayered sample with correlated roughness.

  • The sample is composed of a substrate on which is sitting a stack of layers. These layers consist in a repetition of 5 times two different superimposed layers (from bottom to top):
    • layer A: $2.5$ nm thick with a real refractive index $n = 5 \cdot 10^{-6}$.
    • layer B: $5$ nm thick with a real refractive index $n = 10 \cdot 10^{-6}$.
  • There is no added particle.
  • All layers present the same type of roughness on the top surface, which is characterized by:
    • a rms roughness of the interfaces $\sigma = 1$ nm,
    • a Hurst parameter $H$ equal to $0.3$,
    • a lateral correlation length $\xi$ of $5$ nm,
    • a cross correlation length $\xi_{\perp}$ equal to $10^{-4}$ nm.
  • The incident beam is characterized by a wavelength of $1$ $\unicode{x212B}$.
  • The incident angles are $\alpha_i = 0.2 ^{\circ}$ and $\phi_i = 0^{\circ}$.

Note:

The roughness profile is described by a normally-distributed random function. The roughness correlation function at the jth interface is expressed as: $$ < U_j (x, y) U_j (x’, y’)> = \sigma^2 e^{-\frac{\tau}{ξ}2H}, \tau=[(x-x’)^2+(y-y’)^2]^{\frac{1}{2}}$$

  • $U_j(x, y)$ is the height deviation of the jth interface at position $(x, y)$.
  • $\sigma$ gives the rms roughness of the interface. The Hurst parameter $H$, comprised between $0$ and $1$ is connected to the fractal dimension $D=3-H$ of the interface. The smaller $H$ is, the more serrate the surface profile looks. If $H = 1$, the interface has a non fractal nature.
  • The lateral correlation length ξ acts as a cut-off for the lateral length scale on which an interface begins to look smooth. If $\xi \gg \tau$ the surface looks smooth.
  • The cross correlation length $\xi_{\perp}$ is the vertical distance over which the correlation between layers is damped by a factor $1/e$. It is assumed to be the same for all interfaces. If $\xi_{\perp} = 0$ there is no correlations between layers. If $\xi_{\perp}$ is much larger than the layer thickness, the layers are perfectly correlated.

Real-space model

Intensity image

 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
63
64
65
66
67
68
69
70
71
72
"""
MultiLayer with correlated roughness
"""
import bornagain as ba
from bornagain import deg, angstrom, nm


def get_sample():
    """
    Returns a sample with two layers on a substrate, with correlated roughnesses.
    """
    # defining materials
    m_ambience = ba.HomogeneousMaterial("ambience", 0.0, 0.0)
    m_part_a = ba.HomogeneousMaterial("PartA", 5e-6, 0.0)
    m_part_b = ba.HomogeneousMaterial("PartB", 10e-6, 0.0)
    m_substrate = ba.HomogeneousMaterial("substrate", 15e-6, 0.0)

    # defining layers
    l_ambience = ba.Layer(m_ambience)
    l_part_a = ba.Layer(m_part_a, 2.5*nm)
    l_part_b = ba.Layer(m_part_b, 5.0*nm)
    l_substrate = ba.Layer(m_substrate)

    roughness = ba.LayerRoughness()
    roughness.setSigma(1.0*nm)
    roughness.setHurstParameter(0.3)
    roughness.setLatteralCorrLength(5.0*nm)

    my_sample = ba.MultiLayer()

    # adding layers
    my_sample.addLayer(l_ambience)

    n_repetitions = 5
    for i in range(n_repetitions):
        my_sample.addLayerWithTopRoughness(l_part_a, roughness)
        my_sample.addLayerWithTopRoughness(l_part_b, roughness)

    my_sample.addLayerWithTopRoughness(l_substrate, roughness)
    my_sample.setCrossCorrLength(10*nm)

    print(my_sample.treeToString())

    return my_sample


def get_simulation():
    """
    Characterizing the input beam and output detector
    """
    simulation = ba.GISASSimulation()
    simulation.setDetectorParameters(200, -0.5*deg, 0.5*deg,
                                     200, 0.0*deg, 1.0*deg)
    simulation.setBeamParameters(1.0*angstrom, 0.2*deg, 0.0*deg)
    simulation.setBeamIntensity(5e11)
    return simulation


def run_simulation():
    """
    Runs simulation and returns intensity map.
    """
    simulation = get_simulation()
    simulation.setSample(get_sample())
    simulation.runSimulation()
    return simulation.result()


if __name__ == '__main__':
    result = run_simulation()
    ba.plot_simulation_result(result)
CorrelatedRoughness.py