BornAgain ≻ 1.19 ≻ Documentation ≻ Python scripting ≻ Simulations ≻ GISAS

GISAS simulation

In BornAgain, grazing-incidence small-angle scattering (GISAS) is computed using the distorted-wave Born approximation (DWBA).

Example: cylinders on substrate

As an introductory example, we consider a dilute random assembly of monodisperse cylindrical disks on a substrate.

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

#!/usr/bin/env python3
"""
Basic example of a DWBA simulation of a GISAS experiment:
Scattering by a dilute random assembly of cylinders on a substrate.
"""
import bornagain as ba
from bornagain import deg, nm


def get_sample():
    # Define materials
    material_Particle = ba.HomogeneousMaterial("Particle", 6e-4, 2e-08)
    material_Substrate = ba.HomogeneousMaterial("Substrate", 6e-6, 2e-08)
    material_Vacuum = ba.HomogeneousMaterial("Vacuum", 0, 0)

    # Define particles
    ff = ba.FormFactorCylinder(5*nm, 5*nm)
    particle = ba.Particle(material_Particle, ff)

    # Define particle layouts
    layout = ba.ParticleLayout()
    layout.addParticle(particle)
    layout.setTotalParticleSurfaceDensity(0.01)

    # Define layers
    layer_1 = ba.Layer(material_Vacuum)
    layer_1.addLayout(layout)
    layer_2 = ba.Layer(material_Substrate)

    # Define sample
    sample = ba.MultiLayer()
    sample.addLayer(layer_1)
    sample.addLayer(layer_2)

    return sample


def get_simulation(sample):
    # Define beam
    wavelength = 0.1*nm
    alpha_i = 0.2*deg
    beam = ba.Beam(1, wavelength, ba.Direction(alpha_i, 0))

    # Define detector
    nPix = 200  # pixels per direction
    detector = ba.SphericalDetector(nPix, -2*deg, 2*deg, nPix, 0, 3*deg)

    return ba.GISASSimulation(beam, sample, detector)


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

Explanation

The Define materials stance defines three materials in terms of their refractive index. The arguments of the constructor-like global function HomogeneousMaterial are name, delta ($\delta$), beta ($\beta$). The refractive index is set to $n=1-\delta+i\beta$.

The Define layers stance defines two semi-infinite layers, with materials vacuum and substrate.

The Define particles stance selects cylinderical particles. The constructor FormFactorCylinder takes the arguments radius and height. Both are specified as 5 nanometers.

The multiplier nm happens to be 1 because the internal length unit in BornAgain (except for macroscopic detector parameters) is one nanometer. In principle, *nm could be omitted from the code, but we recommend to leave it in the code for the benefit of human readers.

The Define particle layout describes the inter-particle structure. The class ParticleLayout ensures incoherent averaging over different particle decorations. Here we add just one type of particles.

As we specify no interference function, the particle are assumed to be disordered. Excluded volume effects are not accounted for. Otherwise said, the particles are assumed to be dilute.

The function setTotalParticleSurfaceDensity specifies the number of particles per square nanometer.

The Define sample stance constructs a sample by pilig up the above defined layers from top (vacuum) to bottom (substrate). Samples are always of type MultiLayer.

The function get_simulation constructs a GISASSimulation.

The incoming beam is specified using the Beam constructor, which takes the arguments intensity (on an arbitrary scale), wavelength (in nanometer), and direction. The Direction constructor takes angle arguments in radian. Here we specify a glancing angle $\alpha_i = 0.2 ^{\circ}$, and a horizontal deviation $\varphi_i = 0$.

The SphericalDetector provides a two-dimensional histogram for representing the spatial distribution of the scattering intensity. The two coordinate axes are glancing angle $\alpha$ and horizontal declination $\varphi$. The constructor takes the arguments number-of-bins, lower-limit-angle, upper-limit-angle in $\alpha$ and $\varphi$. For details and alternatives, see the detector section.

The Main program has been explained in the Syntax page. For alternative ways of running simulations and plotting or exporting results, see section Plot and export.

Further reading