Polarized SANS

This example shows how to simulate polarized SANS with BornAgain, using the Born Approximation.

While BornAgain is designed for GISAS experiments (using the Distorted Wave Born Approximation), it naturally also contains the regular (plane wave) Born Approximation. Accordingly, BornAgain can also simulate standard small-angle scattering (SAS).

However, there exist several other specialized SAS softwares. Therefore we do not advertise BornAgain for analysing SAS experiments, and in general we do not provide user support for this application domain. We rather recommend SASView, which is institutionally supported by the European Spallation Source, and was designated as standard SAS software in the European SINE2020 project.

Yet BornAgain can be an appropriate choice in cases where the sample structure or the experimental conditions are not covered by other software. For example, other softwares provide no, or limited, support for polarized SANS. Here, we show how such experiments can be simulated with BornAgain.

The main difference between simulating GISAS and SAS in BornAgain is the presence of only a single layer in the multilayer object. This triggers the software to calculate the differential scattering cross section in the Born Approximation:

multiLayer = ba.MultiLayer()
multiLayer.addLayer(solvent_layer)

The rest of the example script hereafter contains nothing new compared to the previous examples. A sample with a magnetic core-shell particle is constructed. Beam and detector are setup to detect the spin-flip scattering channel and the result of this simulation is plotted as usual.

Intensity images

 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
"""
Simple example demonstrating how polarized SANS experiments can be
simulated with BornAgain.
"""

import bornagain as ba
from bornagain import deg, nm, kvector_t

# Magnetization of the particle's core material (A/m)
magnetization_core = kvector_t(0.0, 0.0, 1e7)


def get_sample():
    """
    Returns a sample with a magnetic core-shell particle in a solvent.
    """
    # Defining Materials
    mat_solvent = ba.HomogeneousMaterial("Solvent", 5e-6, 0.0)
    mat_core = ba.HomogeneousMaterial("Core", 6e-6, 2e-8,
                                      magnetization_core)
    mat_shell = ba.HomogeneousMaterial("Shell", 1e-7, 2e-8)

    # Defining Layer
    solvent_layer = ba.Layer(mat_solvent)

    # Defining particle layout with a core-shell particle
    layout = ba.ParticleLayout()
    core_sphere_ff = ba.FormFactorFullSphere(10*nm)
    shell_sphere_ff = ba.FormFactorFullSphere(12*nm)
    core = ba.Particle(mat_core, core_sphere_ff)
    shell = ba.Particle(mat_shell, shell_sphere_ff)
    position = kvector_t(0.0, 0.0, 2.0)
    particleCoreShell = ba.ParticleCoreShell(shell, core, position)
    layout.addParticle(particleCoreShell)

    # Adding layout to layer
    solvent_layer.addLayout(layout)

    # Defining Multilayer with single layer
    multiLayer = ba.MultiLayer()
    multiLayer.addLayer(solvent_layer)
    return multiLayer


def get_simulation():
    """
    Returns a polarized SANS simulation
    """
    simulation = ba.GISASSimulation()

    # Defining detector
    simulation.setDetectorParameters(200, -3.0*deg, 3.0*deg, 200, -3.0*deg, 3.0*deg)

    # Defining beam parameters
    simulation.setBeamParameters(0.5*nm, 0.0*deg, 0.0*deg)
    simulation.setBeamIntensity(1e12)

    # Defining beam polarization and polarization analysis for spin-flip channel
    analyzer_dir = kvector_t(0.0, 0.0, -1.0)
    beampol = kvector_t(0.0, 0.0, 1.0)
    simulation.setBeamPolarization(beampol)
    simulation.setAnalyzerProperties(analyzer_dir, 1.0, 0.5)

    return simulation


def run_simulation():
    """
    Runs simulation and returns intensity map.
    """
    simulation = get_simulation()
    simulation.setSample(get_sample())
    simulation.runSimulation()
    return simulation.result()


if __name__ == '__main__': 
    result = run_simulation()
    ba.plot_simulation_result(result, cmap='jet', units=ba.AxesUnits.QSPACE,
                              aspect='auto')
PolarizedSANS.py