def get_simple_atom_lattice_two_sublattices(image_noise=False):
"""Returns a simple atom_lattice with two sublattices.
Parameters
----------
image_noise : bool, default False
Returns
-------
simple_atom_lattice : Atom_Lattice object
Examples
--------
>>> import atomap.api as am
>>> al = am.dummy_data.get_simple_atom_lattice_two_sublattices()
>>> al.plot()
"""
test_data_1 = MakeTestData(300, 300)
test_data_2 = MakeTestData(300, 300)
test_data_3 = MakeTestData(300, 300)
if image_noise:
test_data_3.add_image_noise(mu=0, sigma=0.02)
_make_atom_lists_two_sublattices(test_data_1, test_data_2)
_make_atom_lists_two_sublattices(test_data_3)
sublattice_1 = test_data_1.sublattice
sublattice_2 = test_data_2.sublattice
sublattice_2._plot_color = 'b'
image = test_data_3.signal.data
atom_lattice = al.Atom_Lattice(
image=image,
name='Simple Atom Lattice',
sublattice_list=[sublattice_1, sublattice_2])
return (atom_lattice)
def setup_method(self):
image_data = np.arange(10000).reshape(100, 100)
peaks0 = np.arange(20).reshape(10, 2)
peaks1 = np.arange(26).reshape(13, 2)
sublattice0 = Sublattice(atom_position_list=peaks0, image=image_data)
sublattice1 = Sublattice(atom_position_list=peaks1, image=image_data)
self.atom_lattice = al.Atom_Lattice()
self.atom_lattice.sublattice_list.extend([sublattice0, sublattice1])
self.atom_lattice.image0 = image_data
self.tmpdir = tempfile.TemporaryDirectory()
def test_save_load_atom_lattice_atom_values(self):
image_data = np.arange(10000).reshape(100, 100)
atom0_pos = np.random.random(size=(30, 2)) * 10
atom0_sigma_x = np.random.random(size=30)
atom0_sigma_y = np.random.random(size=30)
atom0_rot = np.random.random(size=30)
atom1_pos = np.random.random(size=(30, 2)) * 10
atom1_sigma_x = np.random.random(size=30)
atom1_sigma_y = np.random.random(size=30)
atom1_rot = np.random.random(size=30)
sublattice0 = Sublattice(atom_position_list=atom0_pos,
image=image_data)
sublattice1 = Sublattice(atom_position_list=atom1_pos,
image=image_data)
for i, atom in enumerate(sublattice0.atom_list):
atom.sigma_x = atom0_sigma_x[i]
atom.sigma_y = atom0_sigma_y[i]
atom.rotation = atom0_rot[i]
for i, atom in enumerate(sublattice1.atom_list):
atom.sigma_x = atom1_sigma_x[i]
atom.sigma_y = atom1_sigma_y[i]
atom.rotation = atom1_rot[i]
atom_lattice = al.Atom_Lattice()
atom_lattice.sublattice_list.extend([sublattice0, sublattice1])
atom_lattice.image0 = image_data
save_path = pjoin(self.tmpdir.name, "atomic_lattice.hdf5")
atom_lattice.save(filename=save_path, overwrite=True)
atom_lattice_load = load_atom_lattice_from_hdf5(
save_path, construct_zone_axes=False)
sl0 = atom_lattice_load.sublattice_list[0]
sl1 = atom_lattice_load.sublattice_list[1]
assert (sl0.x_position == atom0_pos[:, 0]).all()
assert (sl0.y_position == atom0_pos[:, 1]).all()
assert (sl1.x_position == atom1_pos[:, 0]).all()
assert (sl1.y_position == atom1_pos[:, 1]).all()
assert (sl0.sigma_x == atom0_sigma_x).all()
assert (sl0.sigma_y == atom0_sigma_y).all()
assert (sl1.sigma_x == atom1_sigma_x).all()
assert (sl1.sigma_y == atom1_sigma_y).all()
assert (sl0.rotation == atom0_rot).all()
assert (sl1.rotation == atom1_rot).all()
def _get_fantasite_atom_lattice():
test_data1 = MakeTestData(500, 500)
test_data1 = _add_fantasite_sublattice_A(test_data1)
test_data2 = MakeTestData(500, 500)
test_data2 = _add_fantasite_sublattice_B(test_data2)
test_data3 = MakeTestData(500, 500)
test_data3 = _add_fantasite_sublattice_A(test_data3)
test_data3 = _add_fantasite_sublattice_B(test_data3)
test_data3.add_image_noise(mu=0, sigma=0.01, random_seed=0)
sublattice_1 = test_data1.sublattice
sublattice_2 = test_data2.sublattice
sublattice_1._plot_color = 'b'
image = test_data3.signal.data
atom_lattice = al.Atom_Lattice(
image=image,
name='Fantasite Atom Lattice',
sublattice_list=[sublattice_1, sublattice_2])
return (atom_lattice)
def get_polarization_film_atom_lattice(image_noise=False):
"""Get an Atom Lattice with two sublattices resembling a perovskite film.
Similar to a perovskite oxide thin film, where the B cations
are shifted in the film.
Parameters
----------
image_noise : bool, default False
Returns
-------
simple_atom_lattice : Atom_Lattice object
Examples
--------
>>> import atomap.api as am
>>> atom_lattice = am.dummy_data.get_polarization_film_atom_lattice()
>>> atom_lattice.plot()
With image noise
>>> atom_lattice = am.dummy_data.get_polarization_film_atom_lattice(
... image_noise=True)
>>> atom_lattice.plot()
"""
test_data0 = _make_polarization_film_A(image_noise=image_noise)
test_data1 = _make_polarization_film_B(image_noise=image_noise)
image = test_data0.signal.data + test_data1.signal.data
sublattice0 = test_data0.sublattice
sublattice1 = test_data1.sublattice
sublattice0.image = image
sublattice1.image = image
sublattice0.original_image = image
sublattice1.original_image = image
sublattice1._plot_color = 'b'
atom_lattice = al.Atom_Lattice(image=image,
name='Perovskite film',
sublattice_list=[sublattice0, sublattice1])
return atom_lattice
def load_atom_lattice_from_hdf5(filename, construct_zone_axes=True):
"""
Load an Atomap HDF5-file, restoring a saved Atom_Lattice.
Parameters
----------
filename : string
Filename of the HDF5-file.
construct_zone_axes : bool
If True, find relations between atomic positions by
constructing atomic planes. Default True.
Returns
-------
Atomap Atom_Lattice object
"""
h5f = h5py.File(filename, 'r')
if 'atom_lattice_type' in h5f.attrs.keys():
atom_lattice_type = h5f.attrs['atom_lattice_type']
if 'Atom_Lattice' in atom_lattice_type:
atom_lattice = al.Atom_Lattice()
elif 'Dumbbell_Lattice' in atom_lattice_type:
atom_lattice = al.Dumbbell_Lattice()
else:
atom_lattice = al.Atom_Lattice()
else:
atom_lattice = al.Atom_Lattice()
sublattice_list = []
sublattice_index_list = []
for group_name in h5f:
if ('atom_lattice' in group_name) or ('sublattice' in group_name):
sublattice_set = h5f[group_name]
modified_image_data = sublattice_set['modified_image_data'][:]
original_image_data = sublattice_set['original_image_data'][:]
atom_position_array = sublattice_set['atom_positions'][:]
if 'sublattice_index' in sublattice_set.attrs.keys():
sublattice_index_list.append(
sublattice_set.attrs['sublattice_index'])
sublattice = Sublattice(atom_position_array, modified_image_data)
sublattice.original_image = original_image_data
if 'sigma_x' in sublattice_set.keys():
sigma_x_array = sublattice_set['sigma_x'][:]
for atom, sigma_x in zip(sublattice.atom_list, sigma_x_array):
atom.sigma_x = sigma_x
if 'sigma_y' in sublattice_set.keys():
sigma_y_array = sublattice_set['sigma_y'][:]
for atom, sigma_y in zip(sublattice.atom_list, sigma_y_array):
atom.sigma_y = sigma_y
if 'rotation' in sublattice_set.keys():
rotation_array = sublattice_set['rotation'][:]
for atom, rotation in zip(sublattice.atom_list,
rotation_array):
atom.rotation = rotation
sublattice.pixel_size = sublattice_set.attrs['pixel_size']
if 'tag' in sublattice_set.attrs.keys():
sublattice.name = sublattice_set.attrs['tag']
elif 'name' in sublattice_set.attrs.keys():
sublattice.name = sublattice_set.attrs['name']
else:
sublattice.name = ''
if type(sublattice.name) == bytes:
sublattice.name = sublattice.name.decode()
sublattice._plot_color = sublattice_set.attrs['plot_color']
if type(sublattice._plot_color) == bytes:
sublattice._plot_color = sublattice._plot_color.decode()
if 'pixel_separation' in sublattice_set.attrs.keys():
sublattice._pixel_separation = sublattice_set.attrs[
'pixel_separation']
else:
sublattice._pixel_separation = 0.0
if construct_zone_axes:
construct_zone_axes_from_sublattice(sublattice)
if 'zone_axis_names_byte' in sublattice_set.keys():
zone_axis_list_byte = sublattice_set.attrs[
'zone_axis_names_byte']
zone_axis_list = []
for zone_axis_name_byte in zone_axis_list_byte:
zone_axis_list.append(zone_axis_name_byte.decode())
sublattice.zones_axis_average_distances_names = zone_axis_list
sublattice_list.append(sublattice)
if group_name == 'image_data':
atom_lattice.image = h5f[group_name][:]
if group_name == 'image_data0':
atom_lattice.image = h5f[group_name][:]
if group_name == 'image_extra_data':
atom_lattice.image_extra = h5f[group_name][:]
if group_name == 'image_data1':
atom_lattice.image_extra = h5f[group_name][:]
if group_name == 'original_image_data':
atom_lattice.original_image = h5f[group_name][:]
sorted_sublattice_list = []
if not sublattice_index_list: # Support for older hdf5 files
sublattice_index_list = range(len(sublattice_list))
for sublattice_index in sublattice_index_list:
sorted_sublattice_list.append(sublattice_list[sublattice_index])
atom_lattice.sublattice_list.extend(sorted_sublattice_list)
if 'name' in h5f.attrs.keys():
atom_lattice.name = h5f.attrs['name']
elif 'path_name' in h5f.attrs.keys():
atom_lattice.name = h5f.attrs['path_name']
if 'pixel_separation' in h5f.attrs.keys():
atom_lattice._pixel_separation = h5f.attrs['pixel_separation']
else:
atom_lattice._pixel_separation = 0.8 / sublattice.pixel_size
if type(atom_lattice.name) == bytes:
atom_lattice.name = atom_lattice.name.decode()
h5f.close()
return (atom_lattice)