BornAgain ≻ 1.19 ≻ Documentation ≻ Python scripting ≻ Sample model ≻ Particles ≻ Magnetic particles

Magnetic particles

This tutorial demonstrates how to include particles with non-zero magnetization.

As an example we are going to use magnetic spherical particles embedded in the substrate of a simple 2-layer system. We will simulate this sample with a polarized beam and use polarization analysis to focus on the spin-flip channel.

Creating materials with magnetization density

Magnetic materials in BornAgain are defined by their refractive index, as for non-mangetic materials, and the magnetization density vector, given in units of A/m. The following code first defines the magnetization density vector and then creates a material with this magnetization.

# Magnetization of the particle's material (A/m)
magnetization_particle = ba.kvector_t(0.0, 0.0, 1e7)
particle_material = ba.HomogeneousMaterial("Particle", 2e-5, 4e-7,
                                           magnetization_particle)

Using the magnetic material for a particle

A magnetic material can be used just as a non-magnetic one when defining particles or layers. For the spherical particle of this example, we use the following code to define it.

# spherical magnetic particle
sphere_ff = ba.FormFactorFullSphere(5*nm)
sphere = ba.Particle(particle_material, sphere_ff)

Defining a polarized beam and polarization analysis

When magnetic materials are present, some of the scattering may appear as spin-flip scattering. This contribution to the scattering can be isolated during an experiment by using a polarized beam and using polarization analysis at the detector.

The polarization state of the beam is fully defined by its Bloch vector, which points in the preferred direction of the neutron’s spin and whose size determines if the neutron is in a mixed or pure state. In this example, we will define a pure state for the neutron, with spin pointing in the positive z-axis.

# define the beam polarization state
beampol = ba.kvector_t(0.0, 0.0, 1.0)
simulation.setBeamPolarization(beampol)

Polarization analysis is defined in BornAgain by the direction along which the spin will be analyzed, the efficiency of the analyzer and the total transmission.

In this example, we will define the analysis to be in negative z-direction to gain information on the spin-flip channel. We set the efficiency to 1 and the total transmission to 0.5.

# define the polarization analysis properties
analyzer_dir = ba.kvector_t(0.0, 0.0, -1.0)
simulation.setAnalyzerProperties(analyzer_dir, 1.0, 0.5)

Complete example

The full example embeds the previously defined spherical particle inside the substrate and simulates the spin-flip channel along the z-axis.

The figure shows the intensity map produced by the script below.

 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

#!/usr/bin/env python3
"""
Simulation demo: magnetic spheres in substrate
"""
import bornagain as ba
from bornagain import deg, nm, kvector_t


def get_sample():
    """
    Returns a sample with magnetic spheres in the substrate.
    """

    # Define materials
    magnetic_field = kvector_t(0, 0, 1e7)
    material_Particle = ba.HomogeneousMaterial("Particle", 2e-05, 4e-07,
                                               magnetic_field)
    material_Substrate = ba.HomogeneousMaterial("Substrate", 7e-06,
                                                1.8e-07)
    material_Vacuum = ba.HomogeneousMaterial("Vacuum", 0, 0)

    # Define form factors
    ff = ba.FormFactorFullSphere(5*nm)

    # Define particles
    particle = ba.Particle(material_Particle, ff)
    particle_position = kvector_t(0, 0, -10*nm)
    particle.setPosition(particle_position)

    # Define particle layouts
    layout = ba.ParticleLayout()
    layout.addParticle(particle, 1)
    layout.setWeight(1)
    layout.setTotalParticleSurfaceDensity(0.01)

    # Define layers
    layer_1 = ba.Layer(material_Vacuum)
    layer_2 = ba.Layer(material_Substrate)
    layer_2.addLayout(layout)

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

    return sample


def get_simulation(sample):
    beam = ba.Beam(1e12, 0.1*nm, ba.Direction(0.5*deg, 0))
    beam_polarization = kvector_t(0, 0, 1)
    beam.setPolarization(beam_polarization)
    detector = ba.SphericalDetector(200, 6*deg, 0, 3*deg)
    simulation = ba.GISASSimulation(beam, sample, detector)
    analyzer_direction = kvector_t(0, 0, -1)
    simulation.detector().setAnalyzerProperties(analyzer_direction, 1, 0.5)
    return simulation


if __name__ == '__main__':
    import ba_plot
    sample = get_sample()
    simulation = get_simulation(sample)
    ba_plot.run_and_plot(simulation)
MagneticSpheres.py