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
|
#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# dependencies = ["bornagain>=25,<26"]
# ///
"""
GISAXS of extreme ultraviolet light (13.5 nm) from molybdenum nanospheres on
silicon, in the four channels s -> s, s -> p, p -> s, p -> p of polarizer and
analyzer. For a beam without phase relation between its s and p waves, such as
an unpolarized one, and an analyzer for s or p, the intensity is a weighted sum
of these maps.
At this wavelength, the scattering angles are large. The field radiated by a
particle is the projection of the incident field onto the plane normal to the
outgoing wave. Outside the plane of incidence, this projection has components
along both s and p of the outgoing wave: scattering converts s to p and p to s.
The p -> p channel is weak where the outgoing wave approaches the direction of
the incident field, at the top of the maps, since a dipole does not radiate
along its axis. All maps are symmetric under phi_f -> -phi_f. For hard x-rays
at angles up to 3 deg, typical of GISAXS, the polarization factors of the Born
approximation give the converted channels less than 1e-5 of the intensity,
and s -> s and p -> p differ by about 1 %.
"""
import bornagain as ba
ba.require_versions("bornagain>=25,<26")
from bornagain import deg, nm, nm2
def get_sample():
"""
Molybdenum spheres on a silicon substrate, with optical constants at
13.5 nm from the Henke tables.
"""
molybdenum_color = (0.55, 0.55, 0.6)
molybdenum = ba.RefractiveMaterial("Mo", molybdenum_color, 0.0762, 0.00644)
silicon_color = (0.65, 0.75, 0.85)
silicon = ba.RefractiveMaterial("Si", silicon_color, 0.00100, 0.00183)
sphere = ba.Particle(molybdenum, ba.Sphere(5*nm))
layer = ba.Layer(ba.Vacuum())
layer.deposit2D(ba.Dilute2D(1e-4/nm2, sphere))
sample = ba.Sample()
sample.addLayer(layer)
sample.addLayer(ba.Layer(silicon))
return sample
def get_simulation(sample, polarizer, analyzer):
"""
A GISAXS simulation for one channel. Polarizer and analyzer select linear
polarization at the given angles from s toward p.
"""
n = 200
beam = ba.Beam(1e9, 13.5*nm, 20*deg)
beam.setXrayPolarization(angle=polarizer, axis_ratio=0, degree=1)
detector = ba.SphericalDetector(n, -60*deg, 60*deg, n, 0, 60*deg)
detector.setXrayAnalyzer(angle=analyzer, axis_ratio=0)
simulation = ba.ScatteringSimulation(beam, sample, detector)
return simulation
def simulate(sample, polarizer, analyzer, title):
"""
Runs one channel.
"""
result = get_simulation(sample, polarizer, analyzer).simulate()
result.setTitle(title)
return result
if __name__ == '__main__':
sample = get_sample()
# Angles of s and p polarization
s_wave = 0
p_wave = 90*deg
channels = [
("s → s", s_wave, s_wave),
("s → p", s_wave, p_wave),
("p → s", p_wave, s_wave),
("p → p", p_wave, p_wave),
]
results = [
simulate(sample, polarizer, analyzer, title)
for title, polarizer, analyzer in channels
]
ba.showSample3D(sample, sample_size=120*nm, seed=0)
ba.plot2d_to_grid(results, 2, unit_aspect=1)
ba.plt.show()
|