lineshape_tools 0.1.0__py3-none-any.whl

lineshape_tools/constants.py

@@ -0,0 +1,4 @@
+"""Constants shared by various portions of the code."""
+
+omega2eV = 0.06465415134095606
+kelvin2eV = 8.617333262145179e-05

lineshape_tools/lineshape.py

@@ -0,0 +1,279 @@
+"""Implements functionality to evaluate optical lineshapes."""
+
+from __future__ import annotations
+
+import logging
+from typing import NamedTuple
+
+import numpy as np
+from numba import njit
+
+from lineshape_tools.constants import kelvin2eV, omega2eV
+
+logger = logging.getLogger(__name__)
+
+
+def get_Stot(dq: np.ndarray, omega: np.ndarray) -> float:
+    """Calculate the Huang-Rhys factor Stot.
+
+    Args:
+        dq (np.ndarray): mass-weighted displacement vector in normal mode basis in (amu^{1/2} Ang).
+        omega (np.ndarray): normal mode phonon frequencies (in eV/amu/Ang^2).
+    """
+    return np.sum(0.5 * omega * dq**2 / omega2eV)
+
+
+@njit(cache=True, fastmath=True, error_model="numpy")
+def gaussian(x: np.ndarray, s: float) -> np.ndarray:
+    """Evaluate the Gaussian function with smearing s."""
+    return np.exp(-(x**2) / 2 / s**2) / np.sqrt(2 * np.pi) / s
+
+
+@njit(cache=True, fastmath=True, error_model="numpy")
+def lorentzian(x: np.ndarray, g: float) -> np.ndarray:
+    """Evaluate the Lorentzian function with broadening g."""
+    return g / np.pi / (x**2 + g**2)
+
+
+class Broadening(NamedTuple):
+    gamma_zpl: float
+    sigma_zpl: float
+    method_psb: np.ndarray
+    value_psb: np.ndarray
+
+    @classmethod
+    def create(
+        cls,
+        omega: np.ndarray,
+        gamma_zpl: float = 0.001,
+        sigma_zpl: float = 0.0,
+        sigma_psb: tuple[float, float] = (0.005, 0.001),
+        gamma_lvm: float = 0.001,
+        ipr_cut: float = 10.0,
+        ipr: np.ndarray | None = None,
+    ) -> Broadening:
+        """Create an instance of Broadening.
+
+        Args:
+            omega (np.ndarray): normal mode phonon frequencies (in eV/amu/Ang^2).
+            gamma_zpl (float): Lorentzian broadening in the ZPL to capture homogeneous broadening.
+            sigma_zpl (float): Gaussian broadening in the ZPL to capture inhomogeneous broadening.
+            sigma_psb (float, float): Gaussian broadening used to broaden the partial Huang-Rhys
+                factors. The broadening factor is linearly interpolated from sigma_psb[0] at zero
+                frequency to sigma_psb[1] at the highest (non-LVM) frequency.
+            gamma_lvm (float): Lorentzian broadening applied to local vibrational modes identified
+                by their inverse participation ratio.
+            ipr_cut (float): Local vibrational modes are identified when their ipr < ipr_cut.
+            ipr (np.ndarray): array of inverse participation ratios for each mode.
+        """
+        w_k = omega2eV * omega
+
+        method_psb = np.zeros(omega.shape[0], dtype=np.uint8)
+
+        if ipr is not None:
+            mask = ipr < ipr_cut
+            w_max = w_k[~mask].max()
+        else:
+            mask = None
+            w_max = w_k.max()
+
+        x = w_k / w_max
+        value_psb = sigma_psb[0] * (1 - x) + sigma_psb[1] * x
+
+        if ipr is not None:
+            method_psb[mask] = 1
+            value_psb[mask] = gamma_lvm
+
+        return cls(
+            gamma_zpl=gamma_zpl, sigma_zpl=sigma_zpl, method_psb=method_psb, value_psb=value_psb
+        )
+
+
+@njit(cache=True, fastmath=True, error_model="numpy")
+def _do_compute_phonon_spec_func_zeroT(
+    w: np.ndarray,
+    dq: np.ndarray,
+    omega: np.ndarray,
+    broadening: Broadening,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Compute the phonon spectral function and related quantities at zero T."""
+    dw = w[1] - w[0]
+
+    w_k = omega2eV * omega
+    S_k = 0.5 * omega * dq**2 / omega2eV
+
+    S_w, dos = np.zeros_like(w), np.zeros_like(w)
+    for i in range(S_k.shape[0]):
+        broad_f = lorentzian if broadening.method_psb[i] == 1 else gaussian
+        S_w += S_k[i] * broad_f(w - w_k[i], broadening.value_psb[i])
+        dos += broad_f(w - w_k[i], broadening.value_psb[i])
+    dos /= S_k.shape[0]
+
+    S_0 = S_w.sum() * dw
+    if not np.isclose(S_k.sum(), S_0, rtol=1e-3):
+        print(
+            "Warning! Inconsistency in computed HR factors (",
+            S_k.sum(),
+            S_0,
+            "). You may want to decrease sigma.",
+        )
+    S_t = np.fft.rfft(S_w) * dw
+    t = 2 * np.pi * np.fft.rfftfreq(S_w.shape[0]) / dw
+
+    G_t = np.exp(S_t - S_0 - broadening.gamma_zpl * t - 0.5 * broadening.sigma_zpl**2 * t**2)
+    A_w = np.fft.irfft(G_t) / dw
+    return dos, S_w, A_w
+
+
+@njit(cache=True, fastmath=True, error_model="numpy")
+def _do_compute_phonon_spec_func(
+    w: np.ndarray,
+    dq: np.ndarray,
+    omega: np.ndarray,
+    broadening: Broadening,
+    T: float,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Compute the phonon spectral function and related quantities at arbitrary T."""
+    dw = w[1] - w[0]
+    kT = kelvin2eV * T
+
+    w_k = omega2eV * omega
+    S_k = 0.5 * omega * dq**2 / omega2eV
+
+    n_k = np.zeros_like(S_k)
+    n_k[w_k > 0] = 1 / (np.exp(w_k[w_k > 0] / kT) - 1)
+
+    S_w, C_w, dos = np.zeros_like(w), np.zeros_like(w), np.zeros_like(w)
+    for i in range(S_k.shape[0]):
+        broad_f = lorentzian if broadening.method_psb[i] == 1 else gaussian
+        S_w += S_k[i] * broad_f(w - w_k[i], broadening.value_psb[i])
+        C_w += n_k[i] * S_k[i] * broad_f(w - w_k[i], broadening.value_psb[i])
+        dos += broad_f(w - w_k[i], broadening.value_psb[i])
+    dos /= S_k.shape[0]
+
+    S_0, C_0 = (S_w.sum() * dw), (C_w.sum() * dw)
+    if not np.isclose(S_k.sum(), S_0, rtol=1e-3):
+        print(
+            "Warning! Inconsistency in computed HR factors (",
+            S_k.sum(),
+            S_0,
+            "). You may want to decrease sigma.",
+        )
+
+    S_t = np.fft.fft(S_w) * dw
+    C_t = np.fft.fft(C_w) * dw
+    t = 2 * np.pi * np.fft.fftfreq(S_w.shape[0]) / dw
+
+    G_t = np.exp(
+        S_t
+        - S_0
+        + C_t
+        + C_t.conj()
+        - 2 * C_0
+        - broadening.gamma_zpl * np.abs(t)
+        - 0.5 * broadening.sigma_zpl**2 * t**2
+    )
+    A_w = np.fft.ifft(G_t) / dw
+    return dos, S_w, A_w.real
+
+
+def get_phonon_spec_func(
+    dq: np.ndarray,
+    omega: np.ndarray,
+    broadening: Broadening | None = None,
+    resolution: float = 1e-3,
+    w_max: float | None = None,
+    pad: float = 0.1,
+    T: float = 0.0,
+    **kwargs,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """Compute the phonon spectral function and related quantities.
+
+    If broadening is not provided, kwargs will be passed to Broadening.create
+    (see :func:`Broadening.create`).
+
+    When T == 0. (the default), an optimized evaluation of the spectral function is utilized.
+
+    Args:
+        dq (np.ndarray): mass-weighted displacement vector in normal mode basis in (amu^{1/2} Ang).
+        omega (np.ndarray): normal mode phonon frequencies (in eV/amu/Ang^2).
+        broadening (Broadening): instance of :class:`Broadening`.
+        resolution (float): desired energy resolution (in eV) of the calculated spectral functions.
+        w_max (np.ndarray): maximum frequency in grid.
+        pad (float): energy (in eV) below ZPL to pad the spectral function.
+        T (float): Temperature in kelvin.
+        **kwargs: keyword arguments passed to :func:`Broadening.create` when broadening is not
+            provided as input.
+
+    Returns:
+        w (np.ndarray): frequencies at which the functions were evaluated at (ħω)
+        dos (np.ndarray): phonon density of states ρ(ħω)
+        S_w (np.ndarray): Huang-Rhys spectral density S(ħω)
+        A_w (np.ndarray): spectral function A(ħω)
+    """
+    broadening = broadening or Broadening.create(omega=omega, **kwargs)
+
+    if resolution > broadening.gamma_zpl and resolution > broadening.sigma_zpl:
+        resolution = max(broadening.gamma_zpl, broadening.sigma_zpl)
+        logger.info(f"energy resolution is larger than ZPL broadening, decreasing to {resolution}")
+
+    w_max = w_max or (pad + max(2 * get_Stot(dq, omega), 3) * omega.max() * omega2eV)
+    N = int(w_max / resolution) + 1
+    # ensure an even number of grid points for T = 0 evaluation
+    if T <= 0.0:
+        N += N % 2
+    w = np.linspace(0.0, w_max, N)
+    if N > 50_000:
+        logger.warning(f"large number of grid points {N=}")
+    logger.debug(f"made frequency grid with {w_max=} {N=}")
+
+    if T > 0:
+        dos, S_w, A_w = _do_compute_phonon_spec_func(w, dq, omega, broadening, T)
+    else:
+        dos, S_w, A_w = _do_compute_phonon_spec_func_zeroT(w, dq, omega, broadening)
+
+    # padding at the end of w was for wrap-around in fft, need to roll arrays
+    n_shift = np.sum(w >= w[-1] - pad)
+
+    dos = np.roll(dos, n_shift)
+    S_w = np.roll(S_w, n_shift)
+    A_w = np.roll(A_w, n_shift)
+
+    new_w = np.roll(w, n_shift)
+    new_w[:n_shift] -= w[-1]
+
+    return new_w, dos, S_w, A_w
+
+
+def convert_A_to_L(
+    w: np.ndarray,
+    A: np.ndarray,
+    dE: float,
+    emission: bool = True,
+    norm: str = "area",
+) -> tuple[np.ndarray, np.ndarray]:
+    """Convert phonon spectral function into a (normalized) optical intensity.
+
+    Args:
+        w (np.ndarray): frequencies (in eV) where A is evaluated.
+        A (np.ndarray): spectral function.
+        dE (float): energy of the zero-phonon line.
+        emission (bool): determines if the intensity corresponds to emission or absorption.
+        norm (str): normalization of luminescence (area or max).
+
+    Returns:
+        new_w (np.ndarray): expanded range of frequencies where intensity is evaluated.
+        L (np.ndarray): optical intensity L(ħω) on expanded frequencies new_w.
+    """
+    new_w = (dE - w) if emission else (dE + w)
+
+    # remove negative frequencies, they should be superfluous anyway
+    tmp_A = A[new_w >= 0.0]
+    new_w = new_w[new_w >= 0.0]
+
+    L = new_w**3 * tmp_A if emission else new_w * tmp_A
+    if norm[0].lower() == "m":
+        L /= L.max()
+    else:
+        L /= L.sum() * (w[1] - w[0])
+    return new_w, L

lineshape_tools/phonon.py

@@ -0,0 +1,77 @@
+"""Implements functionality for handling phonons."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from lineshape_tools.constants import omega2eV
+
+if TYPE_CHECKING:
+    from ase.atoms import Atoms
+
+
+def get_ipr(U: np.ndarray) -> np.ndarray:
+    """Evaluate the inverse participation ratio.
+
+    Args:
+        U (np.ndarray): matrix with phonon eigenvectors as columns (see np.linalg.eigh).
+    """
+    return 1 / np.sum(
+        np.sum(U.reshape((U.shape[0] // 3, 3, U.shape[1])) ** 2, axis=1) ** 2, axis=0
+    )
+
+
+def get_disp_vect(atoms0: Atoms, atoms1: Atoms) -> np.ndarray:
+    """Compute smallest displacement vector between two sets of atoms.
+
+    Args:
+        atoms0 (Atoms): first set of atoms
+        atoms1 (Atoms): second set of atoms
+
+    Returns:
+        np.ndarray: 3N dimensional displacement vector in Å
+    """
+    dx = atoms0.get_scaled_positions() - atoms1.get_scaled_positions()
+    dx -= np.round(dx)
+    dx = dx @ atoms0.cell
+    return dx.flatten()
+
+
+def get_dq_vect(atoms0: Atoms, atoms1: Atoms) -> np.ndarray:
+    """Compute smallest mass-weighted displacement vector between two sets of atoms.
+
+    Args:
+        atoms0 (Atoms): first set of atoms
+        atoms1 (Atoms): second set of atoms
+
+    Returns:
+        np.ndarray: 3N dimensional displacement vector in amu^{1/2} Å
+    """
+    return np.repeat(np.sqrt(atoms0.get_masses()), 3) * get_disp_vect(atoms0, atoms1)
+
+
+def get_phonons(
+    dynmat: np.ndarray | Path | str, acoustic_tol: float = 5e-4
+) -> tuple[np.ndarray, np.ndarray]:
+    """Compute the phonon frequencies and eigenvectors from a dynamical matrix.
+
+    Args:
+        dynmat (np.ndarray | Path | str): path to a dynamical matrix in .npz format or a np.ndarray
+            corresponding to a dynamical matrix (shape 3N x 3N).
+        acoustic_tol (float): tolerance (in eV) to determine acoustic phonon modes.
+
+    Returns:
+        omega (np.ndarray): phonon frequencies (in eV/amu/Ang^2).
+        U (np.ndarray): matrix with phonon eigenvectors as columns (see np.linalg.eigh).
+    """
+    if isinstance(dynmat, Path) or isinstance(dynmat, str):
+        H = np.load(dynmat)["H"]
+    else:
+        H = dynmat
+
+    omega2, U = np.linalg.eigh(H)
+    omega2[omega2 < (acoustic_tol / omega2eV) ** 2] = 0.0
+    return np.sqrt(omega2), U

lineshape_tools/plot.py

@@ -0,0 +1,294 @@
+"""Various plotting utilities."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from lineshape_tools.constants import omega2eV
+from lineshape_tools.lineshape import convert_A_to_L, get_phonon_spec_func
+from lineshape_tools.phonon import get_ipr, get_phonons
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    import numpy as np
+
+
+def _make_subplots(
+    spec_funcs: list[tuple],
+    dE: float,
+    emission: bool,
+    omega_max: float,
+    omega_mult: float,
+    figsize: tuple[float, float],
+    skip_lim_adjust: bool,
+    ax=None,
+):
+    """Helper function to make subplot-type plot."""
+    if ax is not None:
+        fig = ax[0].get_figure()
+    else:
+        import matplotlib.pyplot as plt
+
+        fig, ax = plt.subplots(1, 3, figsize=figsize, constrained_layout=True)
+
+    for spec_func in spec_funcs:
+        w, dos, S, tw, L = spec_func
+
+        if dos is not None:
+            ax[0].plot(w, dos)
+
+        if S is not None:
+            ax[1].plot(w, S)
+
+        if L is not None:
+            ax[2].plot(tw, L)
+
+    if not skip_lim_adjust:
+        for a in ax:
+            a.set_ylim((0, a.get_ylim()[1]))
+
+        for a in ax[:2]:
+            a.set_xlim((0.0, omega_max + 0.005))
+
+        if emission:
+            ax[2].set_xlim((dE - omega_mult * omega_max - 0.02, dE + 0.02))
+        else:
+            ax[2].set_xlim((dE - 0.02, dE + omega_mult * omega_max + 0.02))
+
+    ax[0].set_xlabel(r"$\hbar\omega$ [eV]")
+    ax[0].set_ylabel(r"DOS $\rho(\hbar\omega)$ [eV$^{-1}$]")
+    ax[1].set_xlabel(r"$\hbar\omega$ [eV]")
+    ax[1].set_ylabel(r"Spectral Density $S(\hbar\omega)$ [eV$^{-1}$]")
+    ax[2].set_xlabel(r"Energy [eV]")
+    if emission:
+        ax[2].set_ylabel(r"Luminescence $L(\hbar\omega)$ [eV$^{-1}$]")
+    else:
+        ax[2].set_ylabel(r"Absorption $L(\hbar\omega)$ [eV$^{-1}$]")
+    return fig, ax
+
+
+def _make_inset(
+    spec_funcs: list[tuple],
+    dE: float,
+    emission: bool,
+    omega_max: float,
+    omega_mult: float,
+    figsize: tuple[float, float],
+    skip_lim_adjust: bool,
+    ax=None,
+):
+    """Helper function to make inset-type plot."""
+    if ax is not None:
+        fig = ax[0].get_figure()
+    else:
+        import matplotlib.pyplot as plt
+
+        fig, ax1 = plt.subplots(figsize=figsize, constrained_layout=True)
+        ax = [ax1, fig.add_axes((0.17, 0.55, 0.4, 0.35))]
+
+    for spec_func in spec_funcs:
+        w, _, S, tw, L = spec_func
+
+        if L is not None:
+            ax[0].plot(tw, L)
+
+        if S is not None:
+            ax[1].plot(w, S)
+
+    if not skip_lim_adjust:
+        for a in ax:
+            a.set_ylim((0, a.get_ylim()[1]))
+
+        ax[1].set_xlim((0.0, omega_max + 0.005))
+
+        if emission:
+            ax[0].set_xlim((dE - omega_mult * omega_max - 0.02, dE + 0.02))
+        else:
+            ax[0].set_xlim((dE - 0.02, dE + omega_mult * omega_max + 0.02))
+
+    ax[0].set_xlabel(r"Energy [eV]")
+    if emission:
+        ax[0].set_ylabel(r"Luminescence $L(\hbar\omega)$ [eV$^{-1}$]")
+    else:
+        ax[0].set_ylabel(r"Absorption $L(\hbar\omega)$ [eV$^{-1}$]")
+    ax[1].set_xlabel(r"$\hbar\omega$ [eV]")
+    ax[1].set_ylabel(r"$S(\hbar\omega)$ [eV$^{-1}$]")
+    return fig, ax
+
+
+def _make_single(
+    func_type: str,
+    spec_funcs: list[tuple],
+    dE: float,
+    emission: bool,
+    omega_max: float,
+    omega_mult: float,
+    figsize: tuple[float, float],
+    skip_lim_adjust: bool,
+    ax=None,
+):
+    """Helper function to make a single-function plot."""
+    if ax is not None:
+        fig = ax.get_figure()
+    else:
+        import matplotlib.pyplot as plt
+
+        fig, ax = plt.subplots(figsize=figsize, constrained_layout=True)
+
+    for spec_func in spec_funcs:
+        w, dos, S, tw, L = spec_func
+
+        if func_type[0].lower() == "d":
+            ax.plot(w, dos)
+        elif func_type[0].lower() == "s":
+            ax.plot(w, S)
+        else:
+            ax.plot(tw, L)
+
+    if not skip_lim_adjust:
+        ax.set_ylim((0, ax.get_ylim()[1]))
+
+        if func_type[0].lower() in ("d", "s"):
+            ax.set_xlim((0.0, omega_max + 0.005))
+        else:
+            if emission:
+                ax.set_xlim((dE - omega_mult * omega_max - 0.02, dE + 0.02))
+            else:
+                ax.set_xlim((dE - 0.02, dE + omega_mult * omega_max + 0.02))
+
+    if func_type[0].lower() in ("d", "s"):
+        ax.set_xlabel(r"$\hbar\omega$ [eV]")
+    else:
+        ax.set_xlabel(r"Energy [eV]")
+
+    if func_type[0].lower() == "d":
+        ax.set_ylabel(r"DOS $\rho(\hbar\omega)$ [eV$^{-1}$]")
+    elif func_type[0].lower() == "s":
+        ax.set_ylabel(r"Spectral Density $S(\hbar\omega)$ [eV$^{-1}$]")
+    else:
+        if emission:
+            ax.set_ylabel(r"Luminescence $L(\hbar\omega)$ [eV$^{-1}$]")
+        else:
+            ax.set_ylabel(r"Absorption $L(\hbar\omega)$ [eV$^{-1}$]")
+    return fig, ax
+
+
+def plot_spec_funcs(
+    dynmats: tuple | np.ndarray | Path | str | list[tuple | np.ndarray | Path | str],
+    dq: np.ndarray | None,
+    dE: float,
+    gamma_zpl: float = 0.001,
+    sigma_zpl: float = 0.0,
+    sigma_psb: tuple[float, float] = (0.005, 0.001),
+    gamma_psb: tuple[float, float] | None = None,
+    emission: bool = True,
+    omega_mult: float = 5.0,
+    omega_max: float = 0.0,
+    norm: str = "area",
+    T: float = 0,
+    plot_type: str = "subplot",
+    figsize: tuple[float, float] = (8.0, 2.5),
+    skip_lim_adjust: bool = False,
+    ax=None,
+):
+    """Make a plot of the spectral functions and luminescence/absorption intensity.
+
+    Args:
+        dynmats (tuple | np.ndarray | Path | str): path to a dynamical matrix in .npz format or a
+            np.ndarray corresponding to a dynamical matrix (shape 3N x 3N). If a tuple is given,
+            assume that the spectral functions have already been obtained. The tuple should contain
+            elements (w, dos, S, w_L, L) where w is the freq grid of dos/S and w_L is the freq grid
+            of L. A list of dynmats can be provided instead.
+        dq (np.ndarray): mass-weighted displacement vector in (amu^{1/2} Ang). Can be None if all
+            dynmats that are provided are of type tuple (see above).
+        dE (float): energy of the zero-phonon line.
+        gamma_zpl (float): Lorentzian broadening in the ZPL to capture homogeneous broadening.
+        sigma_zpl (float): Gaussian broadening in the ZPL to capture inhomogeneous broadening.
+        sigma_psb (float, float): Gaussian broadening used to broaden the partial Huang-Rhys
+            factors. The broadening factor is linearly interpolated from sigma_psb[0] at zero
+            frequency to sigma_psb[1] at the highest (non-LVM) frequency.
+        gamma_psb (float, float): Turns on Lorentzian broadening of local vibrational modes
+            identified by their inverse participation ratio. gamma_psb[0] is ipr_cut and
+            gamma_psb[1] is gamma_lvm. See :class:`Broadening`.
+        emission (bool): determines if the intensity corresponds to emission or absorption.
+        omega_mult (float): how many factors of the maximum phonon frequency from the ZPL will be
+            plotted in the luminescence/absorption intensity.
+        omega_max (float): maximum phonon frequency can be provided if known, used in determining
+            the plot ranges.
+        norm (str): normalization of luminescence (area or max).
+        T (float): Temperature in kelvin.
+        plot_type (str): type of plot to generate. "subplot" will generate a subplot for the dos, S
+            and L, respectively. "inset" will plot L with S as an inset. To make a plot of a single
+            type of function, specify "dos", "S", or "L".
+        figsize (tuple): figsize passed to `matplotlib.pyplot.subplots`.
+        skip_lim_adjust (bool): do not adjust xlim and ylim when making plots.
+        ax (plt.Axes): matplotlib axes object (an array of them) if already made.
+    """
+    if not isinstance(dynmats, list):
+        dynmats = [dynmats]
+
+    spec_funcs = []
+    for i, dynmat in enumerate(dynmats):
+        if isinstance(dynmat, tuple):
+            spec_funcs.append(dynmat)
+            continue
+
+        logger.info(f"dynmat {i} - diagonalizing")
+        omega, U = get_phonons(dynmat)
+        dq_k = U.T @ dq
+
+        if gamma_psb is not None:
+            logger.info(f"dynmat {i} - computing inverse participation ratios")
+            ipr, ipr_cut, gamma_lvm = get_ipr(U), gamma_psb[0], gamma_psb[1]
+        else:
+            ipr, ipr_cut, gamma_lvm = None, None, None
+
+        if omega2eV * omega.max() > omega_max:
+            omega_max = omega2eV * omega.max()
+
+        logger.info(f"dynmat{i} - evaluating spectral functions")
+        w, dos, S, A = get_phonon_spec_func(
+            dq_k,
+            omega,
+            sigma_psb=sigma_psb,
+            gamma_zpl=gamma_zpl,
+            sigma_zpl=sigma_zpl,
+            ipr=ipr,
+            ipr_cut=ipr_cut,
+            gamma_lvm=gamma_lvm,
+            T=T,
+        )
+        tw, L = convert_A_to_L(w, A, dE, emission=emission, norm=norm)
+
+        spec_funcs.append((w, dos, S, tw, L))
+
+    if omega_max <= 0.0 and not skip_lim_adjust:
+        logger.warning("the maximum omega could not be determined, falling back to 0.1")
+        omega_max = 0.1
+
+    if plot_type[0].lower() == "i":
+        return _make_inset(
+            spec_funcs, dE, emission, omega_max, omega_mult, figsize, skip_lim_adjust, ax=ax
+        )
+    elif plot_type.lower()[:2] == "su":
+        return _make_subplots(
+            spec_funcs, dE, emission, omega_max, omega_mult, figsize, skip_lim_adjust, ax=ax
+        )
+    elif plot_type[0].lower() in ("d", "s", "l"):
+        return _make_single(
+            plot_type,
+            spec_funcs,
+            dE,
+            emission,
+            omega_max,
+            omega_mult,
+            figsize,
+            skip_lim_adjust,
+            ax=ax,
+        )
+    else:
+        raise ValueError(f"unknown plot_type {plot_type}")