This page documents the PyARPES API by generation from signatures and docstrings. You can use this and the source code to supplement the remainder of the PyARPES documentation.

Please note that this is not a complete API documentation page. Less used and internal APIs are not documented here.

Data-loading functions #

`io.load_data`(file[, location])	Loads a piece of data using available plugins.
`io.load_example_data`([example_name])	Provides sample data for executable documentation.
`io.example_data`	ExampleData()

Xarray_extensions #

Establishes the PyARPES data model by extending the xarray types.

This is another core part of PyARPES. It provides a lot of extensions to what comes out of the box in xarray. Some of these are useful generics, generally on the .T extension, others collect and manipulate metadata, interface with plotting routines, provide functional programming utilities, etc.

If f is an ARPES spectrum, then f.S should provide a nice representation of your data in a Jupyter cell. This is a complement to the text based approach that merely printing f offers. Note, as of PyARPES v3.x.y, the xarray version has been bumped and this representation is no longer necessary as one is provided upstream.

The main accessors are .S, .G, and .F.

The .S accessor:: The .S accessor contains functionality related to spectroscopy. Utilities which only make sense in this context should be placed here, while more generic tools should be placed elsewhere.
The .G. accessor:: This a general purpose collection of tools which exists to provide conveniences over what already exists in the xarray data model. As an example, there are various tools for simultaneous iteration of data and coordinates here, as well as for vectorized application of functions to data or coordinates.
The .F accessor:: This is an accessor which contains tools related to interpreting curve fitting results. In particular there are utilities for vectorized extraction of parameters, for plotting several curve fits, or for selecting “worst” or “best” fits according to some measure.

The .S accessor #

class arpes.xarray_extensions.accessor.property.ARPESAngleProperty[source]#

Bases: Generic[DataType]

Class for Angle related property.

_obj#

ARPES data

Type:: XrTypes

Note

This class should not be called directly.

property angle_unit[source]#: Return Angle unit Enum (“Degrees” or “Radians”).

lookup_coord(name)[source]#: Return the coordinates, if not return np.nan.

property sample_angles[source]#

The angle (\(\beta,\,\theta,\,\chi,\,\phi,\,\psi,\,\alpha\)) values.

Returns: tuple[xr.DataArray | float, …]: beta, theta, chi, phi, psi, alpha

switch_angle_unit()[source]#

Switch angle unit (radians <-> degrees) in place.

Change the value of angle related objects/variables in attrs and coords

switched_angle_unit()[source]#

Return the identical data but the angle unit is converted.

Change the value of angle related objects/variables in attrs and coords

Returns:: The DataArray in which angle units are converted.
Return type:: xr.DataArray

class arpes.xarray_extensions.accessor.property.ARPESPhysicalProperty[source]#

Bases: Generic[DataType]

Class for ARPES physical properties.

_obj#

ARPES data

Type:: XrTypes

Note

This class should not be called directly.

property analyzer_work_function[source]#

The work function of the analyzer, if present in metadata.

otherwise, use appropriate value.

Note

Use this value for k-conversion.

property energy_notation[source]#: The energy notation (“Binding” energy or “Final” state energy).

property experimental_conditions[source]#

hv, polarization, temperature.

Use this property in plotting/annotations.py/conditions

Type:: The experimental condition

property hv[source]#

The photon energy for excitation.

Returns: float | xr.DataArray: Photon energy in eV unit. (for hv_map type, xr.DataArray is returned.)

property inner_potential[source]#: The inner potential, if present in metadata. Otherwise, 10 eV is assumed.

property polarization[source]#: The light polarization information.

Todo

Test

property probe_polarization[source]#: The probe polarization of the UV/x-ray source.

property pump_polarization[source]#: The pump polarization for Tr-ARPES experiments.

property sample_pos[source]#: The sample position, x, y, and z.

property sherman_function[source]#

Sherman function from attributes.

Returns: float: Sharman function
Raises: ValueError: When no Sherman function related value is found.

Todo

Test, Consider if it should be in “S”

switch_energy_notation(nonlinear_order=1)[source]#

Switch the energy notation between binding and kinetic.

Parameters:: nonlinear_order (int) – order of the nonliniarity, default to 1

property temp[source]#: The temperature at which an experiment was performed.

property work_function[source]#

The work function of the sample, if present in metadata.

Otherwise, uses something approximate.

Note

This “work_function” should NOT be used for k-conversion!

class arpes.xarray_extensions.accessor.property.ARPESInfoProperty[source]#

Bases: ARPESPhysicalProperty[DataType]

Class for Information Property.

_obj#

ARPES data

Type:: arpes._typing.base.DataType

Note

This class should not be called directly.

property analyzer_detail[source]#: Details about the analyzer, its capabilities, and metadata.

property analyzer_info[source]#: General information about the photoelectron analyzer used.

property beamline_info[source]#: Information about the beamline or light source used for a measurement.

property daq_info[source]#: General information about the acquisition settings for an ARPES experiment.

property endstation[source]#

Alias for the location attribute used to load the data.

Returns:: The name of loader/location which was used to load data.

property experiment_info[source]#: Experiment information property, such as temperature, pressure, etc.

property label[source]#: Return “description” in attrs or scan_name.

property laser_info[source]#: Laser information property, both pump and probe properties.

property monochromator_info[source]#: Details about the monochromator used on the UV/x-ray source.

property prebinning[source]#: Information about the prebinning performed during scan acquisition.

property probe_info[source]#

Probe pulse information property.

Returns (LightSourceInfo):

property pump_info[source]#: Pump pulse information property.

property sample_info[source]#

Sample info property.

Returns (SampleInfo):

property scan_info[source]#: Scan information, measurement data/time, scan type, and sample name, etc.

property scan_name[source]#

The scan name.

Returns: (str): If “scan” or “file” is set in attrs, return the file name. If they are not set, return “id” if “id” is set.

property scan_type[source]#: Scan type (DAQ type).

property spectrum_type[source]#: Spectrum type (cut, map, hv_map, ucut, spem and xps).

property sweep_settings[source]#: For datasets acquired with swept acquisition settings, provides those settings.

property undulator_info[source]#: Details about the undulator for data performed at an undulator source.

class arpes.xarray_extensions.accessor.property.ARPESProvenanceProperty[source]#

Bases: Generic[DataType]

Class for Provenance related property.

property history[source]#

Retrieves the complete processing history (provenance) of the xarray object.

This property extracts nested provenance records stored in the _obj.attrs[“provenance”] attribute. It unwraps these records from the most recent operation back to the original data, forming a chronological list of processing steps.

The provenance information is expected to be stored in a nested dictionary structure where each step has a parents_provenance key pointing to the previous step(s). This method flattens that hierarchical structure into a linear list.

Returns:

A list of dictionaries, where each dictionary represents a processing step (Provenance record) in the history of the dataset, ordered from the most recent to the oldest. An empty list is returned if no provenance is recorded or if it’s invalid.

Return type:

list[Provenance]

Warns:

UserWarning –

If the provenance attribute is found to be a string type, indicating an older or malformed provenance record.
If multiple parents are encountered in a parents_provenance list, as only the first parent will be considered and others ignored.

Examples

Assuming ds is an xr.Dataset with provenance recorded:

>>> # Example setup for a Dataset with nested provenance
>>> from arpes_analyzer.history import Provenance # Hypothetical import
>>> ds = xr.Dataset()
>>> ds.attrs['provenance'] = {
...     'step_name': 'filter',
...     'params': {'kernel_size': 3},
...     'parents_provenance': {
...         'step_name': 'normalize',
...         'params': {'method': 'max'},
...         'parents_provenance': {
...             'step_name': 'load_data',
...             'params': {'file': 'data.h5'}
...         }
...     }
... }
>>> accessor = YourARPESAccessor(ds)
>>> history_list = accessor.history
>>> for entry in history_list:
...     print(entry['step_name'])
filter
normalize
load_data

>>> # Example with no provenance
>>> ds_no_prov = xr.Dataset()
>>> accessor_no_prov = YourARPESAccessor(ds_no_prov)
>>> accessor_no_prov.history
[]

>>> # Example with string provenance (warns)
>>> ds_str_prov = xr.Dataset()
>>> ds_str_prov.attrs['provenance'] = "Old string provenance record."
>>> accessor_str_prov = YourARPESAccessor(ds_str_prov)
>>> # This will print a warning and return ['Old string provenance record.']
>>> accessor_str_prov.history
['Old string provenance record.']

property is_differentiated[source]#

Return True if the spectrum is differentiated data.

Returns: bool

Todo

Test

property parent_id[source]#: Return id object of the parent object.

short_history(key='by')[source]#

Return the short version of history.

Parameters:: key (str) – key str in recorded dict of self.history. (default: “by”)

class arpes.xarray_extensions.accessor.property.ARPESOffsetProperty[source]#

Bases: ARPESAngleProperty[DataType]

Class for offset value property.

_obj#

ARPES data

Type:: arpes._typing.base.DataType

Note

This class should not be called directly.

apply_offsets(offsets)[source]#

Applies and records angular offsets to the xarray object’s attributes.

This method iterates through a dictionary of angle types and their corresponding offset values, storing each offset in the _obj.attrs dictionary. The attribute key is formatted as “{angle_type}_offset”.

These offsets are typically used to correct or define the zero-point for various angular dimensions (e.g., k-parallel, polar angle theta).

Parameters:

offsets (dict[ANGLE, float]) – A dictionary where keys are ANGLE enum members (or similar type representing angle dimensions, e.g., “k_parallel”, “theta”) and values are the float offsets to be applied.

Returns:

This method modifies the _obj.attrs in-place and does not: return any value.

Return type:

None

Raises:

AssertionError – If the internal _obj is not an instance of xarray.Dataset or xarray.DataArray.

Examples

Assuming ds is an xr.Dataset and ANGLE.K_PARALLEL is defined:

>>> ds_accessor = YourAccessorClass(ds)
>>> ds_accessor.apply_offsets({ANGLE.K_PARALLEL: 0.05, ANGLE.THETA: -0.1})
>>> ds.attrs['k_parallel_offset']
0.05
>>> ds.attrs['theta_offset']
-0.1

property beta_offset[source]#: Offset of \(\beta\) angle.

property chi_offset[source]#: Offset of \(\chi\) angle.

property is_slit_vertical[source]#

Infers whether the scan is taken on an analyzer with vertical slit.

Caveat emptor: this assumes that the alpha coordinate is not some intermediate value.

Returns:: True if the alpha value is consistent with a vertical slit analyzer. False otherwise.

property iter_own_symmetry_points[source]#

An iterator property that yields high-symmetry points and their coordinates.

This property provides a convenient way to iterate over the high-symmetry points associated with the current dataset’s Brillouin zone or band structure, along with their corresponding coordinate dictionaries. It relies on the symmetry_points() method (which is assumed to be defined elsewhere within this class or a related one) to retrieve the mapping of symmetry point names to their coordinates.

Yields:

tuple[HIGH_SYMMETRY_POINTS, dict[str, float]] –

The symmetry-point: name together with a dictionary of coordinate values for that point.

Examples

>>> # Assume ds_accessor.symmetry_points() returns:
>>> # {HIGH_SYMMETRY_POINTS.GAMMA: {'kx': 0.0, 'ky': 0.0},
>>> #  HIGH_SYMMETRY_POINTS.X_POINT: {'kx': 1.0, 'ky': 0.0}}
>>> for point_name, coords in ds_accessor.iter_own_symmetry_points:
...     print(f"Symmetry Point: {point_name}, Coordinates: {coords}")

property logical_offsets[source]#

The logical offsets of the sample position.

Returns:: dict object of long_[x, y, z] + physical_long_[x, y, z]

Todo

Consering if this is really suitable way?

While this variable used just in MAESTRO.py which I haven’t used, to keep consistensy with other plugins the following change seems to be reasonable.
- coords[“long_x”] should be coosrds[“x”] ?
- coords[“physical_long_x”] seems to be just x_offset.

lookup_offset(attr_name)[source]#: Return the offset value.

lookup_offset_coord(name)[source]#: Return the offset coordinate.

property offsets[source]#: The offset values.

property phi_offset[source]#: Offset of \(\phi\) angle.

property psi_offset[source]#: Offset of \(\psi\) angle.

symmetry_points()[source]#

Return the dict object about symmetry point such as G-point in the ARPES data.

The original version was something complicated, but the coding seemed to be in process and the purpose was unclear, so it was streamlined considerably.

Returns (dict[HIGH_SYMMETRY_POINTS, dict[str, float]]):: Dict object representing the symmetry points in the ARPES data.

Raises:: RuntimeError – When the label of high symmetry_points in arr.attrs[symmetry_points] is not in HIGH_SYMMETRY_POINTS declared in _typing.py

Examples

symmetry_points = {“G”: {“phi”: 0.405}}

property theta_offset[source]#: Offset of \(\theta\) angle.

with_rotation_offset(offset)[source]#

Temporarily rotates the chi_offset by offset.

Parameters:: offset (float) – offset value about chi.

Todo

Test

class arpes.xarray_extensions.accessor.property.ARPESPropertyBase[source]#

Bases: ARPESInfoProperty[DataType], ARPESOffsetProperty[DataType], ARPESProvenanceProperty[DataType]

Base class for ARPES Property.

property beamline_settings[source]#: Return beam line setting.

property full_coords[source]#

Return the coordinate.

Returns: xr.Coordinates: Coordinates data.

property is_kspace[source]#

Infers whether the scan is k-space converted or not.

Because of the way this is defined, it will return true for XPS spectra, which I suppose is true but trivially.

Returns:: True if the data is k-space converted. False otherwise.

property is_spatial[source]#

Infers whether a given scan has real-space dimensions (SPEM or u/nARPES).

Returns:: True if the data is explicitly a “ucut” or “spem” or contains “X”, “Y”, or “Z” dimensions. False otherwise.

property reference_settings[source]#: Return Reference setting.

property spectrometer_settings[source]#: Return spectrometer setting.

class arpes.xarray_extensions.accessor.property.ARPESProperty[source]#

Bases: ARPESPropertyBase[DataType]

Class for ARPES property.

static dict_to_html(d)[source]#

Return html format of dict object.

Parameters:: d – dict object
Returns:: html representation of dict object

Todo

Test

class arpes.xarray_extensions.accessor.base.ARPESDataArrayAccessorBase(xarray_obj)[source]#

Bases: ARPESAccessorBase[DataArray]

Base class for accessors specifically designed for xarray.DataArray objects in PyARPES.

This class extends ARPESAccessorBase and provides methods tailored for single-variable ARPES data, such as inferring background subtraction status and performing advanced selections around specific data points.

property is_subtracted[source]#

Infers whether a given data is subtracted.

Returns (bool):: Return True if the data is subtracted.

select_around(point, radius, *, mode='sum')[source]#

Selects and integrates a region around a one dimensional point.

This method is useful to do a small region integration, especially around point on a path of a k-point of interest. See also the companion method select_around_data.

Parameters:

point – The point where the selection should be performed.
radius – The radius of the selection in each coordinate. If dimensions are omitted, a standard sized selection will be made as a compromise.
safe – If true, infills radii with default values. Defaults to True.
mode – How the reduction should be performed, one of “sum” or “mean”. Defaults to “sum”

Returns:

The binned selection around the desired point.

select_around_data(points, radius=None, *, mode='sum')[source]#

Performs a binned selection around a point or points.

Can be used to perform a selection along one axis as a function of another, integrating a region in the other dimensions.

Example

As an example, suppose we have a dataset with dimensions (‘eV’, ‘kp’, ‘T’,) and we also by fitting determined the Fermi momentum as a function of T, kp_F(‘T’), stored in the dataset kFs. Then we could select momentum integrated EDCs in a small window around the fermi momentum for each temperature by using

>>> edcs = full_data.S.select_around_data(points={'kp': kFs}, radius={'kp': 0.04})

The resulting data will be EDCs for each T, in a region of radius 0.04 inverse angstroms around the Fermi momentum.

Parameters:

points – The set of points where the selection should be performed.
radius – The radius of the selection in each coordinate. If dimensions are omitted, a standard sized selection will be made as a compromise.
mode – How the reduction should be performed, one of “sum” or “mean”. Defaults to “sum”

Returns:

The binned selection around the desired point or points.

class arpes.xarray_extensions.accessor.spectroscopy.ARPESDataArrayAccessor(xarray_obj)[source]#

Bases: ARPESDataArrayAccessorBase

Spectrum related accessor for xr.DataArray.

correct_coords(correction_types)[source]#

Correct the coordinates of the DataArray in place.

Parameters:: correction_types (CoordsOffset | Sequence[CoordsOffset, ...]) – The types of corrections to apply.

corrected_coords(correction_types)[source]#

Apply the specified coordinate corrections to the DataArray.

Parameters:: correction_types (CoordsOffset | Sequence[CoordsOffset]) – The types of corrections to apply.
Returns:: The corrected DataArray.
Return type:: xr.DataArray

fat_sel(widths=None, method='mean', **kwargs)[source]#: See ARPESDatasetAccessor.fat_sel().

fermi_edge_reference_plot(pattern='{}.png', out='', **kwargs)[source]#

Provides a reference plot for a Fermi edge reference.

This function generates a reference plot for a Fermi edge, which can be useful for analyzing energy spectra. It calls the fermi_edge_reference function and passes any additional keyword arguments to it for plotting customization. The output file name can be specified using the out argument, with a default name pattern.

Parameters:

pattern (str) – A string pattern for the output file name. The pattern can include placeholders that will be replaced by the label or other variables. Default is “{}.png”.
out (str | Path) – The path for saving the output figure. If set to None or False, no figure will be saved. If a boolean True is passed, it will use the pattern to generate the filename.
kwargs – Additional arguments passed to the fermi_edge_reference function for customizing the plot.

Returns:

The path to the saved figure (if out is provided), or the Axes object of the plot.Provides a reference plot for a Fermi edge reference.

Return type:

Path | Axes

fs_plot(pattern='{}.png', **kwargs)[source]#: Provides a reference plot of the approximate Fermi surface.

mean_other(dim_or_dims, *, keep_attrs=False)[source]#: See ARPESDatasetAccessor.mean_other().

plot(*args, **kwargs)[source]#

Utility delegate to xr.DataArray.plot which rasterizes`.

Parameters:

rasterized (bool) – if True, rasterized (Not vector) drawing
args – Pass to xr.DataArray.plot
kwargs – Pass to xr.DataArray.plot

reference_plot(**kwargs)[source]#

Generates a reference plot for this piece of data according to its spectrum type.

Parameters:: kwargs – pass to referenced_scans_for_**
Raises:: NotImplementedError – If there is no standard approach for plotting this data.
Returns:: The axes which were used for plotting.

show(**kwargs)[source]#: Show holoviews based plot.

sum_other(dim_or_dims, *, keep_attrs=False)[source]#: See ARPESDatasetAccessor.sum_other().

class arpes.xarray_extensions.accessor.spectroscopy.ARPESDatasetAccessor(xarray_obj)[source]#

Bases: ARPESAccessorBase[Dataset]

Spectrum related accessor for xr.Dataset.

__getattr__(item)[source]#

Forward attribute access to the spectrum, if necessary.

Parameters:: item – Attribute name
Returns:: The attribute after lookup on the default spectrum

fat_sel(widths=None, method='mean', **kwargs)[source]#

Performs a ‘fat’ selection, integrating data over small regions specified by widths.

This method allows for integrating a selection over a small coordinate region (defined by widths or keyword arguments), effectively reducing noise by averaging or summing over nearby slices. The resulting dataset will be normalized by the number of slices integrated over if method=”mean”.

Parameters:

widths (dict[Hashable, float] | None, optional) – A dictionary specifying the width of the integration window for each dimension. Keys are dimension names (Hashable), and values are float widths. Overrides any widths specified in kwargs. Defaults to None, in which case selections.fat_sel might use default widths.
method (ReduceMethod, optional) – The reduction method to apply within the selection window. Can be “mean” (default) or “sum”.
**kwargs (float) – Keyword arguments that can define specific selection points (e.g., eV=1.5) or widths (e.g., eV_width=0.1). Note: Using *_width in kwargs for specifying widths is deprecated. Prefer the widths dictionary argument.

Returns:

The xarray.DataArray or xarray.Dataset after the ‘fat’ selection and reduction have been applied. The dimensions for which a width was specified will effectively be reduced or removed.

Return type:

XrTypes

Note

The widths argument is the preferred way to specify integration widths. Using *_width through kwargs is deprecated and may be removed in future versions.

make_spectrum_reference_plots(prefix='', **kwargs)[source]#

Creates photocurrent normalized + unnormalized figures.

Creates:

The reference plots for the photocurrent normalized spectrum
The normalized total cycle intensity over scan DoF, i.e. cycle vs scan DOF integrated over E, phi
For delay scans
1. Fermi location as a function of scan DoF, integrated over phi
2. Subtraction scans

Parameters:

prefix – A prefix inserted into filenames to make them unique.
kwargs – Passed to plotting routines to provide user control over plotting behavior

mean_other(dim_or_dims, *, keep_attrs=False)[source]#

Calculates the mean over all dimensions except those specified.

This is a convenience method for xarray.Dataset.mean() or xarray.DataArray.mean() that inverts the selection of dimensions. Instead of specifying dimensions to average along, you specify dimensions to keep.

Parameters:

dim_or_dims (list[str] | str) – A list of dimension names to keep, or a single dimension name string. The mean operation will be performed over all other dimensions not in this list/string.
keep_attrs (bool, optional) – If True, attributes (.attrs) will be preserved on the returned object. Defaults to False.

Returns:

A new xarray object (Dataset or DataArray) with the data averaged along the specified “other” dimensions. Its dimensions will only include those listed in dim_or_dims.

Return type:

DataType

Raises:

AssertionError – If dim_or_dims is not a list (note: the type hint allows str but the assertion explicitly checks for list). This discrepancy should be resolved for consistency. For now, the docstring reflects the assertion.

Examples

>>> data = xr.DataArray(np.arange(12).reshape(2, 2, 3), dims=['x', 'y', 'z'])
>>> accessor = ARPESAccessorBase(data)
>>> accessor.mean_other(dim_or_dims=['x']) # Averages over 'y' and 'z'
<xarray.DataArray (x: 2)>
array([2.5, 8.5])
Coordinates:
  * x        (x) int64 0 1
>>> accessor.mean_other(dim_or_dims=['y', 'z']) # Averages over 'x'
<xarray.DataArray (y: 2, z: 3)>
array([[2.5, 3.5, 4.5],
       [5.5, 6.5, 7.5]])
Coordinates:
  * y        (y) int64 0 1
  * z        (z) int64 1 2 3

reference_plot(**kwargs)[source]#

Creates reference plots for a dataset.

A bit of a misnomer because this actually makes many plots. For full datasets, the relevant components are:

Temperature as function of scan DOF
Photocurrent as a function of scan DOF
Photocurrent normalized + unnormalized figures, in particular
1. The reference plots for the photocurrent normalized spectrum
2. The normalized total cycle intensity over scan DoF, i.e. cycle vs scan DOF integrated
  over E, phi
3. For delay scans
  Fermi location as a function of scan DoF, integrated over phi
  
  Subtraction scans
For spatial scans
1. energy/angle integrated spatial maps with subsequent measurements indicated
2. energy/angle integrated FS spatial maps with subsequent measurements indicated

Parameters:: kwargs – Passed to plotting routines to provide user control

property spectra[source]#

Collects the variables which are likely spectra.

Returns:: The subset of the data_vars which have dimensions indicating that they are spectra.

property spectrum[source]#

Isolates a single spectrum from a dataset.

This is a convenience method which is typically used in startup for tools and analysis routines which need to operate on a single piece of data. Historically, the handling of Dataset and Dataarray was a mess in previous pyarpes. Most of the current pyarpes methods/function are sufficient to treat DataArray as the main object. (The few exceptions are S.modelfit, whose return value is a Dataset, which is reasonable.) For backward compatibility, the return of load_data is still a Dataset, so in many cases, using this property for a DataArray will provide a more robust analysing environment.

In practice, we filter data variables by whether they contain “spectrum” in the name before selecting the one with the largest pixel volume. This is a heuristic which tries to guarantee we select ARPES data above XPS data, if they were collected together.

Returns:

A spectrum found in the dataset, if one can be isolated.

In the case that several candidates are found, a single spectrum is selected among the candidates.

Attributes from the parent dataset are assigned onto the selected array as a convenience.

Todo: Need test

sum_other(dim_or_dims, *, keep_attrs=False)[source]#

Calculates the sum over all dimensions except those specified.

This is a convenience method for xarray.Dataset.sum() or xarray.DataArray.sum() that inverts the selection of dimensions. Instead of specifying dimensions to sum along, you specify dimensions to keep.

Parameters:

dim_or_dims (list[str]) – A list of dimension names to keep. The sum operation will be performed over all other dimensions not in this list.
keep_attrs (bool, optional) – If True, attributes (.attrs) will be preserved on the returned object. Defaults to False.

Returns:

A new xarray object (Dataset or DataArray) with the data summed along the specified “other” dimensions. Its dimensions will only include those listed in dim_or_dims.

Return type:

DataType

Raises:

AssertionError – If dim_or_dims is not a list.

Examples

>>> data = xr.DataArray(np.ones((2, 3, 4)), dims=['x', 'y', 'z'])
>>> accessor = ARPESAccessorBase(data)
>>> accessor.sum_other(dim_or_dims=['x']) # Sums over 'y' and 'z'
<xarray.DataArray (x: 2)>
array([12., 12.])
Dimensions without coordinates: y, z
Coordinates:
  * x        (x) int64 0 1
>>> accessor.sum_other(dim_or_dims=['y', 'z']) # Sums over 'x'
<xarray.DataArray (y: 3, z: 4)>
array([[2., 2., 2., 2.],
       [2., 2., 2., 2.],
       [2., 2., 2., 2.]])
Dimensions without coordinates: x
Coordinates:
  * y        (y) int64 0 1 2
  * z        (z) int64 0 1 2 3

The .G accessor #

Available as methods via .G accessor.

class arpes.xarray_extensions.accessor.base.GenericAccessorBase[source]#

Bases: Generic[DataType]

Class for general-purpose utility methods for xarray.Dataset and xarray.DataArray objects.

This class offers functionalities such as coordinate manipulation, applying functions to data regions, and iterating over coordinates, which can be broadly useful across different types of scientific data.

coordinatize(as_coordinate_name=None)[source]#

Copies data into a coordinate’s data, with an optional renaming.

If you think of an array as a function c => f(c) from coordinates to values at those coordinates, this function replaces f by the identity to give c => c

Remarkably, coordinatize is a word.

For the most part, this is only useful when converting coordinate values into k-space “forward”.

Parameters:: as_coordinate_name – A new coordinate name for the only dimension. Defaults to None.
Returns:: An array which consists of the mapping c => c.

Todo

Test

enumerate_iter_coords(dim_names=())[source]#

Return an iterator for pixel and physical coordinates.

Aargs:: dir_names (Sequence[Hashable]): Dimension names for iterateion.

Yields:: Iteratoring the data like – ((0, 0), {‘phi’: -0.2178031280148764, ‘eV’: 9.0}) which shows the relationship between pixel position and physical (like “eV” and “phi”).

iter_coords(dim_names=(), *, reverse=False)[source]#

Iterator for coordinates along the axis.

Parameters:

dim_names (Sequence[Hashable]) – Dimensions for iteration.
reverse – return the “reversivle” iterator.

Yields:

Iterator of the physical position like (“eV” and “phi”) {‘phi’: -0.2178031280148764, ‘eV’: 9.002}

range(*, generic_dim_names=True)[source]#

Return the maximum/minimum value in each dimension.

Parameters:: generic_dim_names (bool) – if True, use Generic dimension name, such as ‘x’, is used.

Returns: (dict[str, tuple[float, float]]): The range of each dimension.

stride(*args, generic_dim_names=True)[source]#

Return the stride in each dimension.

Parameters:

args – The dimension to return. [“eV”, “phi”] or “eV”, “phi”
generic_dim_names (bool) – if True, use Generic dimension name, such as ‘x’, is used.

Returns:

The stride of each dimension

class arpes.xarray_extensions.accessor.general.GenericDatasetAccessor(xarray_obj)[source]#

Bases: GenericAccessorBase[Dataset]

A collection of generic accessors for xarray.Dataset objects.

This accessor provides utility methods for filtering data variables, and transforming meshgrid coordinates within an xarray Dataset.

Usage:: Register this accessor using @xr.register_dataset_accessor(“G”). Then, you can access its methods via the .G attribute on any xarray.Dataset: ds.G.filter_vars(…) or ds.G.shift_meshgrid(…).

apply_over(fn, *, copy=True, selections=None, **selections_kwargs)[source]#

Applies a function to a data region and updates the dataset with the result.

Parameters:

fn (Callable) – The function to apply.
copy (bool, optional) – If True, operates on a deep copy of the data. If False, modifies the data in-place. Defaults to True.
selections (Incomplete) – Keyword arguments specifying the region of the data to select.
**selections_kwargs – Selection keys and values as keyword arguments.

Returns:

The dataset after the function has been applied.

Return type:

XrTypes

Todo

Add tests.

filter_coord(coordinate_name, sieve)[source]#

Filters a dataset along a coordinate.

Sieve should be a function which accepts a coordinate value and the slice of the data along that dimension.

Internally, the predicate function sieve is applied to the coordinate and slice to generate a mask. The mask is used to select from the data after iteration.

An improvement here would support filtering over several coordinates.

Parameters:

coordinate_name – The coordinate which should be filtered.
sieve – A predicate to be applied to the coordinate and data at that coordinate.

Returns:

A subset of the data composed of the slices which make the sieve predicate True.

Todo

Test

filter_vars(f)[source]#

Filters data variables based on the specified condition and returns a new dataset.

This method iterates through the data variables of the Dataset and applies a user-defined filtering function. Only variables for which the function returns True will be included in the new Dataset. The original Dataset remains unchanged.

Parameters:

f (Callable[[Hashable, xr.DataArray], bool]) – A predicate function that takes two arguments: the name (hashable key) of a data variable and its corresponding xr.DataArray. It must return True to include the variable in the filtered dataset, or False to exclude it.

Returns:

A new xarray.Dataset containing only the data variables: that satisfied the filtering condition. The attributes of the original dataset are preserved.

Return type:

xr.Dataset

Examples

>>> import xarray as xr
>>> ds = xr.Dataset(
...     {"temp": (("x", "y"), [[1, 2], [3, 4]]),
...      "pressure": (("x", "y"), [[5, 6], [7, 8]])}
... )
>>> # Filter variables whose names start with 't'
>>> filtered_ds = ds.G.filter_vars(lambda k, v: k.startswith("t"))
>>> print(filtered_ds)
<xarray.Dataset>
Dimensions:  (x: 2, y: 2)
Data variables:
    temp     (x, y) int64 1 2 3 4
>>> # Filter variables with more than 2 elements
>>> filtered_ds = ds.G.filter_vars(lambda k, v: v.size > 2)
>>> print(filtered_ds)
<xarray.Dataset>
Dimensions:  (x: 2, y: 2)
Data variables:
    temp     (x, y) int64 1 2 3 4
    pressure (x, y) int64 5 6 7 8

The .F accessor #

Available as methods via .F accessor.

class arpes.xarray_extensions.accessor.fit.ARPESDatasetFitToolAccessor(xarray_obj)[source]#

Bases: object

Provides ARPES spectral fitting inspection and query tools for xarray.Dataset.

A custom accessor for xarray.Dataset objects, providing tools for inspecting and querying results from spectral fitting operations on ARPES data.

This accessor is registered under the name “F”, allowing users to access its methods via xr.Dataset.F.<method_name>.

_obj#

The xarray Dataset instance to which this accessor is attached.

Type:: xr.Dataset

fit_dimensions(spectral_name='spectrum')[source]#

Returns the dimensions which were broadcasted across, as opposed to fit across.

This is a sibling property to broadcast_dimensions.

Returns:: The list of the dimensions which were not used in any individual fit. For example, a broadcast of MDCs across energy on a dataset with dimensions [“eV”, “kp”] would produce [“eV”].

save_fit(path, **kwargs)[source]#

Wrapper of xarray_lmfit.save_fit.

Save the result dataset to a netCDF file, which can be loaded by using standard xarray.load_dataset()

Parameters:

path – Path to save the fit results
**kwargs – Passed to xarray.Dataset.to_netcdf

show(**kwargs)[source]#

Displays an interactive fit inspection tool for visualizing spectral fitting results.

This method leverages an external fit_inspection function to generate a visual interface that allows users to examine the quality of fits, individual components, and residuals across different dimensions of the dataset.

Parameters:

**kwargs (Unpack[ProfileViewParam]) – Arbitrary keyword arguments that are passed directly to the fit_inspection function. These typically control the appearance and behavior of the profile view, such as plotting parameters or selection criteria.

Returns:

An object representing the interactive layout of the: fit inspection tool. The exact type and behavior depend on the implementation of fit_inspection.

Return type:

AdjointLayout

Note

The fit_inspection function is expected to be defined elsewhere and capable of interpreting the structure of the fitted ARPES data within the _obj Dataset.

class arpes.xarray_extensions.accessor.fit.ARPESFitToolsAccessor(xarray_obj)[source]#

Bases: object

Utilities related to examining curve fits.

modelfit_results or [var]_modelfit_results (When Dataset.S.modelfit is applied.)

property band_names[source]#

Collects the names of the bands from a multiband fit.

Heuristically, a band is defined as a dispersive peak so we look for prefixes corresponding to parameter names which contain “center”.

Returns:

The collected prefix names for the bands.

For instance, if the param name “a_center”, the return value would contain “a_”.

property bands[source]#

Collects bands after a multiband fit.

Returns:: The collected bands.

best_fits()[source]#: Orders the fits into a raveled array by the MSE error.

Todo

Test

mean_square_error()[source]#

Calculates the mean square error of the fit across fit axes.

Producing a scalar metric of the error for all model result instances in the collection.

order_stacked_fits(*, ascending=False)[source]#

Produces an ordered collection of lmfit.ModelResult instances.

For multidimensional broadcasts, the broadcasted dimensions will be stacked for ordering to produce a 1D array of the results.

Parameters:: ascending – Whether the results should be ordered according to ascending mean squared error (best fits first) or descending error (worst fits first).
Returns:: An xr.DataArray instance with stacked axes whose values are the ordered models.

Todo

Test

p(param_name)[source]#

Collects the value of a parameter from curve fitting.

Across an array of fits, walks parameters to collect the value assigned by the fitting routine.

Parameters:

param_name – The parameter name we are trying to collect

Returns:

An xr.DataArray containing the value found by the fitting routine.

The output array is infilled with np.nan if the fit did not converge/ the fit result is None.

Memo:: Work after xarray-lmfit migration.

param_as_dataset(param_name)[source]#

Maps from lmfit.ModelResult to a Dict parameter summary.

Parameters:: param_name – The parameter which should be summarized.
Returns:: “value” and “error” which are the fit value and standard error on the parameter requested.
Return type:: A dataset consisting of two arrays

property parameter_names[source]#

Collects the parameter names for a multidimensional fit.

Assumes that the model used is the same for all lmfit.ModelResult s so that we can merely extract the parameter names from a single non-null result.

Returns:: A set of all the parameter names used in a curve fit.

Todo

Test

Memo:: Work after xarray-lmfit migration.

plot_param(param_name, **kwargs)[source]#

Creates a scatter plot of a parameter from a multidimensional curve fit.

Parameters:

param_name – The name of the parameter which should be plotted
kwargs – Passed to plotting routines to provide user control figsize=, color=, markersize=,

s(param_name)[source]#

Collects the standard deviation of a parameter from fitting.

Across an array of fits, walks parameters to collect the standard error assigned by the fitting routine.

Parameters:

param_name – The parameter name we are trying to collect

Returns:

An xr.DataArray containing the floating point value for the fits.

The output array is infilled with np.nan if the fit did not converge/ the fit result is None.

Memo:: Work after xarray-lmfit migration.

worst_fits()[source]#: Orders the fits into a raveled array by the MSE error.

Todo

Test

Momentum Conversion #

Exact Forward Transforms #

analysis.forward_conversion.convert_coordinates_to_kspace_forward(arr)

Forward converts all the individual coordinates of the data array.

Utilities #

`utilities.conversion.fast_interp.Interpolator`(...)	Provides a Pythonic interface to fast gridded linear interpolation.
`utilities.conversion.bounds_calculations.full_angles_to_k`(...)	Converts from the full set of standard PyARPES angles to momentum.

Conversion Implementations #

You do not need to call these directly, but they are good references for anyone looking to implement a different kind of coordinate transform.

`utilities.conversion.base.CoordinateConverter`(arr)	Infrastructure code to support a new coordinate conversion routine.
`utilities.conversion.kx_ky_conversion.ConvertKp`(...)	A momentum converter for single ARPES (kp) cuts.
`utilities.conversion.kx_ky_conversion.ConvertKxKy`(...)	Implements volumetric momentum conversion for kx-ky scans.
`utilities.conversion.kz_conversion.ConvertKpKz`(...)	Implements single angle photon energy scans.

General Analysis #

Axis Methods #

`analysis.general.rebin`(data[, shape, ...])	Rebins the data onto a different (smaller) shape.
`analysis.general.symmetrize_axis`(data, axis_name)	Symmetrizes data across an axis.
`analysis.general.condense`(data)	Clips the data so that only regions where there is substantial weight are included.
`preparation.axis.normalize_dim`(arr, ...[, ...])	Normalizes the intensity.
`preparation.axis.sort_axis`(data, axis_name)	Sorts slices of data along axis_name so that they lie in order.

Experimental Resolution Modeling #

`analysis.resolution.total_resolution_estimate`(data, *)	Gives the quadrature sum estimate of the resolution of an ARPES spectrum.
`analysis.resolution.thermal_broadening_estimate`(data, *)	Calculates the thermal broadening from the temperature on the data.
`analysis.resolution.beamline_resolution_estimate`(data, *)
`analysis.resolution.analyzer_resolution_estimate`(data, *)	Estimates the energy resolution of the analyzer.

Self-Energy #

`analysis.self_energy.to_self_energy`(...[, ...])	Converts MDC fit results into the self energy.
`analysis.self_energy.fit_for_self_energy`(...)	Fits for the self energy of a dataset containing a single band.
`analysis.self_energy.estimate_bare_band`(...)	Estimates the bare band from a fitted dispersion.
`analysis.self_energy.quasiparticle_lifetime`(...)	Calculates the quasiparticle mean free path in meters (meters!).

Derivatives #

`analysis.derivative.dn_along_axis`(arr[, ...])	Like curvature, performs a second derivative.
`analysis.derivative.curvature`(arr[, dims, alpha])	Provides "curvature" analysis for band locations.
`analysis.derivative.minimum_gradient`(data, *)	Implements the minimum gradient approach to defining the band in a diffuse spectrum.

Smoothing and Filtering #

`analysis.filters.gaussian_filter_arr`(arr[, ...])	Coordinate aware scipy.ndimage.filters.gaussian_filter.
`analysis.filters.boxcar_filter_arr`(arr[, ...])	Coordinate aware scipy.ndimage.uniform_filter.
`analysis.filters.savitzky_golay_filter`(data)	Implements a Savitzky Golay filter with given window size.
`analysis.filters.savgol_filter_multi`(data, ...)	Apply Savitzky-Golay filter to an xarray.DataArray along multiple dimensions.

Deconvolution #

`analysis.deconvolution.deconvolve_ice`(data, psf)	Deconvolves data by a given point spread function (PSF).
`analysis.deconvolution.deconvolve_rl`(data, psf)	Deconvolves data by a given point spread function using the Richardson-Lucy (RL) method.
`analysis.deconvolution.make_psf1d`(data, dim, ...)	Produces a 1-dimensional gaussian point spread function for use in deconvolve_rl.
`analysis.deconvolution.make_psf`(data, sigmas, *)	Produces an n-dimensional gaussian point spread function for use in deconvolve_rl.

Masks #

`analysis.mask.apply_mask`(data, mask[, ...])	Applies a logical mask, i.e. one given in terms of polygons, to a specific piece of data.
`analysis.mask.apply_mask_to_coords`(data, ...)	Performs broadcasted masking along a given dimension.
`analysis.mask.polys_to_mask`(mask_dict, ...)	Converts a mask definition in terms of the underlying polygon to a True/False mask array.
`analysis.mask.raw_poly_to_mask`(poly)	Converts a polygon into a mask definition.

Fermi Surface Pockets #

`analysis.pocket.curves_along_pocket`(data[, ...])	Produces radial slices along a Fermi surface through a pocket.
`analysis.pocket.edcs_along_pocket`(data[, ...])	Collects EDCs around a pocket.
`analysis.pocket.radial_edcs_along_pocket`(...)	Produces EDCs distributed radially along a vector from the pocket center.
`analysis.pocket.pocket_parameters`(data[, ...])	Estimates pocket center, anisotropy, principal vectors, and extent.

Background Removal #

Shirley Backgrounds #

`analysis.shirley.calculate_shirley_background`(xps)	Calculates a shirley background iteratively over the full energy range energy_range.
`analysis.shirley.remove_shirley_background`(...)	Calculates and removes a Shirley background from a spectrum.

Convex Hull Backgrounds #

`analysis.background.calculate_background_hull`(arr)	Calculates background using the convex hull of the data (intensity as a Z axis).
`analysis.background.remove_background_hull`(...)	Removes a background according to calculate_background_hull.

Incoherent Backgrounds #

`correction.background.remove_incoherent_background`(data)	Removes counts above the Fermi level.
`correction.coords.shift_by`(data, coord_name, ...)	Shifts the coordinates by the specified values.

Array Alignment #

Subpixel Correlation Based Alignment #

analysis.align.align(a, b, **kwargs)

Returns the unitful offset of b in a for ndarrays.

Machine Learning #

ML Based Decompositions #

`analysis.decomposition.decomposition_along`(...)	Change the basis of multidimensional data according to sklearn decomposition classes.
`analysis.decomposition.pca_along`(data, axes, ...)	Change the basis of multidimensional data according to sklearn decomposition classes.
`analysis.decomposition.nmf_along`(data, axes, ...)	Change the basis of multidimensional data according to sklearn decomposition classes.
`analysis.decomposition.factor_analysis_along`(...)	Change the basis of multidimensional data according to sklearn decomposition classes.
`analysis.decomposition.ica_along`(data, axes, ...)	Change the basis of multidimensional data according to sklearn decomposition classes.

Deep Learning and PyTorch #

Utilities for interpretation of results akin to those in fast.ai.

`deep_learning.interpret.Interpretation`(...)	Provides utilities to interpret predictions of a model.
`deep_learning.interpret.InterpretationItem`(...)	Provides tools to introspect model performance on a single item.

IO tools.

`deep_learning.io.from_portable_bin`(path)	Reads data from a relatively portable binary format.
`deep_learning.io.to_portable_bin`(arr, path)	Converts data to a relatively portable binary format.

Transform pipelines.

`deep_learning.transforms.Identity`()	Represents a reversible identity transform.
`deep_learning.transforms.ReversibleLambda`(encodes)	A reversible anonymous function, so long as the caller supplies an inverse.
`deep_learning.transforms.ComposeBoth`(transforms)	Like torchvision.transforms.Compose but it operates on data & target in each transform.

Data Generation #

Here are tools for simulating ARPES from theoretical models, including finite statistics, resolution modeling, and detector effects.

`simulation.sample_from_distribution`(distribution)	Samples events from a probability distribution.
`simulation.cloud_to_arr`(point_cloud, shape)	Converts a point cloud (list of xy pairs) to an array representation.
`simulation.SpectralFunctionMFL`([k, omega, ...])	Implements the Marginal Fermi Liquid spectral function, more or less.
`simulation.SpectralFunctionPhaseCoherent`([...])	Implements the "phase coherence" model for the BSSCO spectral function.
`simulation.DetectorEffect`()	Detector effects are callables that map a spectrum into a new transformed one.
`simulation.NonlinearDetectorEffect`([gamma])	Implements power law detector nonlinearities.

Data Loading Plugins #

`endstations.plugin.ALG_main.ALGMainChamber`()	Implements data loading for the Lanzara group "Main Chamber".
`endstations.plugin.ALG_spin_ToF.SpinToFEndstation`()	Implements data loading for the Lanzara group Spin-ToF.
`endstations.plugin.ANTARES.ANTARESEndstation`()	Implements data loading for ANTARES at SOLEIL.
`endstations.plugin.Elettra_spectromicroscopy.SpectromicroscopyElettraEndstation`()	Data loading for the nano-ARPES beamline "Spectromicroscopy Elettra".
`endstations.plugin.example_data.ExampleDataEndstation`()	Loads data from exported .nc format saved by xarray.
`endstations.plugin.fallback.FallbackEndstation`()	Sequentially tries different loading plugins.
`endstations.plugin.HERS.HERSEndstation`()	Implements data loading at the ALS HERS beamline.
`endstations.plugin.igor_export.IgorExportEndstation`()	Implements loading exported HDF files for ARPES data from Igor.
`endstations.plugin.igor_plugin.IgorEndstation`()	A generic file loader for PXT files.
`endstations.plugin.kaindl.KaindlEndstation`()	The Kaindl Tr-ARPES high harmonic generation setup.
`endstations.plugin.MAESTRO.MAESTROMicroARPESEndstation`()	Implements data loading at the microARPES endstation of ALS's MAESTRO.
`endstations.plugin.MAESTRO.MAESTRONanoARPESEndstation`()	Implements data loading at the nanoARPES endstation of ALS's MAESTRO.
`endstations.plugin.MBS.MBSEndstation`()	Implements loading text files from the MB Scientific text file format.
`endstations.plugin.merlin.BL403ARPESEndstation`()	The MERLIN ARPES Endstation at the Advanced Light Source.
`endstations.plugin.SToF_DLD.SToFDLDEndstation`()	Provides data loading for the Lanzara group experimental ARToF.
`endstations.plugin.SPD_main.SPDEndstation`()	Class for PHOIBOS 100 controlled by using prodigy.
`endstations.plugin.DSNP_UMCS.DSNP_UMCSEndstation`()	Implements loading xy text files from the Specs Prodigy software.

Curve Fitting #

General Curve Fitting Utilities #

fits.utilities.result_to_hints(model_result)

Turns an lmfit.model.ModelResult into a dictionary with initial guesses.

Models #

Utilities related to curve-fitting of ARPES data and xarray format data.

`fit_models.fermi_edge`	Definitions of models involving Fermi edges.
`fit_models.dirac`	Definitions of models involving Dirac points, graphene, graphite.
`fit_models.bands`	Definitions of band shape.
`fit_models.functional_forms`	Common implementations of peaks, backgrounds for other models.
`fit_models.misc`	Some miscellaneous model definitions.
`fit_models.two_dimensional`	Curve fitting models with two independent variables.

Plotting #

Interactive Utilities: holoviews Based #

Public plotting API with lazy imports to avoid circular dependencies.

`ui.concat_along_phi_ui`(dataarray_a, ...)	Creates an interactive UI to visualize concatenation along the phi axis.
`ui.profile_view`(data, *[, use_quadmesh, ...])	Generates an interactive 2D profile view with cross-sectional analysis.
`ui.fit_inspection`(dataset[, spectral_name, ...])	Displays interactive visualization of fitted ARPES data with residuals.
`ui.smoothing.SmoothingApp`(data, **kwargs)	An interactive smoothing UI for xarray DataArray using Panel and HoloViews.
`ui.smoothing.DifferentiateApp`(data, **kwargs)	An interactive differentiation UI for xarray DataArray using Panel and HoloViews.

General Utilities/Matplotlib Quality of Life #

An incomplete list of useful plotting utilities from arpes.utilities.plotting.

`utils.path_for_plot`(desired_path)	Provides workspace and date scoped path generation for plots.
`utils.savefig`(desired_path[, dpi, data, ...])	The PyARPES preferred figure saving routine.
`utils.simple_ax_grid`(n_axes[, figsize])	Generates a square-ish set of axes and hides the extra ones.
`utils.invisible_axes`(ax)	Make a Axes instance completely invisible.
`utils.remove_colorbars`([fig])	Removes colorbars from given (or current) matplotlib figure.
`utils.frame_with`(ax[, color, linewidth])	Makes thick, visually striking borders on a matplotlib plot.
`utils.unchanged_limits`(ax)	Context manager that retains axis limits.
`utils.plot_arr`(arr[, ax, over, mask])	Convenience method to plot an array with a mask over some other data.
`utils.imshow_mask`(mask[, ax, over])	Plots a mask by using a fixed color and transparency.
`utils.latex_escape`(text, *[, force])	Conditionally escapes a string based on the matplotlib settings.
`utils.fancy_labels`(ax_or_ax_set[, data])	Attaches better display axis labels for all axes.
`utils.summarize`(data[, axes])	Makes a summary plot with different marginal plots represented.

Interactive Utilities: Matplotlib Based #

Stack Plots #

`stack_plot.stack_dispersion_plot`(data, *[, ...])	Generates a stack plot with all the lines distinguished by offset (and color).
`stack_plot.flat_stack_plot`(data, *[, ...])	Generates a stack plot with all the lines distinguished by color rather than offset.
`stack_plot.offset_scatter_plot`(data[, ...])	Makes a stack plot (scatters version).

Spin-ARPES Plots #

`spin.spin_polarized_spectrum`(spin_dr[, ...])	Plots a simple spin polarized spectrum using curves for the up and down components.
`spin.spin_colored_spectrum`(spin_dr[, title, ...])	Plots a spin spectrum using total intensity.
`spin.spin_difference_spectrum`(spin_dr[, ...])	Plots a spin difference spectrum.

Count-based and ToF Plots #

`tof.plot_with_std`(data_set[, name_to_plot, ...])	Makes a fill-between line plot with error bars from associated statistical errors.
`tof.scatter_with_std`(data[, name_to_plot, ...])	Makes a scatter plot of data with error bars generated from associated statistical errors.

Reference Plots #

`spatial.plot_spatial_reference`(...[, ...])	Helpfully plots data against a reference scanning dataset.
`spatial.reference_scan_spatial`(data[, out])	Plots the spatial content of a dataset, useful as a quick reference.

Curve Fitting Plots #

`fits.plot_fit`(model_result[, ax])	Performs a straightforward plot of the data, residual, and fit to an axis.
`fits.plot_fits`(model_results[, axs])	Plots several fits onto a grid of axes.
`parameter.plot_parameter`(fit_data, param_name)	Creates a scatter plot of a parameter from a broadcast_fit result.

False Color Plots #

false_color.false_color_plot(data_rgb[, ax, ...])

Plots a spectrum in false color after conversion to R, G, B arrays.

Plotting with Brillouin Zones #

`bz.plot_data_to_bz`(data, cell, **kwargs)	A dimension agnostic tool used to plot ARPES data onto a Brillouin zone.
`bz.overplot_standard`(cell[, repeat, transforms])	A higher order function to plot a Brillouin zone over a plot.
`bz.plot_plane_to_bz`(cell, plane, ax[, facecolor])	Plots a 2D cut plane onto a Brillouin zone.

Plot Annotations #

`annotations.annotate_cuts`(ax, data, ...[, ...])	Annotates a cut location onto a plot.
`annotations.annotate_point`(ax, location[, delta])	Annotates a point or high symmetry location into a plot.
`annotations.annotate_experimental_conditions`(ax, ...)	Renders information about the experimental conditions onto a set of axes.

`utilities.conversion.api.convert_to_kspace`(arr, *)	Converts volumetric the data to momentum space ("backwards").
`analysis.forward_conversion.convert_coordinate_forward`(...)	Inverse/forward transform for the small angle volumetric k-conversion code.
`analysis.forward_conversion.convert_through_angular_point`(...)	Converts the lower dimensional ARPES cut passing through given angular coords.
`analysis.forward_conversion.convert_through_angular_pair`(...)	Converts the lower dimensional ARPES cut passing through first_point and second_point.

`analysis.tarpes.find_t_for_max_intensity`(data)	Finds the time corresponding to the maximum (integrated) intensity.
`analysis.tarpes.relative_change`(data[, t0, ...])	Calculate relative Tr-ARPES change in a delay scan.
`analysis.tarpes.build_crosscorrelation`(datalist)	Constructs a multidimensional data array from cross-correlation measurements.
`analysis.tarpes.delaytime_fs`(mirror_movement)	Return delaytime from the mirror movement (not position).
`analysis.tarpes.position_mm_to_delaytime_fs`(...)	Return delay time from the mirror position.

`analysis.sarpes.to_intensity_polarization`(data, *)	Converts from [up, down] representation to [intensity, polarization] representation.
`analysis.sarpes.to_up_down`(data)	Converts from [intensity, polarization] representation to [up, down] representation.
`analysis.sarpes.normalize_sarpes_photocurrent`(data)	Normalizes the down channel so that it matches the up channel in terms of mean photocurrent.

`analysis.gap.symmetrize`(data, *[, subpixel])	Symmetrizes data across the chemical potential.
`analysis.gap.determine_broadened_fermi_distribution`(data, *)	Determine the parameters for broadening by temperature and instrumental resolution.

This Page