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 a 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 uncorrelated particles

To add a dilute random assembly of uncorrelated particles to a layer, use depositParticle or suspendParticle:

layer.depositParticle(density, particle)
layer.suspendParticle(density, particle)

With depositParticle, the bottom of the particle is placed at the layer’s bottom interface. This is appropriate for particles sitting on a substrate. This method is only valid for finite-thickness layers.

With suspendParticle, the top of the particle is placed at the layer’s top interface. This is appropriate for particles hanging from below an interface, such as particles embedded in a substrate just below its top surface.

For variants and details, see Particle assembly > Disorder.

Add 2D particle structures

To add a 2D particle structure (particles on a surface) 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 just below its top surface.

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

Soft particles at interfaces

For soft particles (like FuzzySphere and GaussSphere) that have diffuse boundaries, use ParticleAlignment_Centered to place the particle center at the interface:

layer.deposit2D(ba.Dilute2D(density, soft_particle, ba.ParticleAlignment_Centered))

For an example, see SoftSpheres.

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.

Add 3D particle structures

To add a 3D particle structure (particles filling a volume) to a layer:

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

#!/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
    material_substrate = ba.RefractiveMaterial("Substrate", 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, ba.AlignAt_Top)

    # 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(material_substrate)
    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()
    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 centered alignment: soft spheres placed at a substrate interface. Since FuzzySphere has a diffuse boundary, we use ParticleAlignment_Centered to place the particle center at the interface.

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

#!/usr/bin/env python3
"""
Soft spheres (FuzzySphere) placed at a substrate using deposit2D.
Soft particles have diffuse boundaries, so their center is at the interface.
"""
import bornagain as ba
from bornagain import ba_plot as bp, deg, nm, nm2


def get_sample():
    """
    Soft spheres on a substrate. Since FuzzySphere is a soft particle,
    we use deposit2D with centered alignment to place their centers at
    the interface.
    """

    # Materials
    material_particle = ba.RefractiveMaterial("Particle", 0.0006, 2e-08)
    material_substrate = ba.RefractiveMaterial("Substrate", 6e-06, 2e-08)
    vacuum = ba.Vacuum()

    # Soft particle (Fuzzy sphere with Gaussian fuzziness)
    ff = ba.FuzzySphere(5*nm, 0.5*nm)
    particle = ba.Particle(material_particle, ff, ba.AlignAt_Center)

    # Layers
    layer_top = ba.Layer(vacuum)
    layer_top.deposit2D(ba.Dilute2D(0.001/nm2, particle))
    layer_substrate = ba.Layer(material_substrate)

    # Sample
    sample = ba.Sample()
    sample.addLayer(layer_top)
    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()
    simulation = get_simulation(sample)
    result = simulation.simulate()
    bp.plot_datafield(result, unit_aspect=1)
    bp.plt.show()
auto/Examples/scatter2d/SoftSpheres.py

History

Functions depositParticle, suspendParticle, deposit2D, suspend2D, fill3D, and fill3DRandom were introduced in BornAgain 24, replacing function addLayout. The entire concept of a particle Layout has become unnecessary and was removed in BornAgain 24.

In BornAgain 25, ParticleAlignment was introduced to control particle positioning relative to the reference plane. Use ParticleAlignment_Centered for soft particles.