BornAgain ≻ git-develop ≻ Documentation ≻ Examples ≻ GISAS ≻ Structures and correlations ≻ Rectangular grating

Rectangular grating

This example models a grating as very long boxes arranged by Crystal1D. Rotating both the boxes and their lattice changes the grating orientation while keeping each box aligned with the grating lines. Monte Carlo integration suppresses rapid within-bin oscillations of the large-particle form factor.

Result

Rectangular grating result

Sample

Rectangular grating 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
63
64
65
66
67
68
69
70
71
72

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# dependencies = ["bornagain>=25,<26"]
# ///
"""
Simulation of grating using very long boxes and 1D lattice.
Monte-carlo integration is used to get rid of
large-particle form factor oscillations.
"""
import bornagain as ba
ba.require_versions("bornagain>=25,<26")
from bornagain import deg, micrometer, nm


def get_sample(lattice_rotation_angle=0*deg):
    """
    A sample with a grating on a substrate.
    lattice_rotation_angle = 0 - beam parallel to grating lines
    lattice_rotation_angle = 90*deg - beam perpendicular to grating lines
    """
    # Materials
    vacuum = ba.Vacuum()
    si_color = (0.30, 0.62, 0.86)
    si_mat = ba.RefractiveMaterial("Si", si_color, 5.7816e-6, 1.0229e-7)

    box_length, box_width, box_height = 50*micrometer, 70*nm, 50*nm
    lattice_length = 150*nm

    box_ff = ba.LongBoxLorentz(box_length, box_width, box_height)
    box = ba.Particle(si_mat, box_ff)
    box.rotate(ba.RotationZ(lattice_rotation_angle))

    # Particle layout
    layout = ba.Crystal1D(box, lattice_length,
                          90*deg - lattice_rotation_angle,
                          1/box_length)
    profile = ba.Profile1DGauss(450)
    layout.setDecayFunction(profile)

    sigma, hurst, corrLength = 5*nm, 0.5, 10*nm
    autocorr = ba.SelfAffineFractalModel(sigma, hurst, corrLength)
    transient = ba.TanhTransient()
    roughness = ba.Roughness(autocorr, transient)

    # Sample
    vacuum_layer = ba.Layer(vacuum)
    vacuum_layer.deposit2D(layout)
    substrate_layer = ba.Layer(si_mat, roughness)

    sample = ba.Sample()
    sample.addLayer(vacuum_layer)
    sample.addLayer(substrate_layer)
    return sample


def get_simulation(sample):
    beam = ba.Beam(1e8, 0.134*nm, 0.4*deg)
    n = 200
    detector = ba.SphericalDetector(n, -0.5*deg, 0.5*deg, n, 0, 0.5*deg)
    simulation = ba.ScatteringSimulation(beam, sample, detector)
    simulation.options().setMonteCarloIntegration(True, 100, seed=0)
    return simulation


if __name__ == '__main__':
    sample = get_sample()
    ba.showSample3D(sample, sample_size=1500*nm, seed=0)
    simulation = get_simulation(sample)
    result = simulation.simulate()
    ba.plot_datafield(result, unit_aspect=1)
    ba.plt.show()
auto/Examples/gisas/order/RectangularGrating.py