def calculate_profile_data(self,
structure,
reciprocal_radius=1.0,
magnitude_tolerance=1e-5,
minimum_intensity=1e-3):
"""
Calculates a one dimensional diffraction profile for a structure.
Parameters
----------
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.
magnitude_tolerance : float
The minimum difference between diffraction magnitudes in reciprocal
angstroms for two peaks to be consdiered different.
minimum_intensity : float
The minimum intensity required for a diffraction peak to be
considered real. Deals with numerical precision issues.
Returns
-------
diffsims.ProfileSimulation
The diffraction profile corresponding to this structure and
experimental conditions.
"""
max_r = reciprocal_radius
wavelength = self.wavelength
scattering_params = self.scattering_params
latt = structure.lattice
is_hex = is_lattice_hexagonal(latt)
coeffs, fcoords, occus, dwfactors = get_vectorized_list_for_atomic_scattering_factors(
structure, {}, scattering_params=scattering_params)
# Obtain crystallographic reciprocal lattice points within range
recip_latt = latt.reciprocal()
spot_indicies, _, spot_distances = get_points_in_sphere(
recip_latt, reciprocal_radius)
peaks = {}
mask = np.logical_not((np.any(spot_indicies, axis=1) == 0))
for hkl, g_hkl in zip(spot_indicies[mask], spot_distances[mask]):
# Force miller indices to be integers.
hkl = [int(round(i)) for i in hkl]
d_hkl = 1 / g_hkl
# Bragg condition
# theta = asin(wavelength * g_hkl / 2)
# s = sin(theta) / wavelength = 1 / 2d = |ghkl| / 2 (d =
# 1/|ghkl|)
s = g_hkl / 2
# Store s^2 since we are using it a few times.
s2 = s**2
# Vectorized computation of g.r for all fractional coords and
# hkl.
g_dot_r = np.dot(fcoords, np.transpose([hkl])).T[0]
# Highly vectorized computation of atomic scattering factors.
fs = np.sum(coeffs[:, :, 0] * np.exp(-coeffs[:, :, 1] * s2),
axis=1)
dw_correction = np.exp(-dwfactors * s2)
# Structure factor = sum of atomic scattering factors (with
# position factor exp(2j * pi * g.r and occupancies).
# Vectorized computation.
f_hkl = np.sum(fs * occus * np.exp(2j * np.pi * g_dot_r) *
dw_correction)
# Intensity for hkl is modulus square of structure factor.
i_hkl = (f_hkl * f_hkl.conjugate()).real
# two_theta = degrees(2 * theta)
if is_hex:
# Use Miller-Bravais indices for hexagonal lattices.
hkl = (hkl[0], hkl[1], -hkl[0] - hkl[1], hkl[2])
peaks[g_hkl] = [i_hkl, [tuple(hkl)], d_hkl]
# Scale intensities so that the max intensity is 100.
max_intensity = max([v[0] for v in peaks.values()])
x = []
y = []
hkls = []
d_hkls = []
for k in sorted(peaks.keys()):
v = peaks[k]
fam = get_unique_families(v[1])
if v[0] / max_intensity * 100 > minimum_intensity:
x.append(k)
y.append(v[0])
hkls.append(fam)
d_hkls.append(v[2])
y = y / max(y) * 100
return ProfileSimulation(x, y, hkls)
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,
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()
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_spot = cartesian_coordinates[:, 2]
if self.precession_angle > 0 and not self.approximate_precession:
# We find the average excitation error - this step can be
# quite expensive
excitation_error = _average_excitation_error_precession(
z_spot,
r_spot,
wavelength,
self.precession_angle,
)
else:
z_sphere = -np.sqrt(r_sphere**2 - r_spot**2) + r_sphere
excitation_error = z_sphere - z_spot
# 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 = spot_indices[intersection]
g_hkls = spot_distances[intersection]
# take into consideration rel-rods
if self.precession_angle > 0 and not self.approximate_precession:
shape_factor = _shape_factor_precession(
intersection_coordinates[:, 2],
r_spot,
wavelength,
self.precession_angle,
self.shape_factor_model,
max_excitation_error,
**self.shape_factor_kwargs,
)
elif self.precession_angle > 0 and self.approximate_precession:
shape_factor = lorentzian_precession(
excitation_error,
max_excitation_error,
r_spot,
self.precession_angle,
)
else:
shape_factor = self.shape_factor_model(excitation_error,
max_excitation_error)
# 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 > 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,
is_hex=is_lattice_hexagonal(
structure.lattice))