High-symmetry cuts

Use this guide to show a selected reciprocal-space path beside its energy–momentum cut. Start with converted momentum_data.

Python

Define the path vertices in the coordinates of momentum_data. Then interpolate the complete data volume along the path:

import numpy as np

import erlab.analysis as era

lattice_constant = 6.97
high_symmetry_vertices = {
    "kx": [
        0.0,
        2 * np.pi / (np.sqrt(3) * lattice_constant),
        2 * np.pi / (np.sqrt(3) * lattice_constant),
        0.0,
    ],
    "ky": [0.0, 0.0, 2 * np.pi / (3 * lattice_constant), 0.0],
}
high_symmetry_cut = era.interpolate.slice_along_path(
    momentum_data,
    vertices=high_symmetry_vertices,
    step_size=0.005,
)

Calculate the path positions of the vertices. Use them for the x-axis ticks and the internal guide lines:

path_vertices = np.column_stack(
    [high_symmetry_vertices["kx"], high_symmetry_vertices["ky"]]
)
segment_lengths = np.linalg.norm(np.diff(path_vertices, axis=0), axis=1)
path_vertex_positions = np.concatenate(([0.0], np.cumsum(segment_lengths)))

Plot the selected path and the interpolated cut:

import matplotlib.pyplot as plt

import erlab.plotting as eplt

path_energy_map = momentum_data.qsel(eV=-0.2, eV_width=0.02)
fig, axes = plt.subplots(
    1,
    2,
    figsize=(6.4, 3.2),
    layout="compressed",
    gridspec_kw={"width_ratios": (1.0, 1.35)},
)

eplt.plot_array(
    path_energy_map,
    ax=axes[0],
    cmap="Greys",
    gamma=0.7,
    aspect="equal",
)
eplt.plot_hex_bz(
    a=lattice_constant,
    ax=axes[0],
    fill=False,
    edgecolor="0.35",
    linewidth=0.8,
)
axes[0].plot(
    high_symmetry_vertices["kx"],
    high_symmetry_vertices["ky"],
    color="tab:red",
    marker="o",
    markersize=3,
    linewidth=1.2,
)
axes[0].set_title(r"$E = E_F - 0.2$ eV")

eplt.plot_array(high_symmetry_cut, ax=axes[1], cmap="Greys", gamma=0.7)
eplt.fermiline(ax=axes[1], linestyle="--", linewidth=0.8)
for position in path_vertex_positions[1:-1]:
    axes[1].axvline(position, color="0.5", linestyle="--", linewidth=0.8)
axes[1].set_xticks(path_vertex_positions, labels=["Γ", "M", "K", "Γ"])
axes[1].set(
    xlabel="",
    xlim=(path_vertex_positions[0] - 0.03, path_vertex_positions[-1] + 0.03),
)

(Source code)

The interpolation follows an ideal line. It does not average intensity over a finite width perpendicular to the path. See Extracting data along a momentum path for sampling and path checks.

Figure Composer

ImageTool calculation

Start with the same converted momentum_data used in the Python procedure:

1. Open momentum_data in a managed ImageTool.

2. Display the \(k_x\)-\(k_y\) plane. Move the energy cursor to the required binding energy. Set the energy bin width in the Binning panel.

3. Right-click the image and choose Add Polygon ROI.

4. Place the ROI vertices in path order. Right-click the ROI and choose Edit ROI… to enter the exact high-symmetry point coordinates. Leave Closed off.

5. Right-click the ROI and choose Slice Along ROI Path.

6. Set New Dim Name to path. Select a suitable Step Size, set Result Placement to Open Child Window, and create the cut.

7. Return to the original ImageTool. Right-click the displayed constant energy surface and choose New Figure. Figure Composer records the displayed energy selection and bin width. You do not have to create path_energy_map in Python.

8. Set the Figure Composer layout to \(1 \times 2\). Target the existing Image Plot step to the left axes.

9. In the ROI-derived cut ImageTool, right-click the image and choose Append to Figure. Select the same figure and the right axes. You do not have to create high_symmetry_cut in Python.

For more information about ROI editing and path interpolation, see Extracting data along a polygonal path.

The ROI result uses cumulative distance as its path coordinate. At each ROI vertex, record the path value where the associated kx and ky coordinates match that vertex. Use these values for the guide lines and tick labels below. The path_vertex_positions calculation in the Python section gives the same values.

If you used the Python procedure above to prepare path_energy_map and high_symmetry_cut, open both arrays in ImageTool Manager and add them in Sources:

1. Use a \(1 \times 2\) layout.

2. Add an Image Plot step for path_energy_map on the left axes. Set Aspect to equal.

3. Add an Image Plot step for high_symmetry_cut on the right axes.

Figure assembly

The single first-zone boundary drawn by erlab.plotting.plot_hex_bz() does not have an editable Figure Composer step.

Planned Figure Composer support

Figure Composer does not yet have an editable step for this plotting operation. Structured support is planned. Until then, add a Python step to the recipe and use the code in this section.

1. Add a Python step after the left image.

2. Review this code, then enter it in Code:

lattice_constant = 6.97
eplt.plot_hex_bz(
    a=lattice_constant,
    ax=axs[0, 0],
    fill=False,
    edgecolor="0.35",
    linewidth=0.8,
)

3. Add an Axes Method step after the boundary. Select plot and target the left axes. Set Plot data to Pick from data. For X, select the path-cut source and kx. For Y, select the same source and ky.

4. Add an ERLab Method step for fermiline on the right axes.

5. Add one Axes Method step for each internal guide. Select Vertical line, target the right axes, and enter the cumulative path-coordinate value of the corresponding internal ROI vertex. These values are path_vertex_positions[1:-1] in the Python example.

6. Add an Axes Method step for Set x ticks on the right axes. Enter the cumulative path-coordinate values of all ROI vertices and the labels Γ, M, K, Γ. These values are path_vertex_positions in the Python example.

7. Add an Axes Method step for set_xlabel on the right axes. Leave Label empty so that the cumulative path distance is not shown.

Replace the lattice constant and path positions with values for the measured material.