introduction.rst

Introduction

What is LumiSpy

LumiSpy is an open-source python library aimed at helping with the analysis of luminescence spectroscopy data. The development started mainly with photoluminescence (PL), cathodoluminescence (CL), electroluminescence (EL) and Raman spectroscopy in mind. Besides the standard continuous-excitation spectral data, the idea is to provide tools also for the analysis of time-resolved (transient) measurements. However, LumiSpy may prove useful also for other optical measurements, such as absorption or transmission spectroscopy, scanning optical near field miscroscopy (SNOM), as well as fourier-transform infrared spectroscopy (FTIR).

LumiSpy is an extension to the python package HyperSpy_ that facilitates hyperspectral data analysis, i.e. maps or linescans where a spectrum is collected at each pixel. Or more general, multidimensional datasets that can be described as multidimensional arrays of a given signal, as illustrated by the following figure:

To facilitate working with these datasets, HyperSpy distinguishes between :external+hyperspynavigation and signal dimensions <navigation-signal-dimensions> that can be addressed separately and thus, for example, operations on a single spectrum can be easily mapped to a whole dataset.

Notable features that HyperSpy provides are:

• :external+hyperspybase signal classes <signal-label> for the handling of (multidimensional) spectral data,
• the necessary tools for :external+hyperspyloading <io> :external+rsciiovarious data file formats <supported-formats> using the library RosettaSciIO,
• :external+hyperspyanalytical tools <signal1D-label> that exploit the multidimensionality of datasets,
• a user-friendly and powerful framework for :external+hyperspymodel fitting <model-label> that provides many :external+hyperspystandard functions <model_components-label> and can be easily extended to :external+hyperspycustom ones <expression_component-label>,
• :external+hyperspymachine learning <ml-label> algorithms that can be useful, e.g. for denoising data,
• efficient handling of :external+hyperspybig datasets <big-data-label>,
• functions for :external+hyperspydata visualization <visualization-label> both to evaluate datasets during the analysis and provide interactive operation for certain functions, as well as for plotting of data,
• extracting subsets of data from multidimensional datasets via :external+hyperspyregions of interest <roi-label> and a powerful numpy-style :external+hyperspyindexing mechanism <signal.indexing>,
• handling of :external+hyperspynon-uniform data axes <Axes_types> (introduced in the :external+hyperspy1.7.0 release <changes_1.7.0>).

LumiSpy provides in particular:

• additional signal_types specifically for luminescence spectra and transients,
• transformation to non-uniform signal axes <signal_axis> for use of other common units, such as eV (electron volt) and wavenumbers (Raman shift),
• additional signal tools <signal_tools> such as data normalization and scaling,
• various utility functions <utilities> useful in luminescence spectroscopy data analysis, such as joining multiple spectra along the signal axis, unit conversion, etc.

LumiSpy should facilitate an easy and reproducible analysis of single spectra or spectral images.

Signal types

As an extension to HyperSpy, LumiSpy provides several signal types extending the :external+hyperspybase classes available in HyperSpy <signal_subclasses_table-label>. When the LumiSpy library is installed, these additional signal types are directly available to HyperSpy. To print all available specialised :externalhyperspy.signal.BaseSignal subclasses installed in your system call the :externalhyperspy.api.print_known_signal_types function:

>>> import hyperspy.api as hs
>>> hs.print_known_signal_types()

The different subclasses are characterized by the signal_type metadata attribute. Some additional properties are summarized in the table below. Depending on the use case, certain functions will only be available for some signal types (or inheriting) signal types.

LumiSpy subclasses and their basic attributes.

BaseSignal subclass	signal_dimension	signal_type	dtype	aliases
:class:~.signals.luminescence_spectrum.LumiSpectrum	1	Luminescence	real	LumiSpectrum, LuminescenceSpectrum
~.signals.cl_spectrum.CLSpectrum	1	CL	real	CLSpectrum, cathodoluminescence
~.signals.cl_spectrum.CLSEMSpectrum	1	CL_SEM	real	CLSEM, cathodoluminescence SEM
~.signals.cl_spectrum.CLSTEMSpectrum	1	CL_STEM	real	CLSTEM, cathodoluminescence STEM
~.signals.el_spectrum.ELSpectrum	1	EL	real	ELSpectrum, electroluminescence
~.signals.pl_spectrum.PLSpectrum	1	PL	real	PLSpectrum, photoluminescence
~.signals.luminescence_transient.LumiTransient	1	Transient	real	TRLumi, TR luminescence, time-resolved luminescence
~.signals.luminescence_transientspec.LumiTransientSpectrum	2	TransientSpec	real	TRLumiSpec, TR luminescence spectrum, time-resolved luminescence spectrum

The hierarchy of the LumiSpy signal types and their inheritance from HyperSpy is summarized in the following diagram:

  └── :externalhyperspy.signal.BaseSignal
          ├── :externalhyperspy._signals.signal1d.Signal1D
          │ └── ~.signals.luminescence_spectrum.LumiSpectrum
          │ │ ├── ~.signals.cl_spectrum.CLSpectrum
          │ │ │ ├── ~.signals.cl_spectrum.CLSEMSpectrum
          │ │ │ └── ~.signals.cl_spectrum.CLSTEMSpectrum
          │ │ ├── ~.signals.el_spectrum.ELSpectsrum
          │ │ └── ~.signals.pl_spectrum.PLSpectrum
          │ └── ~.signals.luminescence_transient.LumiTransient
          └── hyperspy.signal.Signal2D
                  └── ~.signals.luminescence_transientspec.LumiTransientSpectrum

Where are we heading?

LumiSpy is under active development, and as a user-driven project, we welcome contributions <contributing_label> to the code and documentation, but also bug reports and feature requests from any user. Don't hesitate to join the discussions!

Currrently, we have implemented the base functionality that extends :external+hyperspyHyperSpy's capabilities <user_guide> to additional signal classes. In the near future, the following functions should be developed:

• handling of transient (time-resolved) data with dedicated models,
• extend the capabilities for reading relevant data formats (see :external+rsciiosupported-formats of RosettaSciIO),
• more dedicated analysis functionalities,
• ...