BornAgain ≻ 1.19 ≻ Documentation ≻ Python scripting ≻ Sample model ≻ Rough interfaces ≻ Simulation with a rough sample

Specular simulation with a rough sample

This example demonstrates how to compute reflected signal from a multilayered sample with surface roughness. All the experiment layout is exactly the same as the one described in reflectometry tutorial, but now all the layers (except the ambient media) have roughness on the top surface. The roughness is characterized by root-mean-square deviation from the mean surface position $\sigma = 1$ nm.

Real-space model

Intensity image

When comparing the result of the simulation to the result obtained in the reflectometry tutorial, one can notice up to two orders of magnitude attenuation of the reflected signal due to the roughness of the sample.

Please note that other roughness characteristics (like Hurst parameter or lateral and cross correlation lengths) previously described in example on correlated roughness do not affect the result of the simulation. The computation model takes into account only the rms-deviation from the mean surface position.
 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

#!/usr/bin/env python3
"""
Example of simulating a reflectometry experiment
with a rough sample using BornAgain.

"""
import bornagain as ba
from bornagain import deg, angstrom, nm


def get_sample():
    """
    Defines sample and returns it
    """

    # creating materials
    m_ambient = ba.MaterialBySLD("Ambient", 0, 0)
    m_ti = ba.MaterialBySLD("Ti", -1.9493e-06, 0)
    m_ni = ba.MaterialBySLD("Ni", 9.4245e-06, 0)
    m_substrate = ba.MaterialBySLD("SiSubstrate", 2.0704e-06, 0)

    # creating layers
    ambient_layer = ba.Layer(m_ambient)
    ti_layer = ba.Layer(m_ti, 30*angstrom)
    ni_layer = ba.Layer(m_ni, 70*angstrom)
    substrate_layer = ba.Layer(m_substrate)

    # defining roughness
    roughness = ba.LayerRoughness()
    roughness.setSigma(1*nm)

    # creating multilayer
    multi_layer = ba.MultiLayer()
    multi_layer.addLayer(ambient_layer)
    for i in range(10):
        multi_layer.addLayerWithTopRoughness(ti_layer, roughness)
        multi_layer.addLayerWithTopRoughness(ni_layer, roughness)
    multi_layer.addLayerWithTopRoughness(substrate_layer, roughness)

    return multi_layer


def get_simulation(sample, scan_size=500):
    """
    Defines and returns a specular simulation.
    """
    simulation = ba.SpecularSimulation()
    scan = ba.AngularSpecScan(1.54*angstrom, scan_size, 0, 2*deg)
    simulation.setScan(scan)
    simulation.setSample(sample)
    return simulation


if __name__ == '__main__':
    import ba_plot
    sample = get_sample()
    simulation = get_simulation(sample)
    ba_plot.run_and_plot(simulation)
SpecularSimulationWithRoughness.py