API documentation

Classes

Model Refiner

Modules

TopoTEM (Polarisation)

Element Tools

temul.element_tools.atomic_radii_in_pixels(sampling, element_symbol)

Get the atomic radius of an element in pixels, scaled by an image sampling

Parameters:
  • sampling (float, default None) – sampling of an image in units of nm/pix
  • element_symbol (string, default None) – Symbol of an element from the periodic table of elements
Returns:
Return type:

Half the colavent radius of the input element in pixels

Examples

>>> import atomap.api as am
>>> from temul.element_tools import atomic_radii_in_pixels
>>> image = am.dummy_data.get_simple_cubic_signal()

pretend it is a 5x5 nm image

>>> image_sampling = 5/len(image.data) # units nm/pix
>>> radius_pix_Mo = atomic_radii_in_pixels(image_sampling, 'Mo')
>>> radius_pix_Mo
4.62

>>> radius_pix_S = atomic_radii_in_pixels(image_sampling, 'C')
>>> radius_pix_S
2.28
temul.element_tools.combine_element_lists(lists)

Reduce multiple element_lists into one list of strings from a list of lists, useful for the Model Refiner flattened_element_list.

temul.element_tools.get_and_return_element(element_symbol)

From the elemental symbol, e.g., ‘H’ for Hydrogen, provides Hydrogen as a periodictable.core.Element object for further use.

Parameters:element_symbol (string) – Symbol of an element from the periodic table of elements e.g., “C”, “H”
Returns:
Return type:A periodictable.core.Element object

Examples

>>> from temul.element_tools import get_and_return_element
>>> Moly = get_and_return_element(element_symbol='Mo')
>>> print(Moly.symbol)
Mo

>>> print(Moly.covalent_radius)
1.54

>>> print(Moly.number)
42
temul.element_tools.get_individual_elements_from_element_list(element_list, split_symbol=['_', '.'])

Examples

Single list

>>> import temul.element_tools as tml_el
>>> element_list = ['Mo_0', 'Ti_3', 'Ti_9', 'Ge_2']
>>> get_individual_elements_from_element_list(
...     element_list, split_symbol=['_', '.'])
['Ge', 'Mo', 'Ti']

some complex atomic_columns

>>> element_list = ['Mo_0', 'Ti_3.Re_7', 'Ti_9.Re_3', 'Ge_2']
>>> get_individual_elements_from_element_list(
...     element_list, split_symbol=['_', '.'])
['Ge', 'Mo', 'Re', 'Ti']

multiple lists in element_list. Used in Model_Refiner if you have more than one sublattice.

>>> element_list = [['Ti_7_0', 'Ti_9.Re_3', 'Ge_2'], ['B_9', 'B_2.Fe_8']]
>>> get_individual_elements_from_element_list(
...     element_list, split_symbol=['_', '.'])
['B', 'Fe', 'Ge', 'Re', 'Ti']
temul.element_tools.split_and_sort_element(element, split_symbol=['_', '.'])

Extracts info from input atomic column element configuration Split an element and its count, then sort the element for use with other functions.

Parameters:
  • element (string, default None) – element species and count must be separated by the first string in the split_symbol list. separate elements must be separated by the second string in the split_symbol list.
  • split_symbol (list of strings, default ['_', '.']) – The symbols used to split the element into its name and count. The first string ‘_’ is used to split the name and count of the element. The second string is used to split different elements in an atomic column configuration.
Returns:

  • list of a list with element_split, element_name, element_count, and
  • element_atomic_number.
  • See examples below

Examples

>>> from temul.element_tools import split_and_sort_element

simple atomic column

>>> split_and_sort_element(element='S_1')
[[['S', '1'], 'S', 1, 16]]

complex atomic column

>>> info = split_and_sort_element(element='O_6.Mo_3.Ti_5')

Intensity Tools

temul.intensity_tools.get_pixel_count_from_image_slice(self, image_data, percent_to_nn=0.4)

Fid the number of pixels in an area when calling _get_image_slice_around_atom()

Parameters:
  • image_data (Numpy 2D array) –
  • percent_to_nn (float, default 0.40) – Determines the boundary of the area surrounding each atomic column, as fraction of the distance to the nearest neighbour.
Returns:
Return type:

The number of pixels in the image_slice

Examples

>>> from temul.intensity_tools import get_pixel_count_from_image_slice
>>> import temul.external.atomap_devel_012.dummy_data as dummy_data
>>> sublattice = dummy_data.get_simple_cubic_sublattice()
>>> sublattice.find_nearest_neighbors()
>>> atom0 = sublattice.atom_list[0]
>>> pixel_count = get_pixel_count_from_image_slice(atom0, sublattice.image)
temul.intensity_tools.get_sublattice_intensity(sublattice, intensity_type='max', remove_background_method=None, background_sub=None, num_points=3, percent_to_nn=0.4, mask_radius=None)

Finds the intensity for each atomic column using either max, mean, min, total or all of them at once.

The intensity values are taken from the area defined by percent_to_nn.

Results are stored in each Atom_Position object as amplitude_max_intensity, amplitude_mean_intensity, amplitude_min_intensity and/or amplitude_total_intensity which can most easily be accessed through the sublattice object. See the examples in get_atom_column_amplitude_max_intensity.

Parameters:
  • sublattice (sublattice object) – The sublattice whose intensities you are finding.
  • intensity_type (string, default "max") – Determines the method used to find the sublattice intensities. The available methods are “max”, “mean”, “min”, “total” and “all”.
  • remove_background_method (string, default None) – Determines the method used to remove the background_sub intensities from the image. Options are “average” and “local”.
  • background_sub (sublattice object, default None) – The sublattice used if remove_background_method is used.
  • num_points (int, default 3) – If remove_background_method=”local”, num_points is the number of nearest neighbour values averaged from background_sub
  • percent_to_nn (float, default 0.40) – Determines the boundary of the area surrounding each atomic column, as fraction of the distance to the nearest neighbour.
  • mask_radius (float) – Radius of the atomic column in pixels. If chosen, percent_to_nn must be None.
Returns:
Return type:

Numpy array, shape depending on intensity_type

Examples

>>> from temul.intensity_tools import get_sublattice_intensity
>>> import temul.external.atomap_devel_012.dummy_data as dummy_data
>>> sublattice = dummy_data.get_simple_cubic_sublattice()
>>> sublattice.find_nearest_neighbors()
>>> intensities_all = get_sublattice_intensity(
...     sublattice=sublattice,
...     intensity_type="all",
...     remove_background_method=None,
...     background_sub=None)

Return the summed intensity around the atom:

>>> intensities_total = get_sublattice_intensity(
...     sublattice=sublattice,
...     intensity_type="total",
...     remove_background_method=None,
...     background_sub=None)

Return the summed intensity around the atom with local background subtraction:

>>> intensities_total_local = get_sublattice_intensity(
...     sublattice=sublattice,
...     intensity_type="total",
...     remove_background_method="local",
...     background_sub=sublattice)

Return the maximum intensity around the atom with average background subtraction:

>>> intensities_max_average = get_sublattice_intensity(
...     sublattice=sublattice,
...     intensity_type="max",
...     remove_background_method="average",
...     background_sub=sublattice)
temul.intensity_tools.remove_average_background(sublattice, intensity_type, background_sub, percent_to_nn=0.4, mask_radius=None)

Remove the average background from a sublattice intensity using a background sublattice.

Parameters:
  • sublattice (sublattice object) – The sublattice whose intensities are of interest.
  • intensity_type (string) – Determines the method used to find the sublattice intensities. The available methods are “max”, “mean”, “min” and “all”.
  • background_sub (sublattice object) – The sublattice used to find the average background.
  • percent_to_nn (float, default 0.4) – Determines the boundary of the area surrounding each atomic column, as fraction of the distance to the nearest neighbour.
  • mask_radius (float) – Radius of the atomic column in pixels. If chosen, percent_to_nn must be None.
Returns:
Return type:

Numpy array, shape depending on intensity_type

Examples

>>> from temul.intensity_tools import remove_average_background
>>> import temul.external.atomap_devel_012.dummy_data as dummy_data
>>> # import atomap.dummy_data as dummy_data
>>> sublattice = dummy_data.get_simple_cubic_sublattice()
>>> sublattice.find_nearest_neighbors()
>>> intensities_all = remove_average_background(
...     sublattice, intensity_type="all",
...     background_sub=sublattice)
>>> intensities_max = remove_average_background(
...     sublattice, intensity_type="max",
...     background_sub=sublattice)
temul.intensity_tools.remove_local_background(sublattice, background_sub, intensity_type, num_points=3, percent_to_nn=0.4, mask_radius=None)

Remove the local background from a sublattice intensity using a background sublattice.

Parameters:
  • sublattice (sublattice object) – The sublattice whose intensities are of interest.
  • intensity_type (string) – Determines the method used to find the sublattice intensities. The available methods are “max”, “mean”, “min”, “total” and “all”.
  • background_sub (sublattice object) – The sublattice used to find the local backgrounds.
  • num_points (int, default 3) – The number of nearest neighbour values averaged from background_sub
  • percent_to_nn (float, default 0.40) – Determines the boundary of the area surrounding each atomic column, as fraction of the distance to the nearest neighbour.
  • mask_radius (float) – Radius of the atomic column in pixels. If chosen, percent_to_nn must be None.
Returns:
Return type:

Numpy array, shape depending on intensity_type

Examples

>>> from temul.intensity_tools import remove_local_background
>>> import temul.external.atomap_devel_012.dummy_data as dummy_data
>>> sublattice = dummy_data.get_simple_cubic_sublattice()
>>> sublattice.find_nearest_neighbors()
>>> intensities_total = remove_local_background(
...     sublattice, intensity_type="total",
...     background_sub=sublattice)
>>> intensities_max = remove_local_background(
...     sublattice, intensity_type="max",
...     background_sub=sublattice)

Model Creation

Image Simulation Functions

Signal Processing

Signal Plotting

class temul.signal_plotting.Sublattice_Hover_Intensity(image, sublattice, sublattice_positions, background_sublattice)

User can hover over sublattice overlaid on STEM image to display the x,y location and intensity of that point.

scaled(points)
setup_annotation()

Draw and hide the annotation box.

snap(x, y)

Return the value in self.tree closest to x, y.

temul.signal_plotting.color_palettes(pallette)

Color sequences that are useful for creating matplotlib colormaps. Info on “zesty” and other options: venngage.com/blog/color-blind-friendly-palette/ Info on “r_safe”: Google: r-plot-color-combinations-that-are-colorblind-accessible

Parameters:palette (str) – Options are “zesty” (4 colours), and “r_safe” (12 colours).
Returns:
Return type:list of hex colours
temul.signal_plotting.compare_images_line_profile_one_image(image, line_profile_positions, linewidth=1, sampling='Auto', units='pix', arrow=None, linetrace=None, **kwargs)

Plots two line profiles on one image with the line profile intensities in a subfigure. See skimage PR PinkShnack for details on implementing profile_line in skimage: https://github.com/scikit-image/scikit-image/pull/4206

Parameters:
  • image (2D Hyperspy signal) –
  • line_profile_positions (list of lists) – two line profile coordinates. Use atomap’s am.add_atoms_with_gui() function to get these. The first two dots will trace the first line profile etc. Could be extended to n positions with a basic loop.
  • linewidth (int, default 1) – see profile_line for parameter details.
  • sampling (float, default 'Auto') –
    if set to ‘Auto’ the function will attempt to find the sampling of
    image from image.axes_manager[0].scale.
    arrow : string, default None
    If set, arrows will be plotting on the image. Options are ‘h’ and ‘v’ for horizontal and vertical arrows, respectively.
  • linetrace (int, default None) – If set, the line profile will be plotted on the image. The thickness of the linetrace will be linewidth*linetrace. Name could be improved maybe.
  • kwargs (Matplotlib keyword arguments passed to imshow()) –
temul.signal_plotting.compare_images_line_profile_two_images(imageA, imageB, line_profile_positions, reduce_func=<function mean>, filename=None, linewidth=1, sampling='auto', units='nm', crop_offset=20, title='Intensity Profile', imageA_title='Experiment', imageB_title='Simulation', marker_A='v', marker_B='o', arrow_markersize=10, figsize=(10, 3), imageB_intensity_offset=0)

Plots two line profiles on two images separately with the line profile intensities in a subfigure. See skimage PR PinkShnack for details on implementing profile_line in skimage: https://github.com/scikit-image/scikit-image/pull/4206

Parameters:
  • imageB (imageA,) –
  • line_profile_positions (list of lists) – one line profile coordinate. Use atomap’s am.add_atoms_with_gui() function to get these. The two dots will trace the line profile. See Examples below for example.
  • filename (string, default None) – If this is set to a name (string), the image will be saved with that name.
  • reduce_func (ufunc, default np.mean) – See skimage’s profile_line reduce_func parameter for details.
  • linewidth (int, default 1) – see profile_line for parameter details.
  • sampling (float, default 'auto') – if set to ‘auto’ the function will attempt to find the sampling of image from image.axes_manager[0].scale.
  • units (string, default 'nm') –
  • crop_offset (int, default 20) – number of pixels away from the line_profile_positions coordinates the image crop will be taken.
  • title (string, default "Intensity Profile") – Title of the plot
  • marker_B (marker_A,) –
  • arrow_markersize (Matplotlib markersize) –
  • figsize (see Matplotlib for details) –
  • imageB_intensity_offset (float, default 0) – Adds a y axis offset for comparison purposes.

Examples

>>> import atomap.api as am
>>> import temul.api as tml
>>> imageA = am.dummy_data.get_simple_cubic_signal(image_noise=True)
>>> imageB = am.dummy_data.get_simple_cubic_signal()
>>> # line_profile_positions = tml.choose_points_on_image(imageA)
>>> line_profile_positions = [[81.58, 69.70], [193.10, 184.08]]
>>> tml.compare_images_line_profile_two_images(
...     imageA, imageB, line_profile_positions,
...     linewidth=3, sampling=0.012, crop_offset=30)

To use the new skimage functionality try the reduce_func parameter:

>>> import numpy as np
>>> reduce_func = np.sum # can be any ufunc!
>>> tml.compare_images_line_profile_two_images(
...     imageA, imageB, line_profile_positions, reduce_func=reduce_func,
...     linewidth=3, sampling=0.012, crop_offset=30)

>>> reduce_func = lambda x: np.sum(x**0.5)
>>> tml.compare_images_line_profile_two_images(
...     imageA, imageB, line_profile_positions, reduce_func=reduce_func,
...     linewidth=3, sampling=0.012, crop_offset=30)

Offseting the y axis of the second image can sometimes be useful:

>>> import temul.example_data as example_data
>>> imageA = example_data.load_Se_implanted_MoS2_data()
>>> imageA.data = imageA.data/np.max(imageA.data)
>>> imageB = imageA.deepcopy()
>>> line_profile_positions = [[301.42, 318.9], [535.92, 500.82]]
>>> tml.compare_images_line_profile_two_images(
...     imageA, imageB, line_profile_positions, reduce_func=None,
...     imageB_intensity_offset=0.1)
temul.signal_plotting.create_rgb_array()
temul.signal_plotting.expand_palette(palette, expand_list)

Essentially multiply the palette so that it has the number of instances of each color that you want.

Parameters:
  • palette (list) – Color palette in hex, rgb or dec
  • expand_list (list) – List of integers that will be used to duplicate colours in the palette.
Returns:
Return type:

List of expanded palette

Examples

>>> import temul.api as tml
>>> zest = tml.color_palettes('zesty')
>>> expanded_palette = tml.expand_palette(zest, [1,2,2,2])
temul.signal_plotting.get_cropping_area(line_profile_positions, crop_offset=20)

By inputting the top-left and bottom-right coordinates of a rectangle, this function will add a border buffer (crop_offset) which can be used for cropping of regions in a plot. See compare_images_line_profile_two_images for use-case

temul.signal_plotting.get_polar_2d_colorwheel_color_list(u, v)

make the color_list from the HSV/RGB colorwheel. This color_list will be the same length as u and as v. It works by indexing the angle of the RGB (hue in HSV) array, then indexing the magnitude (r) in the RGB (value in HSV) array, leaving only a single RGB color for each vector.

temul.signal_plotting.hex_to_rgb(hex_values)

Change from hexidecimal color values to rgb color values. Grabs starting two, middle two, last two values in hex, multiplies by 16^1 and 16^0 for the first and second, respectively.

Parameters:hex_values (list) – A list of hexidecimal color values as strings e.g., ‘#F5793A’
Returns:
Return type:list of tuples

Examples

>>> import temul.api as tml
>>> tml.hex_to_rgb(color_palettes('zesty'))
[(245, 121, 58), (169, 90, 161), (133, 192, 249), (15, 32, 128)]

Create a matplotlib cmap from a palette with the help of matplotlib.colors.from_levels_and_colors()

>>> from matplotlib.colors import from_levels_and_colors
>>> zest = tml.hex_to_rgb(tml.color_palettes('zesty'))
>>> zest.append(zest[0])  # make the top and bottom colour the same
>>> cmap, norm = from_levels_and_colors(
...     levels=[0,1,2,3,4,5], colors=tml.rgb_to_dec(zest))
temul.signal_plotting.plot_atom_energies(sublattice_list, image=None, vac_or_implants=None, elements_dict_other=None, filename='energy_map', cmap='plasma', levels=20, colorbar_fontsize=16)

Used to plot the energies of atomic column configurations above 0 as calculated by DFT.

Parameters:
  • sublattice_list (list of Atomap Sublattices) –
  • image (array-like, default None) – The first sublattice image is used if image=None.
  • vac_or_implants (string, default None) – vac_or_implants options are “implants” and “vac”.
  • elements_dict_other (dict, default None) – A dictionary of {element_config1: energy1, element_config2: energy2, } The default is Se antisites in monolayer MoS2.
  • filename (string, default "energy_map") – Name with which to save the plot.
  • cmap (Matplotlib colormap, default "plasma") –
  • levels (int, default 20) – Number of Matplotlib contour map levels.
  • colorbar_fontsize (int, default 16) –
Returns:

  • The x and y coordinates of the atom positions and the
  • atom energy.
temul.signal_plotting.rgb_to_dec(rgb_values)

Change RGB color values to decimal color values (between 0 and 1). Required for use with matplotlib. See Example in hex_to_rgb below.

Parameters:rgb_values (list of tuples) –
Returns:
Return type:Decimal color values (RGB but scaled from 0 to 1 rather than 0 to 255)

Input/Output (io)

temul.io.batch_convert_emd_to_image(extension_to_save, top_level_directory, glob_search='**/*', overwrite=True)

Convert all .emd files to the chosen extension_to_save file format in the specified directory and all subdirectories.

Parameters:
  • extension_to_save (string) – the image file extension to be used for saving the image. See Hyperspy documentation for information on file writing extensions available: http://hyperspy.org/hyperspy-doc/current/user_guide/io.html
  • top_level_directory (string) – The top-level directory in which the emd files exist. The default glob_search will search this directory and all subdirectories.
  • glob_search (string) – Glob search string, see glob for more details: https://docs.python.org/2/library/glob.html Default will search this directory and all subdirectories.
  • overwrite (bool, default True) – Overwrite if the extension_to_save file already exists.
temul.io.convert_vesta_xyz_to_prismatic_xyz(vesta_xyz_filename, prismatic_xyz_filename, delimiter=' | | ', header=None, skiprows=[0, 1], engine='python', occupancy=1.0, rms_thermal_vib=0.05, edge_padding=None, header_comment="Let's make a file!", save=True)

Convert from Vesta outputted xyz file format to the prismatic-style xyz format. Lose some information from the .cif or .vesta file but okay for now. Develop your own converter if you need rms and occupancy! Lots to do.

delimiter=’ | | ‘ # ase xyz delimiter=’ | | ‘ # vesta xyz

Parameters:
  • vesta_xyz_filename (string) – name of the vesta outputted xyz file. See vesta > export > xyz
  • prismatic_xyz_filename (string) – name to be given to the outputted prismatic xyz file
  • header, skiprows, engine (delimiter,) – See pandas.read_csv for documentation Note that the delimiters here are only available if you use engine=’python’
  • rms_thermal_vib (occupancy,) – if you want a file format that will retain these atomic attributes, use a format other than vesta xyz. Maybe .cif or .vesta keeps these?
  • header_comment (string) – header comment for the file.
  • save (bool, default True) – whether to output the file as a prismatic formatted xyz file with the name of the file given by “prismatic_xyz_filename”.
Returns:
Return type:

The converted file format as a pandas dataframe

Examples

See example_data for the vesta xyz file.

>>> from temul.io import convert_vesta_xyz_to_prismatic_xyz
>>> prismatic_xyz = convert_vesta_xyz_to_prismatic_xyz(
...     'temul/example_data/prismatic/example_MoS2_vesta_xyz.xyz',
...     'temul/example_data/prismatic/MoS2_hex_prismatic.xyz',
...     delimiter='   |    |  ', header=None, skiprows=[0, 1],
...     engine='python', occupancy=1.0, rms_thermal_vib=0.05,
...     header_comment="Let's do this!", save=True)
temul.io.create_dataframe_for_xyz(sublattice_list, element_list, x_size, y_size, z_size, filename, header_comment='top_level_comment')

Creates a Pandas Dataframe and a .xyz file (usable with Prismatic) from the inputted sublattice(s).

Parameters:
  • sublattice_list (list of Atomap Sublattice objects) –
  • element_list (list of strings) – Each string must be an element symbol from the periodic table.
  • y_size, z_size (x_size,) – Dimensions of the x,y,z axes in Angstrom.
  • filename (string) – Name with which the .xyz file will be saved.
  • header_comment (string, default 'top_level_comment') –

Example

>>> import temul.external.atomap_devel_012.dummy_data as dummy_data
>>> sublattice = dummy_data.get_simple_cubic_sublattice()
>>> for i in range(0, len(sublattice.atom_list)):
...     sublattice.atom_list[i].elements = 'Mo_1'
...     sublattice.atom_list[i].z_height = '0.5'
>>> element_list = ['Mo_0', 'Mo_1', 'Mo_2']
>>> x_size, y_size = 50, 50
>>> z_size = 5
>>> dataframe = create_dataframe_for_xyz([sublattice], element_list,
...                          x_size, y_size, z_size,
...                          filename='dataframe',
...                          header_comment='Here is an Example')
temul.io.dm3_stack_to_tiff_stack(loading_file, loading_file_extension='.dm3', saving_file_extension='.tif', crop=False, crop_start=20.0, crop_end=80.0)

Save an image stack filetype to a different filetype, e.g., dm3 to tiff.

Parameters:
  • filename (string) – Name of the image stack file
  • loading_file_extension (string) – file extension of the filename
  • saving_file_extension (string) – file extension you wish to save as
  • crop (bool, default False) – if True, the image will be cropped in the navigation space, defined by the frames given in crop_start and crop_end
  • crop_end (crop_start,) – the start and end frame of the crop
temul.io.load_data_and_sampling(filename, file_extension=None, invert_image=False, save_image=True)
temul.io.load_prismatic_mrc_with_hyperspy(prismatic_mrc_filename, save_name='calibrated_data_')

We are aware this is currently producing errors with new versions of Prismatic.

Open a prismatic .mrc file and save as a hyperspy object. Also plots saves a png.

Parameters:prismatic_mrc_filename (string) – name of the outputted prismatic .mrc file.
Returns:
Return type:Hyperspy Signal 2D

Examples

>>> from temul.io import load_prismatic_mrc_with_hyperspy
>>> load_prismatic_mrc_with_hyperspy("temul/example_data/prismatic/"
...         "prism_2Doutput_prismatic_simulation.mrc")
<Signal2D, title: , dimensions: (|1182, 773)>
temul.io.save_individual_images_from_image_stack(image_stack, output_folder='individual_images')

Save each image in an image stack. The images are saved in a new folder. Useful for after running an image series through Rigid Registration.

Parameters:
  • image_stack (rigid registration image stack object) –
  • output_folder (string) – Name of the folder in which all individual images from the stack will be saved.
temul.io.write_cif_from_dataframe(dataframe, filename, chemical_name_common, cell_length_a, cell_length_b, cell_length_c, cell_angle_alpha=90, cell_angle_beta=90, cell_angle_gamma=90, space_group_name_H_M_alt='P 1', space_group_IT_number=1)

Write a cif file from a Pandas Dataframe. This Dataframe can be created with temul.model_creation.create_dataframe_for_cif().

Parameters:
  • dataframe (dataframe object) – pandas dataframe containing rows of atomic position information
  • chemical_name_common (string) – name of chemical
  • _cell_length_b, _cell_length_c (cell_length_a,) – lattice dimensions in angstrom
  • cell_angle_beta, cell_angle_gamma (cell_angle_alpha,) – lattice angles in degrees
  • space_group_name_H-M_alt (string) – space group name
  • space_group_IT_number (float) –

Dummy Data

Example Data

temul.example_data.load_Se_implanted_MoS2_data()

Load an ADF image of Se implanted monolayer MoS2.

Example

>>> import temul.example_data as example_data
>>> s = example_data.load_Se_implanted_MoS2_data()
>>> s.plot()
temul.example_data.load_Se_implanted_MoS2_simulation()

Get the simulated image of an MoS2 monolayer

Example

>>> import temul.example_data as example_data
>>> s = example_data.load_Se_implanted_MoS2_simulation()
>>> s.plot()
temul.example_data.load_example_Au_nanoparticle()

Get the emd STEM image of an example Au nanoparticle

Example

>>> import temul.example_data as example_data
>>> s = example_data.load_example_Au_nanoparticle()
>>> s.plot()
temul.example_data.load_example_Cu_nanoparticle_sim()

Get the hspy simulated image of an example Cu nanoparticle

Example

>>> import temul.example_data as example_data
>>> s = example_data.load_example_Cu_nanoparticle_sim()
>>> s.plot()
temul.example_data.path_to_example_data_MoS2_hex_prismatic()

Get the path of the xyz file for monolayer MoS2

Example

>>> import temul.example_data as example_data
>>> path_xyz_file = example_data.path_to_example_data_MoS2_hex_prismatic()
temul.example_data.path_to_example_data_MoS2_vesta_xyz()

Get the path of the vesta xyz file for bilayer MoS2

Example

>>> import temul.example_data as example_data
>>> path_vesta_file = example_data.path_to_example_data_MoS2_vesta_xyz()