BornAgain ≻ git-develop ≻ Documentation ≻ Reference ≻ Sample model ≻ Multilayer ≻ Layer

Class Layer

A Sample and LayerStack contain one or several instances of class Layer.

Create an instance

A Layer instance is created by one of the constructor calls

ba.Layer(material)
ba.Layer(material, roughness)
ba.Layer(material, thickness)
ba.Layer(material, thickness, roughness)

For the first argument, see Material.

The optional thickness argument is the layer thickness in nm. If it is omitted, then the thickness is set to infinite, and the layer can be used as top or bottom of a multi-layer sample, or as the sole component of a single-layer sample.

For the optional roughness argument, see Roughness.

Add 2D particle structures

To add particles on a surface or interface, first create a 2D structure:

structure = ba.Dilute2D(density, particle)

Then add it to a layer:

layer.deposit2D(structure)
layer.addDeposit2D(coverage, structure)
layer.suspend2D(structure)
layer.addSuspend2D(coverage, structure)

With deposit2D and addDeposit2D, the bottom of particles is placed at the layer’s bottom interface. This is appropriate for particles sitting on a substrate. These methods are only valid for finite-thickness layers.

With suspend2D and addSuspend2D, the top of particles is placed at the layer’s top interface. This is appropriate for particles hanging from below an interface, such as holes or inclusions embedded in a substrate.

For argument structure, see Particle assembly. For an example using suspend2D, see HolesLattice.

For an incoherent mixture of different structures, call addDeposit2D or addSuspend2D several times, with a coverage argument between 0 and 1. If coverage is 1, the simpler forms deposit2D or suspend2D can be used.

Soft particles at interfaces

Soft particles such as FuzzySphere and GaussSphere have diffuse boundaries. To place their center away from the default anchor plane, translate the particle before creating the 2D structure:

particle.translate(0, 0, z_shift)
layer.deposit2D(ba.Dilute2D(density, particle))

For an example, see SoftSpheres.

Add 3D particle structures

To add particles distributed through a layer volume, create a 3D structure and add it to the layer:

structure = ba.Dilute3D(volume_density, particle)

layer.fill3D(structure)
layer.add3D(coverage, structure)

For argument structure, see Particle assembly.

For an incoherent mixture of different structures, call add3D several times, with a coverage argument between 0 and 1. If coverage is 1, the simpler form fill3D can be used.

Impose slicing

To divide the layer into n slices for the reflectivity computation, use

layer.setNumberOfSlices(n)

Example: HolesLattice

The following example demonstrates suspend2D: a hexagonal lattice of hemispherical vacuum holes in a substrate. The holes are half-spheres of vacuum material, suspended from the substrate’s top interface so they extend downward into the substrate.

GISAS from hemispherical holes in a substrate

 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
"""
Hexagonal lattice of hemispherical holes in a substrate
"""
import bornagain as ba
from bornagain import ba_plot as bp, deg, nm


def get_sample():
    """
    Substrate with hemispherical holes arranged in a hexagonal lattice.
    The holes are vacuum half-spheres suspended from the substrate top interface.
    """
    # Materials
    substrate_color = (0.28, 0.57, 0.82)
    substrate_mat = ba.RefractiveMaterial("Substrate", substrate_color, 6e-6, 2e-8)
    vacuum = ba.Vacuum()

    # Hemispherical hole (vacuum half-sphere, spanning from -R to 0)
    R = 5*nm
    ff = ba.SphericalSegment(R, R, 0)  # radius, top_cut=R, bottom_cut=0
    hole = ba.Particle(vacuum, ff)

    # Hexagonal lattice
    lattice = ba.HexagonalLattice2D(20*nm, 0)
    layout = ba.Crystal2D(hole, lattice)
    profile = ba.Profile2DCauchy(100*nm, 100*nm, 0)
    layout.setDecayFunction(profile)

    # Layers
    vacuum_layer = ba.Layer(vacuum)
    substrate_layer = ba.Layer(substrate_mat)
    substrate_layer.suspend2D(layout)
    substrate_layer.setNumberOfSlices(6)

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

    return sample


def get_simulation(sample):
    beam = ba.Beam(1e9, 0.1*nm, 0.2*deg)
    n = 200
    detector = ba.SphericalDetector(n, -2*deg, 2*deg, n, 0, 2*deg)
    simulation = ba.ScatteringSimulation(beam, sample, detector)
    return simulation


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

Example: SoftSpheres

The following example demonstrates soft particles in a finite layer. The particle is translated before deposition so that the diffuse sphere is placed inside the film.

GISAS from soft spheres at a substrate interface

 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
"""
Soft spheres (FuzzySphere) in a finite layer.

Soft particles have diffuse boundaries modelled by a Debye-Waller factor.
Slicing is not supported for soft particles; material averaging is disabled.

The layer thickness is 8*R. The particle center is shifted up by 4*R (= thickness/2)
so that almost all of the particle sits inside the finite layer.
"""
import bornagain as ba
from bornagain import ba_plot as bp, deg, nm, nm2


def get_sample():
    R = 5 * nm
    thickness = 8 * R  # 40 nm

    # Materials
    particle_color = (0.86, 0.24, 0.18)
    particle_mat = ba.RefractiveMaterial("Particle", particle_color, 6e-04, 2e-08)
    substrate_color = (0.28, 0.57, 0.82)
    substrate_mat = ba.RefractiveMaterial("Substrate", substrate_color, 6e-06, 2e-08)
    vacuum = ba.Vacuum()

    # Soft particle (FuzzySphere with Gaussian fuzziness)
    ff = ba.FuzzySphere(R, 0.5 * nm)
    particle = ba.Particle(particle_mat, ff)
    # Shift center to thickness/2 (deposit2D anchors the bottom, so compensate)
    particle.translate(0, 0, thickness / 2 - particle.height_below_center())

    # Layers: vacuum / finite film / substrate
    layer_vacuum = ba.Layer(vacuum)
    layer_film = ba.Layer(vacuum, thickness)
    layer_film.deposit2D(ba.Dilute2D(1e-3 / nm2, particle))
    layer_substrate = ba.Layer(substrate_mat)

    # Sample
    sample = ba.Sample()
    sample.addLayer(layer_vacuum)
    sample.addLayer(layer_film)
    sample.addLayer(layer_substrate)

    return sample


def get_simulation(sample):
    beam = ba.Beam(1e9, 0.1 * nm, 0.2 * deg)
    n = 200
    detector = ba.SphericalDetector(n, -2 * deg, 2 * deg, n, 0, 3 * deg)
    simulation = ba.ScatteringSimulation(beam, sample, detector)
    # Disable material averaging (slicing not supported for soft particles)
    simulation.options().setUseAvgMaterials(False)
    return simulation

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

History

The deposit2D, suspend2D, fill3D, and add* methods were introduced in BornAgain 24, replacing addLayout. The entire concept of a particle Layout has become unnecessary and was removed.