Skip to content

xray_utils

X-ray scattering utility funcitons

diffractometer_twotheta(delta=0, gamma=0)

Return the Bragg 2-theta angle for diffractometer detector rotations delta (vertical) and gamma (horizontal)

Source code in mmg_toolbox/utils/xray_utils.py 
77
78
79
80
81
82
def diffractometer_twotheta(delta=0, gamma=0):
    """Return the Bragg 2-theta angle for diffractometer detector rotations delta (vertical) and gamma (horizontal)"""
    delta = np.deg2rad(delta)
    gamma = np.deg2rad(gamma)
    twotheta = np.arccos(np.cos(delta) * np.cos(gamma))
    return np.rad2deg(twotheta)

photon_energy(wavelength_a)

Converts wavelength in A to energy in keV energy_kev = photon_energy(wavelength_a) Energy [keV] = h*c/L = 12.3984 / lambda [A]

Source code in mmg_toolbox/utils/xray_utils.py 
40
41
42
43
44
45
46
47
48
49
50
51
52
53
def photon_energy(wavelength_a):
    """
    Converts wavelength in A to energy in keV
     energy_kev = photon_energy(wavelength_a)
     Energy [keV] = h*c/L = 12.3984 / lambda [A]
    """

    # SI: E = hc/lambda
    lam = wavelength_a * Const.A
    E = Const.h * Const.c / lam

    # Electron Volts:
    energy = E / Const.e
    return energy / 1000.0

photon_wavelength(energy_kev)

Converts energy in keV to wavelength in A wavelength_a = photon_wavelength(energy_kev) lambda [A] = h*c/E = 12.3984 / E [keV]

Source code in mmg_toolbox/utils/xray_utils.py 
24
25
26
27
28
29
30
31
32
33
34
35
36
37
def photon_wavelength(energy_kev):
    """
    Converts energy in keV to wavelength in A
     wavelength_a = photon_wavelength(energy_kev)
     lambda [A] = h*c/E = 12.3984 / E [keV]
    """

    # Electron Volts:
    E = 1000 * energy_kev * Const.e

    # SI: E = hc/lambda
    lam = Const.h * Const.c / E
    wavelength = lam / Const.A
    return wavelength

polarisation_pi(delta=0, gamma=0)

Returns the scattered polerisation vector in the Pi' channel

Source code in mmg_toolbox/utils/xray_utils.py 
147
148
149
150
151
152
153
154
155
def polarisation_pi(delta=0, gamma=0):
    """
    Returns the scattered polerisation vector in the Pi' channel
    """
    sd = np.sin(np.deg2rad(delta))
    sg = np.sin(np.deg2rad(gamma))
    cd = np.cos(np.deg2rad(delta))
    cg = np.cos(np.deg2rad(gamma))
    return np.array([-sg * sd, cd, -cg * sd])

polarisation_sigma(delta=0, gamma=0)

Returns the scattered polerisation vector in the sigma' channel

Source code in mmg_toolbox/utils/xray_utils.py 
136
137
138
139
140
141
142
143
144
def polarisation_sigma(delta=0, gamma=0):
    """
    Returns the scattered polerisation vector in the sigma' channel
    """
    sd = np.sin(np.deg2rad(delta))
    sg = np.sin(np.deg2rad(gamma))
    cd = np.cos(np.deg2rad(delta))
    cg = np.cos(np.deg2rad(gamma))
    return np.array([cg, 0, -sg])

resolution2energy(res, twotheta=180.0)

Calcualte the energy required to achieve a specific resolution at a given two-theta

Parameters:

Name Type Description Default
res

measurement resolution in A (==d-spacing)

 required
twotheta

Bragg angle in Degrees

 180.0

Returns:

Type Description

float
Source code in mmg_toolbox/utils/xray_utils.py 
66
67
68
69
70
71
72
73
74
def resolution2energy(res, twotheta=180.):
    """
    Calcualte the energy required to achieve a specific resolution at a given two-theta
    :param res: measurement resolution in A (==d-spacing)
    :param twotheta: Bragg angle in Degrees
    :return: float
    """
    theta = twotheta * Const.pi / 360  # theta in radians
    return (Const.h * Const.c * 1e10) / (res * np.sin(theta) * Const.e * 2 * 1000.)

wavevector(wavelength_a)

Return wavevector = 2pi/lambda

Source code in mmg_toolbox/utils/xray_utils.py 
61
62
63
def wavevector(wavelength_a):
    """Return wavevector = 2pi/lambda"""
    return 2 * Const.pi / wavelength_a

wavevector_f(wavelength_a, delta=0, gamma=0)

Returns a 3D wavevector for the final wavevector

Source code in mmg_toolbox/utils/xray_utils.py 
114
115
116
117
118
119
120
121
122
123
def wavevector_f(wavelength_a, delta=0, gamma=0):
    """
    Returns a 3D wavevector for the final wavevector
    """
    k = wavevector(wavelength_a)
    sd = np.sin(np.deg2rad(delta))
    sg = np.sin(np.deg2rad(gamma))
    cd = np.cos(np.deg2rad(delta))
    cg = np.cos(np.deg2rad(gamma))
    return k * np.array([sg * cd, sd, cg * cd])

wavevector_i(wavelength_a)

Returns a 3D wavevector for the initial wavevector

Source code in mmg_toolbox/utils/xray_utils.py 
106
107
108
109
110
111
def wavevector_i(wavelength_a):
    """
    Returns a 3D wavevector for the initial wavevector
    """
    k = wavevector(wavelength_a)
    return np.array([0, 0, k])

wavevector_t(wavelength_a, delta=0, gamma=0)

Returns the wavevector transfer in inverse-Angstroms Q = kf - ki

Source code in mmg_toolbox/utils/xray_utils.py 
126
127
128
129
130
131
132
133
def wavevector_t(wavelength_a, delta=0, gamma=0):
    """
    Returns the wavevector transfer in inverse-Angstroms
      Q = kf - ki
    """
    ki = wavevector_i(wavelength_a)
    kf = wavevector_f(wavelength_a, delta, gamma)
    return kf - ki

you_normal_vector(eta=0, chi=90, mu=0)

Determine the normal vector using the You diffractometer angles you_normal_vector(0, 0, 0) = [1, 0, 0] you_normal_vector(0, 90, 0) = [0, 1, 0] you_normal_vector(90, 90, 0) = [0, 0, -1] you_normal_vector(0, 0, 90) = [0, 0, -1]

Parameters:

Name Type Description Default
eta

angle (deg) along the x-axis

 0
mu

angle (deg) about the z-axis

 0
chi

angle deg) a

 90

Returns:

Type Description

array
Source code in mmg_toolbox/utils/xray_utils.py 
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
def you_normal_vector(eta=0, chi=90, mu=0):
    """
    Determine the normal vector using the You diffractometer angles
      you_normal_vector(0, 0, 0) = [1, 0, 0]
      you_normal_vector(0, 90, 0) = [0, 1, 0]
      you_normal_vector(90, 90, 0) = [0, 0, -1]
      you_normal_vector(0, 0, 90) = [0, 0, -1]
    :param eta: angle (deg) along the x-axis
    :param mu: angle (deg) about the z-axis
    :param chi: angle deg) a
    :return: array
    """
    eta = np.deg2rad(eta)
    chi = np.deg2rad(chi)
    mu = np.deg2rad(mu)
    normal = np.array([np.sin(mu) * np.sin(eta) * np.sin(chi) + np.cos(mu) * np.cos(chi),
                       np.cos(eta) * np.sin(chi),
                       -np.cos(mu) * np.sin(eta) * np.sin(chi) - np.sin(mu) * np.cos(chi)])
    return normal