def test_strain_mapping_affine_transform():
latt = diffpy.structure.lattice.Lattice(3, 3, 3, 90, 90, 90)
atom = diffpy.structure.atom.Atom(atype='Zn', xyz=[0, 0, 0], lattice=latt)
structure = diffpy.structure.Structure(atoms=[atom], lattice=latt)
ediff = DiffractionGenerator(300., 0.025)
affines = [[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
[[1.04, 0, 0], [0, 1, 0], [0, 0, 1]],
[[1.08, 0, 0], [0, 1, 0], [0, 0, 1]],
[[1.12, 0, 0], [0, 1, 0], [0, 0, 1]]]
data = []
for affine in affines:
# same coords as used for latt above
latt_rot = diffpy.structure.lattice.Lattice(3, 3, 3, 90, 90, 90, baserot=affine)
structure.placeInLattice(latt_rot)
diff_dat = ediff.calculate_ed_data(structure, 2.5)
dpi = sim_as_signal(diff_dat, 64, 0.02, 2.5)
data.append(dpi.data)
data = np.array(data)
dp = ElectronDiffraction2D(data.reshape((2, 2, 64, 64)))
m = dp.create_model()
ref = ScalableReferencePattern(dp.inav[0, 0])
m.append(ref)
m.multifit()
disp_grad = ref.construct_displacement_gradient()
assert disp_grad.data.shape == np.asarray(affines).reshape(2, 2, 3, 3).shape
def get_library(default_structure):
diffraction_calculator = DiffractionGenerator(300., 0.02)
dfl = DiffractionLibraryGenerator(diffraction_calculator)
structure_library = StructureLibrary(['Phase'], [default_structure],
[np.array([(0, 0, 0), (0, 0.2, 0)])])
return dfl.get_diffraction_library(structure_library, 0.017, 2.4, (72, 72))
def test_appropriate_scaling(self,
diffraction_calculator: DiffractionGenerator):
"""Tests that doubling the unit cell halves the pattern spacing."""
silicon = make_structure(5)
big_silicon = make_structure(10)
diffraction = diffraction_calculator.calculate_ed_data(
structure=silicon, reciprocal_radius=5.)
big_diffraction = diffraction_calculator.calculate_ed_data(
structure=big_silicon, reciprocal_radius=5.)
indices = [tuple(i) for i in diffraction.indices]
big_indices = [tuple(i) for i in big_diffraction.indices]
assert (2, 2, 0) in indices
assert (2, 2, 0) in big_indices
coordinates = diffraction.coordinates[indices.index((2, 2, 0))]
big_coordinates = big_diffraction.coordinates[big_indices.index(
(2, 2, 0))]
assert np.allclose(coordinates, big_coordinates * 2)
def test_lib_gen():
diff_gen = DiffractionGenerator(
accelerating_voltage=200,
precession_angle=1,
scattering_params="lobato",
shape_factor_model="linear",
minimum_intensity=0.05,
)
lib_gen = DiffractionLibraryGenerator(diff_gen)
return lib_gen
def test_TemplateIndexationGenerator(default_structure, method):
identifiers = ["a", "b"]
structures = [default_structure, default_structure]
orientations = [[(0, 0, 0), (0, 1, 0), (1, 0, 0)],
[(0, 0, 1), (0, 0, 2), (0, 0, 3)]]
structure_library = StructureLibrary(identifiers, structures, orientations)
libgen = DiffractionLibraryGenerator(DiffractionGenerator(300))
library = libgen.get_diffraction_library(structure_library, 0.017, 0.02,
(100, 100), False)
edp = ElectronDiffraction2D(np.random.rand(2, 2, 200, 200))
indexer = TemplateIndexationGenerator(edp, library)
z = indexer.correlate(method=method, n_largest=2)
assert isinstance(z, TemplateMatchingResults)
assert isinstance(z.data, Signal2D)
assert z.data.data.shape[0:2] == edp.data.shape[0:2]
assert z.data.data.shape[3] == 5
def test_TemplateMatchingResults_plot_best_results_on_signal(
diffraction_pattern, default_structure):
""" Coverage testing """
edc = DiffractionGenerator(300)
half_side_length = 4
rot_list = [[0, 1, 0], [1, 0, 0]]
diff_gen = DiffractionLibraryGenerator(edc)
struc_lib = StructureLibrary(["A"], [default_structure], [rot_list])
library = diff_gen.get_diffraction_library(
struc_lib,
calibration=1 / half_side_length,
reciprocal_radius=0.8,
half_shape=(half_side_length, half_side_length),
with_direct_beam=True,
)
indexer = TemplateIndexationGenerator(diffraction_pattern, library)
match_results = indexer.correlate()
match_results.plot_best_matching_results_on_signal(diffraction_pattern,
library=library)
plt.close("all")
def diffraction_calculator():
return DiffractionGenerator(300.0)
def default_simulator():
accelerating_voltage = 300
max_excitation_error = 1e-2
return DiffractionGenerator(accelerating_voltage, max_excitation_error)
def default_simulator():
accelerating_voltage = 300
return DiffractionGenerator(accelerating_voltage)
def test_init(self, diffraction_calculator: DiffractionGenerator):
assert diffraction_calculator.debye_waller_factors == {}
_ = DiffractionGenerator(300, 2)
def diffraction_calculator_precession_full():
return DiffractionGenerator(300,
precession_angle=0.5,
approximate_precession=False)
def test_invalid_shape_model():
generator = DiffractionGenerator(300, shape_factor_model="dracula")
def test_invalid_scattering_params():
scattering_param = "_empty"
generator = DiffractionGenerator(300, scattering_params=scattering_param)
def test_diffraction_generator_init(model, expected):
generator = DiffractionGenerator(300, shape_factor_model=model)
assert generator.shape_factor_model == expected
im = pxm.load_hspy(dps.loc[image,'dp'])
dp = pxm.ElectronDiffraction2D(im.data)
dp.set_diffraction_calibration(im.axes_manager['kx'].scale)
dp.set_scan_calibration(im.axes_manager['x'].scale)
pattern_size = dp.axes_manager['x'].size
calibration = dp.axes_manager['kx'].scale
diffraction_calibration = calibration
half_pattern_size = pattern_size // 2
reciprocal_radius = diffraction_calibration*(half_pattern_size - 1)
beam_energy = 300.0
ediff = DiffractionGenerator(beam_energy, 0.025)
diff_gen = DiffractionLibraryGenerator(ediff)
template_library = diff_gen.get_diffraction_library(structure_library,
calibration=diffraction_calibration,
reciprocal_radius=reciprocal_radius-0.1,
half_shape=(half_pattern_size, half_pattern_size),
with_direct_beam=False)
library_name = image.split('.')[0]+"_template_"+str(angular_resolution)+"_deg.pickle"
template_library.pickle_library(library_name)
dps.loc[image,'template_library'] = library_name
def test_param_check(scattering_param):
generator = DiffractionGenerator(300,
0.2,
None,
scattering_params=scattering_param)
def test_invalid_scattering_params():
scattering_param = '_empty'
generator = DiffractionGenerator(300,
0.2,
None,
scattering_params=scattering_param)
def diffraction_calculator_precession_simple():
return DiffractionGenerator(300,
precession_angle=0.5,
approximate_precession=True)
def diffraction_calculator(request):
return DiffractionGenerator(*request.param)
def diffraction_calculator_custom():
return DiffractionGenerator(300, shape_factor_model=local_excite, t=0.2)