BornAgain ≻ git-develop ≻ Documentation ≻ Reference ≻ Sample model ≻ Structure ≻ 2D structures ≻ Size-distribution models

Size-distribution models

Local monodisperse approximation

The LMA approach implies that the layer is laterally divided into domains containing particles of the same size and shape and organized into a certain structure. In this approximation the domains are spatially separated and thus completely independent from each other.

The scattering intensity is incoherently summed over the domains with the corresponding weights.

structure_1 = ba.RadialParacrystal(particle_1, 16.8*nm, 1000*nm)
structure_2 = ba.RadialParacrystal(particle_2, 22.8*nm, 1000*nm)
structure_1.setProbabilityDistribution(profile)
structure_2.setProbabilityDistribution(profile)

layer.addDeposit2D(0.5, structure_1)
layer.addDeposit2D(0.5, structure_2)

Decoupling approximation

The DA approach implies that the particles share the common structure but present there with their individual weights. There is still no coherence between different types of particles.

For ordered structures with multiple particle types, use a Mixture:

mix = ba.Mixture()
mix.addParticle(particle_1, 0.8)
mix.addParticle(particle_2, 0.2)

structure = ba.RadialParacrystal(mix, 18*nm, 1000*nm)
structure.setProbabilityDistribution(profile)
layer.deposit2D(structure)

For a disordered case, use independent dilute structures:

layer.deposit2D(ba.Dilute2D(density_1, particle_1))
layer.deposit2D(ba.Dilute2D(density_2, particle_2))

Size space coupling approximation

Applicable only to radial paracrystal.

The SSCA approach introduces phase shift between different fractions with the common structure. This is done by setting parameter kappa to 1 (it is 0 by default).

mix = ba.Mixture()
mix.addParticle(particle_1, 0.8)
mix.addParticle(particle_2, 0.2)

structure = ba.RadialParacrystal(mix, 18*nm, 1000*nm)
structure.setProbabilityDistribution(profile)
structure.setKappa(1)  # Enable SSCA
layer.deposit2D(structure)

Example

Scattering from a distribution of cylinders of two different sizes, positioned according to the radial paracrystal model.

  • The sample is made of cylinders deposited on a substrate.
  • The distribution of particles is made of:
    • 80% of cylinders with radii and heights equal to $5$ nm
    • 20% of cylinders with radii and heights equal to $8$ nm.
  • The structure is radial paracrystal with a peak distance of $18$ nm and a damping length of $1$ $\mu$m.
  • LMA uses two radial paracrystals with peak distances of $16.8$ and $22.8$ nm.
  • The wavelength is equal to 0.1 nm.
  • The incident angles are $\alpha_i = 0.2 ^{\circ}$ and $\varphi_i = 0^{\circ}$.

The example below compares the scattering patterns of all three approximations.

Scattering intensity

  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
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112

#!/usr/bin/env python3
"""
Cylinders of two different sizes in Decoupling Approximation,
Local Monodisperse Approximation and Size-Spacing Coupling Approximation
"""
import bornagain as ba
from bornagain import ba_plot as bp, deg, nm


def get_sample(approximation):
    """
    A sample with cylinders of two different sizes on a substrate
    in radial paracrystal ordering.
    """

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

    # Particles
    ff_1 = ba.Cylinder(5*nm, 5*nm)
    ff_2 = ba.Cylinder(8*nm, 8*nm)
    particle_1 = ba.Particle(particle_mat, ff_1)
    particle_2 = ba.Particle(particle_mat, ff_2)

    # Layers
    layer_1 = ba.Layer(vacuum)
    layer_2 = ba.Layer(substrate_mat)

    # Distribution function
    profile = ba.Profile1DGauss(3*nm)

    if (not approximation=='LMA' and
        not approximation=='DA' and
        not approximation=='SSCA'):
        raise Exception('Unknown approximation')

    if approximation == 'LMA':
        """
        Local Monodisperse Approximation: two independent layouts
        with their own distinct interference functions
        """
        # Interference functions
        layout_1 = ba.RadialParacrystal(particle_1, 16.8*nm, 1000*nm)
        layout_2 = ba.RadialParacrystal(particle_2, 22.8*nm, 1000*nm)
        layout_1.setProbabilityDistribution(profile)
        layout_2.setProbabilityDistribution(profile)

        # Populate layer with two independent layouts
        layer_1.addDeposit2D(0.5, layout_1)
        layer_1.addDeposit2D(0.5, layout_2)

    else: # 'DA/SSCA'
        # Particle mixture
        mix = ba.Mixture()
        mix.addParticle(particle_1, 4)
        mix.addParticle(particle_2, 1)

        layout = ba.RadialParacrystal(mix, 18*nm, 1000*nm)
        profile = ba.Profile1DGauss(3*nm)
        layout.setProbabilityDistribution(profile)

        """
        The only difference between Decoupling Approximation and
        Size-Spacing Coupling Approximation is that in SSCA there is
        a position phase offset between fractions defined by 'kappa' parameter:
        DA: kappa = 0 (default value)
        SSCA: kappa = 1
        """
        if approximation == 'SSCA':
            layout.setKappa(1)

        # Populate layer with the layout
        layer_1.deposit2D(layout)

    # Sample
    sample = ba.Sample()
    sample.addLayer(layer_1)
    sample.addLayer(layer_2)

    return sample


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


def simulate(approximation):
    sample = get_sample(approximation)
    simulation = get_simulation(sample)
    result = simulation.simulate()
    result.setTitle(approximation)
    return result


if __name__ == '__main__':
    ba.showSample3D(get_sample('LMA'), sample_size=240*nm, seed=0)
    results = [
        simulate('LMA'),
        simulate('DA'),
        simulate('SSCA')
    ]
    bp.plot2d_to_row(results, unit_aspect=1)
    bp.plt.show()
auto/Examples/scatter2d/Approximations.py