# Source code for ixdat.plotters.spectrum_plotter

```
"""Plotters for spectra and spectrumseries."""
import numpy as np
import matplotlib as mpl
from matplotlib import pyplot as plt
from . import MPLPlotter, add_colorbar
from .plotting_tools import get_indeces_and_times
[docs]class SpectrumPlotter(MPLPlotter):
"""A plotter for a spectrum"""
def __init__(self, spectrum=None):
super().__init__()
self.spectrum = spectrum
[docs] def plot(self, *, spectrum=None, ax=None, **kwargs):
"""Plot a spectrum as y (signal) vs x (scanning variable)
Args:
spectrum (Spectrum): The spectrum to plot if different from self.spectrum
ax (mpl.Axis): The axis to plot on. A new one is made by default.
kwargs: additional key-word arguments are given to ax.plot()
"""
spectrum = spectrum or self.spectrum
if not ax:
ax = self.new_ax()
ax.plot(spectrum.x, spectrum.y, **kwargs)
ax.set_xlabel(spectrum.x_name)
ax.set_ylabel(spectrum.y_name)
return ax
[docs]class SpectrumSeriesPlotter(MPLPlotter):
"""A plotter for spectrum series, f.ex. spectra taken continuously over time"""
def __init__(self, spectrum_series=None):
super().__init__()
self.spectrum_series = spectrum_series
@property
def plot(self):
"""The default plot of a SpectrumSeries is heat_plot"""
return self.heat_plot
[docs] def plot_average(self, *, spectrum_series=None, ax=None, **kwargs):
"""Take an average of the spectra and plot that."""
spectrum_series = spectrum_series or self.spectrum_series
if not ax:
ax = self.new_ax()
ax.plot(spectrum_series.x, spectrum_series.y_average, **kwargs)
ax.set_xlabel(spectrum_series.x_name)
ax.set_ylabel(spectrum_series.y_name + " (average)")
return ax
[docs] def heat_plot(
self,
*,
spectrum_series=None,
field=None,
tspan=None,
xspan=None,
ax=None,
cmap_name="inferno",
make_colorbar=False,
t=None,
t_name=None,
max_threshold=None,
min_threshold=None,
scanning_mask=None,
vmin=None,
vmax=None,
continuous=None,
):
"""
Plot a spectrum series with `t` on the horizontal axis, `x` on the vertical axis,
and color representing `y`.
Args:
spectrum_series (SpectrumSeries): The spectrum series to be plotted, if
different from self.spectrum_series.
field (Field): The field to be plotted, if different from
spectrum_series.field
tspan (iterable): The span of the time data to plot
xspan (iterable): The span of the spectral data to plot
ax (mpl.Axis): The axes to plot on. A new one is made by default
cmap_name (str): The name of the colormap to use. Defaults to "inferno", see
https://matplotlib.org/3.5.0/tutorials/colors/colormaps.html#sequential
make_colorbar (bool): Whether to make a colorbar.
FIXME: colorbar at present mis-alignes axes
t (numpy array): Time data to use if not the data in spectrum_series
t_name (str): Name of time variable if not the one in spectrum_series
max_threshold (float): Maximum value to display.
Values above are set to zero.
min_threshold (float): Minimum value to display.
Values below are set to 0.
scanning_mask (list): List of booleans to exclude from scanning variable
before plotting data by setting y values to 0 (zero).
vmin (float): minimum value to represent in colours.
vmax (float): maximum value to represent in colours.
continuous (bool): Optional. Whether to make a continuous heat plot (True) or
a discrete heat plot for each spectrum (False). In the discrete case,
each heat plot is a rectangle with the spectrum's duration as its width,
if available. If the duration is not available, each spectrum heat plot
extends to the start of the next one.
Defaults to the `spectrum_series.continuous`.
"""
spectrum_series = spectrum_series or self.spectrum_series
field = field or spectrum_series.field
if continuous is None:
continuous = spectrum_series.continuous
xseries = field.axes_series[1]
x = xseries.data
t = t if t is not None else field.axes_series[0].t
t_name = t_name or field.axes_series[0].name
data = field.data
if max_threshold:
# data = np.minimum(max_threshold, data)
data[data > max_threshold] = 0
if min_threshold:
data[data < min_threshold] = 0
if np.any(scanning_mask):
data[:, scanning_mask] = 0
if tspan:
t_mask = np.logical_and(tspan[0] < t, t < tspan[-1])
t = t[t_mask]
data = data[t_mask, :]
if (t[0] < t[-1]) != (tspan[0] < tspan[-1]): # this is an XOR.
# Then we need to plot the data against U in the reverse direction:
t = np.flip(t, axis=0)
data = np.flip(data, axis=0)
if xspan:
x_mask = np.logical_and(xspan[0] < x, x < xspan[-1])
x = x[x_mask]
data = data[:, x_mask]
if not ax:
ax = self.new_ax()
if continuous:
ax.imshow(
np.flip(data.swapaxes(0, 1), axis=0),
cmap=cmap_name,
aspect="auto",
extent=(t[0], t[-1], x[0], x[-1]),
vmin=vmin,
vmax=vmax,
)
else:
for i, t_i in enumerate(spectrum_series.t):
if tspan and (t_i < min(tspan) or t_i > max(tspan)):
continue
try:
duration = spectrum_series.durations[i]
# ^ raises TypeError if durations is None.
t_f = t_i + duration # raises TypeError if durations[i] is None.
except TypeError:
if i < len(t) - 1:
t_f = t[i + 1]
else:
# If its duration is unknown, we don't plot the last spectrum.
break
y = data[i]
yy = np.stack([y, y])
ax.imshow(
np.flip(yy.swapaxes(0, 1), axis=0),
cmap=cmap_name,
aspect="auto",
extent=(t_i, t_f, x[0], x[-1]),
vmin=vmin,
vmax=vmax,
)
ax.set_xlabel(t_name)
ax.set_ylabel(xseries.name)
if make_colorbar:
add_colorbar(
ax,
cmap_name,
vmin=(vmin if vmin else np.min(data)),
vmax=(vmax if vmax else np.max(data)),
)
return ax
[docs] def plot_waterfall(
self,
*,
spectrum_series=None,
field=None,
ax=None,
cmap_name="jet",
make_colorbar=True,
t=None,
t_name=None,
):
"""Plot a SpectrumSeries as spectra colored by the time at which they are taken
This is commonly used for e.g. in-situ UV-Vis spectrometry
Args:
spectrum_series (SpectrumSeries): The spectrum series to be plotted, if
different from self.spectrum_series.
field (Field): The field to be plotted, if different from
spectrum_series.field
ax (matplotlib Axis): The axes to plot on. A new one is made by default.
cmap_name (str): The name of the colormap to use. Defaults to "inferno", see
https://matplotlib.org/3.5.0/tutorials/colors/colormaps.html#sequential
make_colorbar (bool): Whether to make a colorbar.
t (numpy array): Time data to use if not the data in spectrum_series
t_name (str): Name of time variable if not the one in spectrum_series
"""
spectrum_series = spectrum_series or self.spectrum_series
field = field or spectrum_series.field
data = field.data
x = field.axes_series[1].data
t = t if t is not None else field.axes_series[0].t
t_name = t_name or field.axes_series[0].name
cmap = mpl.cm.get_cmap(cmap_name)
norm = mpl.colors.Normalize(vmin=np.min(t), vmax=np.max(t))
if not ax:
ax = self.new_ax()
for i, t_i in enumerate(t):
spec = data[i]
color = cmap(norm(t_i))
ax.plot(x, spec, color=color)
ax.set_xlabel(field.axes_series[1].name)
ax.set_ylabel(field.name)
if make_colorbar:
cb = plt.colorbar(mpl.cm.ScalarMappable(norm=norm, cmap=cmap), ax=ax)
cb.set_label(t_name)
return ax
[docs] def plot_stacked_spectra(
self,
spectrum_series=None,
dt=None,
t_list=None,
dn=None,
index_list=None,
average=False,
xspan=None,
xspan_bg=None,
scale_mode="auto",
scale_factor=1,
y_values="time",
ax=None,
color="k",
**kwargs,
):
"""Plot a selection of spectra, stacked
This is commonly used for e.g. FTIR.
Specify which spectra to plot by one of four ways: dt, t_list,
dn, or n_list. See descriptions below.
Args:
spectrum_series (SpectrumSeries): What to plot from, if
different from self.spectrum_series
dt (float): time interval between spectra to plot, [s]. The
first spectrum and those taken at times closest to each
integer multiple of dt after are plotted.
t_list (list of float): List of times for which to plot the
spectrum, [s]. The closest spectrum to each time in the
list is plotted.
dn (int): number of spectra between plotted spectra
index_list (list of int): List of indeces of spectra to plot
average (bool or int): Whether and how to average spectra for
plotting. False means no averaging. True means average all
the spectra in the interval between spectra. An integer
`n` means average the `n/2` spectra before and `n/2` spectra
after the spectra at the given time or index
xspan (list of float): Range of x-axis variable to include.
xspan_bg (list of float): Range of x-axis variable for which to
consider the signal at background. For each spectrum, the
average y value in this range is subtracted.
scale_mode (str): The way to initially scale the spectra.
Options:
- "auto": scale uniformly such that all spectra fit in
their given interval. The raw y-values are scaled by
min(interval) / max(y range)
- [no other scale_mode options yet]
scale_factor: A factor to apply on top of the initial scaling
y_values (str): What to plot on the y-axis. Options: "time", "n"
ax (Axis): axis to plot on, if not a new axis
color (str): color of traces. Defaults to black.
**kwargs: Additional key-word args are passed on to ax.plot()
"""
spectrum_series = spectrum_series or self.spectrum_series
# whichever of the four were specified, we need t_list and index_list:
t_vec = spectrum_series.t
index_list, t_list = get_indeces_and_times(
t_vec, dt=dt, t_list=t_list, dn=dn, index_list=index_list
)
# Now we get the y-values of the spectra to plot
y_vec_list = []
for i, index in enumerate(index_list):
if average:
# The challenge with averaging is figuring out the range of ideces over
# which to average.
if type(average) is int:
range_start = max(0, index - average)
range_end = min(index + average, len(t_vec))
else:
# If average is set to "True", we need to figure out the median
# points between the spectra, as follows.
if i == 0:
range_start = index
else:
range_start = int((index + index_list[i - 1]) / 2)
if i + 1 == len(index_list):
range_end = index
else:
range_end = int((index + index_list[i + 1]) / 2)
# Once we have the range of indeces, the SpectrumSeries makes it easy:
y_vec = spectrum_series[range_start:range_end].y_average
else:
# The simple case where we're not averaging.
y_vec = spectrum_series[index].y
y_vec_list.append(y_vec)
# Establish the axis
if not ax:
ax = self.new_ax()
ax.set_xlabel(spectrum_series.xseries.name)
# Whatever y's we are plotting, the x is the same:
x = spectrum_series.x
# If an xspan_bg is given, zero the corresponding part of each y vector:
if xspan_bg:
mask_bg = np.logical_and(xspan_bg[0] < x, x < xspan_bg[-1])
for i, y_vec in enumerate(y_vec_list):
y_vec_list[i] = y_vec_list[i] - np.mean(y_vec_list[i][mask_bg])
# If an xspan (for plotting) is given, cut all the vectors accordingly:
if xspan:
mask = np.logical_and(xspan[0] < x, x < xspan[-1])
x = x[mask]
for i, y_vec in enumerate(y_vec_list):
y_vec_list[i] = y_vec[mask]
# a list of y ranges is useful in all cases for figuring out how to scale the
# y-vectors onto the y axis, which a bit confusingly represents something else.
y_ranges = np.max(y_vec_list, axis=1) - np.min(y_vec_list, axis=1)
# No matter what, we loop through the y-vectors to plot, but the code is a bit
# different depending on what the y-axis represents, so consider those two cases
# ("time" and "n", which means index) seperately.
if y_values == "time":
ax.set_ylabel(spectrum_series.t_name)
if scale_mode == "auto":
# time intervals:
dts = [t_list[i + 1] - t_list[i] for i in range(len(t_list) - 1)]
# The scale is determined by the minimum time interval divided by
# the maximum y range, so that by default (scale_factor=1) all spectra
# fit completely in thier own time interval
t_per_y = min(dts) / max(y_ranges) * scale_factor
scaled_y_vec_list = [y_vec * t_per_y for y_vec in y_vec_list]
else:
raise ValueError(f"scale_mode={scale_mode} not implemented.")
for t, scaled_y_vec in zip(t_list, scaled_y_vec_list):
ax.plot(x, t + scaled_y_vec, label=t, color=color, **kwargs)
elif y_values == "n":
ax.set_ylabel("spectrum number")
if scale_mode == "auto":
# index intervals:
dns = [
index_list[i + 1] - index_list[i] for i in range(len(index_list) - 1)
]
# The scale is determined by the minimum index interval divided by
# the maximum y range, so that by default (scale_factor=1) all spectra
# fit completely in thier own index interval
t_per_n = min(dns) / max(y_ranges) * scale_factor
scaled_y_vec_list = [y_vec * t_per_n for y_vec in y_vec_list]
else:
raise ValueError(f"scale_mode='{scale_mode}' not implemented.")
for n, scaled_y_vec in zip(index_list, scaled_y_vec_list):
ax.plot(x, n + scaled_y_vec, label=n, color=color, **kwargs)
else:
raise ValueError(f"y_values='{y_values}' not implemented.")
# Make the spectra go all the way to the plot edges, with ticks on both sides:
ax.set_xlim(min(x), max(x))
ax.tick_params(axis="y", right=True)
return ax
[docs]class SpectroMeasurementPlotter(MPLPlotter):
"""Plotter for measurements with spectrum_series
This makes use of the methods in `SpectrumSeriesPlotter`, but allows a second
scanned variable (such as `potential` in the case of spectroelectrochemistry) to be
used from the measurement instead of time data.
"""
def __init__(self, measurement=None):
super().__init__()
self.measurement = measurement
self.spectrum_series_plotter = SpectrumSeriesPlotter()
[docs] def heat_plot_vs(
self,
*,
measurement=None,
field=None,
vs=None,
vspan=None,
xspan=None,
ax=None,
cmap_name="inferno",
make_colorbar=False,
):
"""Plot a SpectroMeasurement in two panels with time as x-asis.
The top panel is a heat plot with wavelength on y-axis and color representing
spectrum. At most one of V_ref and t_ref should be given, and if neither are
given the measurement's default reference_spectrum is used to calculate the
optical density.
Args:
measurement (SpectrumSeries): The spectrum series to be plotted, if
different from self.spectrum_series.
field (Field): The field to be plotted, if different from
spectrum_series.field
vs (str): The name of the value series or time series to plot against.
vspan (iterable): The span of the value series or time series to include
xspan (iterable): The span of the spectral data to plot
ax (mpl.Axis): The axes to plot on. A new one is made by default
cmap_name (str): The name of the colormap to use. Defaults to "inferno", see
https://matplotlib.org/3.5.0/tutorials/colors/colormaps.html#sequential
make_colorbar (bool): Whether to make a colorbar.
FIXME: colorbar at present mis-alignes axes
"""
measurement = measurement or self.measurement
tseries = field.axes_series[0]
v_name = vs
if vs in ("t", tseries.tseries.name):
v = tseries.t
if hasattr(measurement, "t_str") and measurement.t_str:
v_name = measurement.t_str
else:
v = measurement.grab_for_t(vs, t=tseries.t)
return self.spectrum_series_plotter.heat_plot(
spectrum_series=measurement.spectrum_series,
field=field,
tspan=vspan,
xspan=xspan,
ax=ax,
cmap_name=cmap_name,
make_colorbar=make_colorbar,
t=v,
t_name=v_name,
)
[docs] def plot_waterfall_vs(
self,
*,
measurement=None,
field=None,
vs=None,
ax=None,
cmap_name="jet",
make_colorbar=True,
):
"""Plot a SpectrumSeries as spectra colored by the value at which they are taken
Args:
measurement (SpectroMeasurement): The measurement to be plotted if different
from self.measurement.
field (Field): The field to be plotted, if different from
spectrum_series.field
vs (str): The name of the value to use for the color scale. Defaults to time
ax (matplotlib Axis): The axes to plot on. A new one is made by default.
cmap_name (str): The name of the colormap to use. Defaults to "inferno", see
https://matplotlib.org/3.5.0/tutorials/colors/colormaps.html#sequential
make_colorbar (bool): Whether to make a colorbar.
"""
measurement = measurement or self.measurement
tseries = field.axes_series[0]
v_name = vs
if vs in ("t", tseries.tseries.name):
v = tseries.t
if hasattr(measurement, "t_str") and measurement.t_str:
v_name = measurement.t_str
else:
v = measurement.grab_for_t(vs, t=tseries.t)
return self.spectrum_series_plotter.plot_waterfall(
spectrum_series=measurement.spectrum_series,
field=field,
ax=ax,
cmap_name=cmap_name,
make_colorbar=make_colorbar,
t=v,
t_name=v_name,
)
[docs] def plot_stacked_spectra_vs(
self,
*,
measurement=None,
vs=None,
dt=None,
t_list=None,
dn=None,
index_list=None,
average=False,
xspan=None,
xspan_bg=None,
scale_mode="auto",
scale_factor=1,
y_values="time",
ax=None,
color="k",
**kwargs,
):
"""Plot stacked spectra with a time-dependent value on the y-axis
This is commonly used for e.g. FTIR.
Specify which spectra to plot by one of four ways: dt, t_list,
dn, or n_list. See descriptions below.
Args:
measurement (SpectroMeasurement): The spectromeasurement to
plot data form, if different from self.measurement
vs (str): The name of the value series to stack spectra
according to.
dt (float): time interval between spectra to plot, [s]. The
first spectrum and those taken at times closest to each
integer multiple of dt after are plotted.
t_list (list of float): List of times for which to plot the
spectrum, [s]. The closest spectrum to each time in the
list is plotted.
dn (int): number of spectra between plotted spectra
index_list (list of int): List of indeces of spectra to plot
average (bool or int): Whether and how to average spectra for
plotting. False means no averaging. True means average all
the spectra in the interval between spectra. An integer
`n` means average the `n/2` spectra before and `n/2` spectra
after the spectra at the given time or index
xspan (list of float): Range of x-axis variable to include.
xspan_bg (list of float): Range of x-axis variable for which to
consider the signal at background. For each spectrum, the
average y value in this range is subtracted.
scale_mode (str): The way to initially scale the spectra.
Options:
- "auto": scale uniformly such that all spectra fit in
their given interval. The raw y-values are scaled by
min(interval) / max(y range)
- [no other scale_mode options yet]
scale_factor: A factor to apply on top of the initial scaling
y_values (str): What to plot on the y-axis. Options: "time", "n"
ax (Axis): axis to plot on, if not a new axis
color (str): color of traces. Defaults to black.
**kwargs: Additional key-word args are passed on to ax.plot()
"""
measurement = measurement or self.measurement
t_vec = measurement.spectrum_series.t
ax = self.spectrum_series_plotter.plot_stacked_spectra(
spectrum_series=measurement.spectrum_series,
dt=dt,
t_list=t_list,
dn=dn,
index_list=index_list,
average=average,
xspan=xspan,
xspan_bg=xspan_bg,
scale_mode=scale_mode,
scale_factor=scale_factor,
y_values=y_values,
ax=ax,
color=color,
)
index_list, t_list = get_indeces_and_times(t_vec, dt, t_list, dn, index_list)
v_list = measurement.grab_for_t(vs, np.array(t_list))
ax.set_yticks(t_list)
ax.set_yticklabels([np.round(v, 2) for v in v_list])
ax.set_ylabel(vs)
```