BornAgain ≻ 1.19 ≻ Documentation ≻ Python scripting ≻ Instrument model ≻ Neutron polarization ≻ Spin-flip reflectivity

Spin-flip reflectivity

In this section, we want to extend the basic polarized reflectometry tutorial to simulate spin-flip reflectivity. For this purpose, we want to parametrize the magnetization by the angle $\alpha$ between the magnetization and the spin of the incoming neutrons and its magnitude $\left| \mathbf{M} \right|$: $$\mathbf M = \left| \mathbf{M} \right| \left( \sin \alpha, \cos \alpha, 0\right)^\mathrm{T}$$ In practice, the construction of the magnetization vector in Python then proceeds as follows: 

magnetizationMagnitude = 1e8
angle                  = 30 * deg
magnetizationVector    = ba.kvector_t(
                magnetizationMagnitude * numpy.sin(angle), 
                magnetizationMagnitude * numpy.cos(angle), 
                0)

In addition to the non-spin-flip channels, we simulate the spin-flip channels (up-down and down-up) with the following function calls

results_pm = run_simulation(ba.kvector_t(0,  1, 0),
                            ba.kvector_t(0, -1, 0))
results_mp = run_simulation(ba.kvector_t(0, -1, 0),
                            ba.kvector_t(0,  1, 0))

Running the full script, that is given below, we obtain the following simulation result:

Reflectivity

This plot shows the resulting reflectivity in all four channels. The non-spin-flip channels (up-up and down-down) are similar to the result without spin flip. As expected, both spin-flip channels are identical.

Here is the complete example:

 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

#!/usr/bin/env python3
"""
An example of computing splin-flip reflectivity from
a magnetized sample.
"""
import numpy
import bornagain as ba
from bornagain import angstrom, deg, nm, nm2, kvector_t
import matplotlib.pyplot as plt
from math import sqrt

def get_sample():
    """
    Defines sample and returns it
    """

    # Define materials
    material_Ambient = ba.MaterialBySLD("Ambient", 0, 0)
    h = 1e8
    magnetic_field = kvector_t(1/2*h, sqrt(3)/2*h, 0)
    material_Layer = ba.MaterialBySLD("Layer", 0.0001, 1e-08,
                                      magnetic_field)
    material_Substrate = ba.MaterialBySLD("Substrate", 7e-05, 2e-06)

    # Define layers
    layer_1 = ba.Layer(material_Ambient)
    layer_2 = ba.Layer(material_Layer, 10*nm)
    layer_3 = ba.Layer(material_Substrate)

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

    return sample


def get_simulation(sample, scan_size=500):
    """
    Defines and returns a specular simulation.
    """
    simulation = ba.SpecularSimulation()
    scan = ba.AngularSpecScan(1.54*angstrom, scan_size, 0, 5*deg)
    simulation.setScan(scan)
    simulation.setSample(sample)
    return simulation


def run_simulation(polarization=ba.kvector_t(0, 1, 0),
                   analyzer=ba.kvector_t(0, 1, 0)):
    """
    Runs simulation and returns its result.
    """
    sample = get_sample()
    simulation = get_simulation(sample)

    # adding polarization and analyzer operator
    simulation.beam().setPolarization(polarization)
    simulation.detector().setAnalyzerProperties(analyzer, 1, 0.5)

    simulation.runSimulation()
    return simulation.result()


def plot(data, labels):

    plt.figure()
    for d, l in zip(data, labels):
        plt.semilogy(d.axis(), d.array(), label=l, linewidth=1)

    plt.legend(loc='upper right')
    plt.gca().yaxis.set_ticks_position('both')
    plt.gca().xaxis.set_ticks_position('both')

    plt.xlabel(r"$\alpha_i$ [deg]")
    plt.ylabel("Reflectivity")

    plt.tight_layout()
    plt.show()


if __name__ == '__main__':
    results_pp = run_simulation(ba.kvector_t(0, 1, 0),
                                ba.kvector_t(0, 1, 0))
    results_mm = run_simulation(ba.kvector_t(0, -1, 0),
                                ba.kvector_t(0, -1, 0))

    results_pm = run_simulation(ba.kvector_t(0, 1, 0),
                                ba.kvector_t(0, -1, 0))
    results_mp = run_simulation(ba.kvector_t(0, -1, 0),
                                ba.kvector_t(0, 1, 0))

    plot([results_pp, results_mm, results_pm, results_mp],
         ["$++$", "$--$", "$+-$", "$-+$"])
PolarizedSpinFlip.py