def test_get_kinematical_intensities(default_structure):
latt = default_structure.lattice
reciprocal_lattice = latt.reciprocal()
reciprocal_radius = 0.2
unique_hkls, multiplicites, g_hkls = get_intensities_params(
reciprocal_lattice, reciprocal_radius)
g_hkls_array = np.asarray(g_hkls)
i_hkls = get_kinematical_intensities(
default_structure,
g_indices=unique_hkls,
g_hkls_array=g_hkls_array,
debye_waller_factors={"Al": 1},
prefactor=multiplicites,
scattering_params="lobato",
)
np.testing.assert_array_almost_equal(i_hkls, ([43.0979]), decimal=4)
def test_kinematic_intensities_error_raise(structure, rotation):
"""Test that kinematically forbidden diffraction spots gets zero intensity also after rotation."""
rotated_lattice = diffpy.structure.lattice.Lattice(structure.lattice)
rotated_lattice.setLatPar(baserot=rotation)
structure.placeInLattice(rotated_lattice)
reciprocal_lattice = structure.lattice.reciprocal()
g_indices = [(0, 0, 1)]
g_hkls = reciprocal_lattice.dist(g_indices, [0, 0, 0])
intensities = get_kinematical_intensities(structure,
g_indices,
g_hkls,
excitation_error=0,
maximum_excitation_error=1,
debye_waller_factors={},
scattering_params='_empty')
def test_kinematic_intensities_rotation(structure, rotation):
"""Test that kinematically forbidden diffraction spots gets zero intensity also after rotation."""
rotated_lattice = diffpy.structure.lattice.Lattice(structure.lattice)
rotated_lattice.setLatPar(baserot=rotation)
structure.placeInLattice(rotated_lattice)
reciprocal_lattice = structure.lattice.reciprocal()
g_indices = [(0, 0, 1)]
g_hkls = reciprocal_lattice.dist(g_indices, [0, 0, 0])
scattering_params_list = ['lobato', 'xtables']
for scattering_params in scattering_params_list:
intensities = get_kinematical_intensities(
structure,
g_indices,
g_hkls,
excitation_error=0,
maximum_excitation_error=1,
debye_waller_factors={},
scattering_params=scattering_params)
np.testing.assert_almost_equal(intensities, [0])
def calculate_profile_data(
self,
structure,
reciprocal_radius=1.0,
minimum_intensity=1e-3,
debye_waller_factors={},
):
"""Calculates a one dimensional diffraction profile for a
structure.
Parameters
----------
structure : diffpy.structure.structure.Structure
The structure for which to calculate the diffraction profile.
reciprocal_radius : float
The maximum radius of the sphere of reciprocal space to
sample, in reciprocal angstroms.
minimum_intensity : float
The minimum intensity required for a diffraction peak to be
considered real. Deals with numerical precision issues.
debye_waller_factors : dict of str:value pairs
Maps element names to their temperature-dependent Debye-Waller factors.
Returns
-------
diffsims.sims.diffraction_simulation.ProfileSimulation
The diffraction profile corresponding to this structure and
experimental conditions.
"""
wavelength = self.wavelength
latt = structure.lattice
# Obtain crystallographic reciprocal lattice points within range
recip_latt = latt.reciprocal()
spot_indices, _, spot_distances = get_points_in_sphere(
recip_latt, reciprocal_radius
)
##spot_indicies is a numpy.array of the hkls allowd in the recip radius
g_indices, multiplicities, g_hkls = get_intensities_params(
recip_latt, reciprocal_radius
)
i_hkl = get_kinematical_intensities(
structure,
g_indices,
np.asarray(g_hkls),
prefactor=multiplicities,
scattering_params=self.scattering_params,
debye_waller_factors=debye_waller_factors,
)
if is_lattice_hexagonal(latt):
# Use Miller-Bravais indices for hexagonal lattices.
g_indices = (
g_indices[0],
g_indices[1],
-g_indices[0] - g_indices[1],
g_indices[2],
)
hkls_labels = ["".join([str(int(x)) for x in xs]) for xs in g_indices]
peaks = {}
for l, i, g in zip(hkls_labels, i_hkl, g_hkls):
peaks[l] = [i, g]
# Scale intensities so that the max intensity is 100.
max_intensity = max([v[0] for v in peaks.values()])
x = []
y = []
hkls = []
for k in peaks.keys():
v = peaks[k]
if v[0] / max_intensity * 100 > minimum_intensity and (k != "000"):
x.append(v[1])
y.append(v[0])
hkls.append(k)
y = np.asarray(y) / max(y) * 100
return ProfileSimulation(x, y, hkls)
def calculate_ed_data(
self,
structure,
reciprocal_radius,
rotation=(0, 0, 0),
with_direct_beam=True,
max_excitation_error=1e-2,
shape_factor_width=None,
debye_waller_factors={},
):
"""Calculates the Electron Diffraction data for a structure.
Parameters
----------
structure : diffpy.structure.structure.Structure
The structure for which to derive the diffraction pattern.
Note that the structure must be rotated to the appropriate
orientation and that testing is conducted on unit cells
(rather than supercells).
reciprocal_radius : float
The maximum radius of the sphere of reciprocal space to
sample, in reciprocal Angstroms.
rotation : tuple
Euler angles, in degrees, in the rzxz convention. Default is
(0, 0, 0) which aligns 'z' with the electron beam.
with_direct_beam : bool
If True, the direct beam is included in the simulated
diffraction pattern. If False, it is not.
max_excitation_error : float
The cut-off for geometric excitation error in the z-direction
in units of reciprocal Angstroms. Spots with a larger distance
from the Ewald sphere are removed from the pattern.
Related to the extinction distance and roungly equal to 1/thickness.
shape_factor_width : float
Determines the width of the reciprocal rel-rod, for fine-grained
control. If not set will be set equal to max_excitation_error.
debye_waller_factors : dict of str:value pairs
Maps element names to their temperature-dependent Debye-Waller factors.
Returns
-------
diffsims.sims.diffraction_simulation.DiffractionSimulation
The data associated with this structure and diffraction setup.
"""
# Specify variables used in calculation
wavelength = self.wavelength
latt = structure.lattice
# Obtain crystallographic reciprocal lattice points within `reciprocal_radius` and
# g-vector magnitudes for intensity calculations.
recip_latt = latt.reciprocal()
g_indices, cartesian_coordinates, g_hkls = get_points_in_sphere(
recip_latt, reciprocal_radius
)
ai, aj, ak = (
np.deg2rad(rotation[0]),
np.deg2rad(rotation[1]),
np.deg2rad(rotation[2]),
)
R = euler2mat(ai, aj, ak, axes="rzxz")
cartesian_coordinates = np.matmul(R, cartesian_coordinates.T).T
# Identify the excitation errors of candidate points
r_sphere = 1 / wavelength
r_spot = np.sqrt(np.sum(np.square(cartesian_coordinates[:, :2]), axis=1))
z_spot = cartesian_coordinates[:, 2]
z_sphere = -np.sqrt(r_sphere ** 2 - r_spot ** 2) + r_sphere
excitation_error = z_sphere - z_spot
# determine the pre-selection reflections
if self.precession_angle == 0:
intersection = np.abs(excitation_error) < max_excitation_error
else:
# only consider points that intersect the ewald sphere at some point
# the center point of the sphere
P_z = r_sphere * np.cos(np.deg2rad(self.precession_angle))
P_t = r_sphere * np.sin(np.deg2rad(self.precession_angle))
# the extremes of the ewald sphere
z_surf_up = P_z - np.sqrt(r_sphere ** 2 - (r_spot + P_t) ** 2)
z_surf_do = P_z - np.sqrt(r_sphere ** 2 - (r_spot - P_t) ** 2)
intersection = (z_spot - max_excitation_error <= z_surf_up) & (
z_spot + max_excitation_error >= z_surf_do
)
# select these reflections
intersection_coordinates = cartesian_coordinates[intersection]
excitation_error = excitation_error[intersection]
r_spot = r_spot[intersection]
g_indices = g_indices[intersection]
g_hkls = g_hkls[intersection]
if shape_factor_width is None:
shape_factor_width = max_excitation_error
# select and evaluate shape factor model
if self.precession_angle == 0:
# calculate shape factor
shape_factor = self.shape_factor_model(
excitation_error, shape_factor_width, **self.shape_factor_kwargs
)
else:
if self.approximate_precession:
shape_factor = lorentzian_precession(
excitation_error,
shape_factor_width,
r_spot,
np.deg2rad(self.precession_angle),
)
else:
shape_factor = _shape_factor_precession(
excitation_error,
r_spot,
np.deg2rad(self.precession_angle),
self.shape_factor_model,
shape_factor_width,
**self.shape_factor_kwargs,
)
# Calculate diffracted intensities based on a kinematical model.
intensities = get_kinematical_intensities(
structure,
g_indices,
g_hkls,
prefactor=shape_factor,
scattering_params=self.scattering_params,
debye_waller_factors=debye_waller_factors,
)
# Threshold peaks included in simulation as factor of maximum intensity.
peak_mask = intensities > np.max(intensities) * self.minimum_intensity
intensities = intensities[peak_mask]
intersection_coordinates = intersection_coordinates[peak_mask]
g_indices = g_indices[peak_mask]
return DiffractionSimulation(
coordinates=intersection_coordinates,
indices=g_indices,
intensities=intensities,
with_direct_beam=with_direct_beam,
)
def calculate_ed_data(self,
structure,
reciprocal_radius,
rotation=(0, 0, 0),
with_direct_beam=True):
"""Calculates the Electron Diffraction data for a structure.
Parameters
----------
structure : Structure
The structure for which to derive the diffraction pattern. Note that
the structure must be rotated to the appropriate orientation and
that testing is conducted on unit cells (rather than supercells).
reciprocal_radius : float
The maximum radius of the sphere of reciprocal space to sample, in
reciprocal angstroms.
rotation : tuple
Euler angles, in degrees, in the rzxz convention. Default is (0,0,0)
which aligns 'z' with the electron beam
with_direct_beam : bool
If True, the direct beam is included in the simulated diffraction
pattern. If False, it is not.
Returns
-------
diffsims.DiffractionSimulation
The data associated with this structure and diffraction setup.
"""
# Specify variables used in calculation
wavelength = self.wavelength
max_excitation_error = self.max_excitation_error
debye_waller_factors = self.debye_waller_factors
latt = structure.lattice
scattering_params = self.scattering_params
# Obtain crystallographic reciprocal lattice points within `max_r` and
# g-vector magnitudes for intensity calculations.
recip_latt = latt.reciprocal()
spot_indicies, cartesian_coordinates, spot_distances = get_points_in_sphere(
recip_latt, reciprocal_radius)
ai, aj, ak = np.deg2rad(rotation[0]), np.deg2rad(
rotation[1]), np.deg2rad(rotation[2])
R = euler2mat(ai, aj, ak, axes='rzxz')
cartesian_coordinates = np.matmul(R, cartesian_coordinates.T).T
# Identify points intersecting the Ewald sphere within maximum
# excitation error and store the magnitude of their excitation error.
r_sphere = 1 / wavelength
r_spot = np.sqrt(
np.sum(np.square(cartesian_coordinates[:, :2]), axis=1))
z_sphere = -np.sqrt(r_sphere**2 - r_spot**2) + r_sphere
proximity = np.absolute(z_sphere - cartesian_coordinates[:, 2])
intersection = proximity < max_excitation_error
# Mask parameters corresponding to excited reflections.
intersection_coordinates = cartesian_coordinates[intersection]
intersection_indices = spot_indicies[intersection]
proximity = proximity[intersection]
g_hkls = spot_distances[intersection]
# Calculate diffracted intensities based on a kinematical model.
intensities = get_kinematical_intensities(
structure, intersection_indices, g_hkls, proximity,
max_excitation_error, debye_waller_factors, scattering_params)
# Threshold peaks included in simulation based on minimum intensity.
peak_mask = intensities > 1e-20
intensities = intensities[peak_mask]
intersection_coordinates = intersection_coordinates[peak_mask]
intersection_indices = intersection_indices[peak_mask]
return DiffractionSimulation(coordinates=intersection_coordinates,
indices=intersection_indices,
intensities=intensities,
with_direct_beam=with_direct_beam)
def calculate_ed_data(self,
structure,
reciprocal_radius,
rotation=(0, 0, 0),
shape_factor_model="linear",
max_excitation_error=1e-2,
with_direct_beam=True,
**kwargs):
"""Calculates the Electron Diffraction data for a structure.
Parameters
----------
structure : Structure
The structure for which to derive the diffraction pattern. Note that
the structure must be rotated to the appropriate orientation and
that testing is conducted on unit cells (rather than supercells).
reciprocal_radius : float
The maximum radius of the sphere of reciprocal space to sample, in
reciprocal angstroms.
rotation : tuple
Euler angles, in degrees, in the rzxz convention. Default is (0,0,0)
which aligns 'z' with the electron beam
shape_factor_model : function or str
a function that takes excitation_error and max_excitation_error (and potentially **kwargs) and returns an intensity
scaling factor. The code provides "linear" and "binary" options accessed with by parsing the associated strings
max_excitation_error : float
the exctinction distance for reflections, in reciprocal Angstroms
with_direct_beam : bool
If True, the direct beam is included in the simulated diffraction
pattern. If False, it is not.
**kwargs :
passed to shape_factor_model
Returns
-------
diffsims.DiffractionSimulation
The data associated with this structure and diffraction setup.
"""
# Specify variables used in calculation
wavelength = self.wavelength
latt = structure.lattice
# Obtain crystallographic reciprocal lattice points within `reciprocal_radius` and
# g-vector magnitudes for intensity calculations.
recip_latt = latt.reciprocal()
spot_indices, cartesian_coordinates, spot_distances = get_points_in_sphere(
recip_latt, reciprocal_radius)
ai, aj, ak = (
np.deg2rad(rotation[0]),
np.deg2rad(rotation[1]),
np.deg2rad(rotation[2]),
)
R = euler2mat(ai, aj, ak, axes="rzxz")
cartesian_coordinates = np.matmul(R, cartesian_coordinates.T).T
# Identify points intersecting the Ewald sphere within maximum
# excitation error and store the magnitude of their excitation error.
r_sphere = 1 / wavelength
r_spot = np.sqrt(
np.sum(np.square(cartesian_coordinates[:, :2]), axis=1))
z_sphere = -np.sqrt(r_sphere**2 - r_spot**2) + r_sphere
excitation_error = np.absolute(z_sphere - cartesian_coordinates[:, 2])
intersection = excitation_error < max_excitation_error
# Mask parameters corresponding to excited reflections.
intersection_coordinates = cartesian_coordinates[intersection]
g_indices = spot_indices[intersection]
excitation_error = excitation_error[intersection]
g_hkls = spot_distances[intersection]
if shape_factor_model == "linear":
shape_factor = 1 - (excitation_error / max_excitation_error)
elif shape_factor_model == "binary":
shape_factor = 1
else:
shape_factor = shape_factor_model(excitation_error,
max_excitation_error, **kwargs)
# Calculate diffracted intensities based on a kinematical model.
intensities = get_kinematical_intensities(
structure,
g_indices,
g_hkls,
prefactor=shape_factor,
scattering_params=self.scattering_params,
debye_waller_factors=self.debye_waller_factors,
)
# Threshold peaks included in simulation based on minimum intensity.
peak_mask = intensities > 1e-20
intensities = intensities[peak_mask]
intersection_coordinates = intersection_coordinates[peak_mask]
g_indices = g_indices[peak_mask]
return DiffractionSimulation(
coordinates=intersection_coordinates,
indices=g_indices,
intensities=intensities,
with_direct_beam=with_direct_beam,
)
def calculate_ed_data(
self,
structure,
reciprocal_radius,
rotation=(0, 0, 0),
with_direct_beam=True,
max_excitation_error=1e-2,
debye_waller_factors={},
):
"""Calculates the Electron Diffraction data for a structure.
Parameters
----------
structure : diffpy.structure.structure.Structure
The structure for which to derive the diffraction pattern.
Note that the structure must be rotated to the appropriate
orientation and that testing is conducted on unit cells
(rather than supercells).
reciprocal_radius : float
The maximum radius of the sphere of reciprocal space to
sample, in reciprocal Angstroms.
rotation : tuple
Euler angles, in degrees, in the rzxz convention. Default is
(0, 0, 0) which aligns 'z' with the electron beam.
with_direct_beam : bool
If True, the direct beam is included in the simulated
diffraction pattern. If False, it is not.
max_excitation_error : float
The extinction distance for reflections, in reciprocal
Angstroms. Roughly equal to 1/thickness.
debye_waller_factors : dict of str:value pairs
Maps element names to their temperature-dependent Debye-Waller factors.
Returns
-------
diffsims.sims.diffraction_simulation.DiffractionSimulation
The data associated with this structure and diffraction setup.
"""
# Specify variables used in calculation
wavelength = self.wavelength
latt = structure.lattice
# Obtain crystallographic reciprocal lattice points within `reciprocal_radius` and
# g-vector magnitudes for intensity calculations.
recip_latt = latt.reciprocal()
g_indices, cartesian_coordinates, g_hkls = get_points_in_sphere(
recip_latt, reciprocal_radius)
ai, aj, ak = (
np.deg2rad(rotation[0]),
np.deg2rad(rotation[1]),
np.deg2rad(rotation[2]),
)
R = euler2mat(ai, aj, ak, axes="rzxz")
cartesian_coordinates = np.matmul(R, cartesian_coordinates.T).T
# Identify the excitation errors of candidate points
r_sphere = 1 / wavelength
r_spot = np.sqrt(
np.sum(np.square(cartesian_coordinates[:, :2]), axis=1))
z_spot = cartesian_coordinates[:, 2]
z_sphere = -np.sqrt(r_sphere**2 - r_spot**2) + r_sphere
excitation_error = z_sphere - z_spot
if self.precession_angle == 0:
# Mask parameters corresponding to excited reflections.
intersection = np.abs(excitation_error) < max_excitation_error
intersection_coordinates = cartesian_coordinates[intersection]
excitation_error = excitation_error[intersection]
r_spot = r_spot[intersection]
g_indices = g_indices[intersection]
g_hkls = g_hkls[intersection]
# calculate shape factor
shape_factor = self.shape_factor_model(excitation_error,
max_excitation_error,
**self.shape_factor_kwargs)
else:
intersection_coordinates = cartesian_coordinates #for naming simplicity
if self.approximate_precession:
shape_factor = lorentzian_precession(
excitation_error,
max_excitation_error,
r_spot,
np.deg2rad(self.precession_angle),
)
else:
shape_factor = _shape_factor_precession(
excitation_error,
r_spot,
np.deg2rad(self.precession_angle),
self.shape_factor_model,
max_excitation_error,
**self.shape_factor_kwargs,
)
# Calculate diffracted intensities based on a kinematical model.
intensities = get_kinematical_intensities(
structure,
g_indices,
g_hkls,
prefactor=shape_factor,
scattering_params=self.scattering_params,
debye_waller_factors=debye_waller_factors,
)
# Threshold peaks included in simulation based on minimum intensity.
peak_mask = intensities > np.max(intensities) * self.minimum_intensity
intensities = intensities[peak_mask]
intersection_coordinates = intersection_coordinates[peak_mask]
g_indices = g_indices[peak_mask]
return DiffractionSimulation(
coordinates=intersection_coordinates,
indices=g_indices,
intensities=intensities,
with_direct_beam=with_direct_beam,
)