orto 1.5.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

orto/plotter.py

@@ -2,117 +2,44 @@ import matplotlib.pyplot as plt
 import matplotlib as mpl
 from matplotlib.ticker import AutoMinorLocator
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
 import itertools
 import pathlib
 
 from . import utils as ut
-
-
-def gaussian(p: ArrayLike, fwhm: float, b: float, area: float) -> NDArray:
-    """
-    Gaussian g(p) with given peak position (b), fwhm, and area
-
-    g(p) = area/(c*sqrt(2pi)) * exp(-(p-b)**2/(2c**2))
-
-    c = fwhm/(2*np.sqrt(2*np.log(2)))
-
-    Parameters
-    ----------
-    p : array_like
-        Continuous variable
-    fwhm: float
-        Full Width at Half-Maximum
-    b : float
-        Peak position
-    area : float
-        Area of Gaussian function
-
-    Return
-    ------
-    list[float]
-        g(p) at each value of p
-    """
-
-    c = fwhm / (2 * np.sqrt(2 * np.log(2)))
-
-    a = 1. / (c * np.sqrt(2 * np.pi))
-
-    gaus = a * np.exp(-(p - b)**2 / (2 * c**2))
-
-    gaus *= area
-
-    return gaus
-
-
-def lorentzian(p: ArrayLike, fwhm, p0, area) -> NDArray:
-    """
-    Lotenztian L(p) with given peak position (b), fwhm, and area
-
-    L(p) = (0.5*area*fwhm/pi) * 1/((p-p0)**2 + (0.5*fwhm)**2)
-
-    Parameters
-    ----------
-    p : array_like
-        Continuous variable
-    fwhm: float
-        Full Width at Half-Maximum
-    p0 : float
-        Peak position
-    area : float
-        Area of Lorentzian function
-
-    Return
-    ------
-    list[float]
-        L(p) at each value of p
-    """
-
-    lor = 0.5 * fwhm / np.pi
-    lor *= 1. / ((p - p0)**2 + (0.5 * fwhm)**2)
-
-    lor *= area
-
-    return lor
-
-
-def plot_abs(x_values: ArrayLike, x_type: str, foscs: ArrayLike,
-             lineshape: str = 'gaussian', linewidth: float = 100.,
-             x_lim: list[float] = ['auto', 'auto'],
-             abs_type: str = 'napierian',
-             y_lim: list[float] = [0., 'auto'],
-             x_shift: float = 0., normalise: bool = False,
-             osc_style: str = 'separate', save: bool = False,
-             save_name: str = 'absorption_spectrum.png', show: bool = False,
-             verbose: bool = True,
-             window_title: str = 'Absorption Spectrum',
-             plot_type: str = 'absorption') -> tuple[plt.Figure, list[plt.Axes]]: # noqa
+from . import data
+
+
+def plot_absorption_spectrum(abs_data: data.AbsorptionData,
+                             linecolor: str = 'black',
+                             stickcolour: str = 'black',
+                             x_lim: list[float] = ['auto', 'auto'],
+                             y_lim: list[float] = [0., 'auto'],
+                             x_shift: float = 0.,
+                             normalise: bool = False,
+                             osc_style: str = 'separate',
+                             fig: plt.Figure = None, ax: plt.Axes = None,
+                             oax: plt.Axes = None, save: bool = False,
+                             save_name: str = 'absorption_spectrum.png',
+                             show: bool = False,
+                             verbose: bool = True,
+                             window_title: str = 'Absorption Spectrum',
+                             legend: bool = True) -> tuple[plt.Figure, plt.Axes, plt.Axes | None]: # noqa
     '''
-    Plots absorption spectrum with intensity specified by oscillator strength.\n # noqa
-    Spectrum is computed as a sum of Gaussian or Lorentzian lineshapes.\n
-    The x_values can be either wavenumbers [cm^-1], wavelengths [nm] or\n
-    energies [eV].\n
+    Plots absorption spectrum from AbsorptionSpectrum object.\n
 
     Parameters
     ----------
-    x_values: array_like
-        x_values for each transition, either wavenumber, wavelength or energy\n
-        with unit type specified by x_type
-    x_type: str {'wavenumber', 'wavelength', 'energy'}
-        Type of x_values, either wavenumber [cm^-1], wavelength [nm] or\n
-        energy [eV].
-    foscs: array_like
-        Oscillator strength of each transition
-    lineshape: str {'gaussian', 'lorentzian'}
-        Lineshape function to use for each transition/signal
-    linewidth: float
-        Linewidth used in lineshape [cm^-1]
+    abs_data: data.AbsorptionData
+        Data object containing absorption data and spectrum
+    linecolor: str, default 'black'
+        Color of the continuous spectrum line
+    stickcolour: str, default 'black'
+        Color of the oscillator strength sticks
     x_lim: list[float], default ['auto', 'auto']
-        Minimum and maximum x-values to plot [cm^-1 or nm]
+        Minimum and maximum x-values to plot
     y_lim: list[float | str], default [0., 'auto']
-        Minimum and maximum y-values to plot [cm^-1 mol^-1 L]
-    abs_type: str {'napierian', 'logarithmic'}
-        Absorbance (and epsilon) type to use. Orca_mapspc uses napierian
+        Minimum and maximum y-values to plot
     normalise: bool, default False
         If True, normalise the absorption spectrum to the maximum value.
     osc_style: str, default 'separate'
@@ -120,6 +47,12 @@ def plot_abs(x_values: ArrayLike, x_type: str, foscs: ArrayLike,
         - 'separate': plots oscillator strengths as stems on separate axis
         - 'combined': plots oscillator strengths on intensity axis
         - 'off': does not plot oscillator strengths
+    fig: plt.Figure | None, optional
+        If provided, uses this Figure object for plotting
+    ax: plt.Axes | None, optional
+        If provided, uses this Axis object for plotting spectrum
+    oax: plt.Axes | None, optional
+        If provided, uses this Axis object for plotting oscillator strengths
     save: bool, default False
         If True, plot is saved to save_name
     save_name: str | pathlib.Path, default 'absorption_spectrum.png'
@@ -130,9 +63,8 @@ def plot_abs(x_values: ArrayLike, x_type: str, foscs: ArrayLike,
         If True, plot file location is written to terminal
     window_title: str, default 'UV-Visible Absorption Spectrum'
         Title of figure window, not of plot
-    plot_type: str, default 'absorption'
-        Type of plot to create, either 'absorption' or 'emission'.
-
+    legend: bool, default True
+        If True, a legend is added to the plot
     Returns
     -------
     plt.Figure
@@ -141,20 +73,16 @@ def plot_abs(x_values: ArrayLike, x_type: str, foscs: ArrayLike,
         Matplotlib Axis object for main plot followed by\n
         Matplotlib Axis object for twinx oscillator strength axis
     '''
-
     save_name = pathlib.Path(save_name)
 
-    x_values = np.asarray(x_values) + x_shift
-    foscs = np.asarray(foscs)
-    if len(x_values) != len(foscs):
-        raise ValueError('x_values and foscs must have the same length')
+    if abs_data.spectrum is None:
+        raise ValueError('AbsorptionData object does not contain spectrum')
 
-    fig, ax = plt.subplots(1, 1, num=window_title)
+    if fig is None or ax is None:
+        fig, ax = plt.subplots(1, 1, num=window_title)
 
-    ls_func = {
-        'gaussian': gaussian,
-        'lorentzian': lorentzian
-    }
+    if oax is None and osc_style == 'separate':
+        oax = ax.twinx()
 
     if not isinstance(x_lim, list):
         raise ValueError('`x_lim` must be a list of values')
@@ -163,137 +91,133 @@ def plot_abs(x_values: ArrayLike, x_type: str, foscs: ArrayLike,
         if isinstance(x_lim[0], str):
             if x_lim[0] == 'auto':
                 x_lim[0] = ax.get_ylim()[0]
-            else:
+            elif ut.is_floatable(x_lim[0]):
                 x_lim[0] = float(x_lim[0])
+            else:
+                raise ValueError(f'Invalid x_lim[0] value: {x_lim[0]}')
         if isinstance(x_lim[1], str):
             if x_lim[1] == 'auto':
                 x_lim[1] = ax.get_ylim()[1]
-            else:
+            elif ut.is_floatable(x_lim[1]):
                 x_lim[1] = float(x_lim[1])
-    else:
-        x_lim = [np.min(x_values), np.max(x_values)]
+            else:
+                raise ValueError(f'Invalid x_lim[1] value: {x_lim[1]}')
 
     # Set limits and range of continuous variable
-    ax.set_xlim([x_lim[0], x_lim[1]])
-    x_grid = np.linspace(x_lim[0], x_lim[1], 100000)
-
-    # Exclude values of x_values out of the range of x_lim
-    x_values = np.asarray(
-        [val for val in x_values if x_lim[0] <= val <= x_lim[1]]
-    )
-    # Exclude oscillator strengths for those values
-    foscs = np.asarray(
-        [
-            fosc
-            for val, fosc in zip(x_values, foscs)
-            if x_lim[0] <= val <= x_lim[1]]
-    )
-
-    # Conversion from oscillator strength to napierian integrated absorption
-    # coefficient
-    # This is the value of A for a harmonically oscillating electron
-    A_elec = 2.31E8
-    # convert to common log absorbance if desired
-    if abs_type == 'log':
-        A_elec /= np.log(10)
-    A_logs = [fosc * A_elec for fosc in foscs]
-
-    # Spectrum as sum of signals. Always computed in wavenumbers.
-    spectrum = np.sum([
-        ls_func[lineshape](x_grid, linewidth, x_value, A_log)
-        for x_value, A_log in zip(x_values, A_logs)
-    ], axis=0)
+    # ax.set_xlim([x_lim[0], x_lim[1]])
 
+    # Normalisation of spectrum
     if normalise:
         # Normalise the spectrum to the maximum value
-        spectrum /= np.max(spectrum)
-        ax.set_ylabel(
-            'Normalised {} (arbitrary units)'.format(
-                plot_type.capitalize()
-            )
-        )  # noqa
+        _y_values = abs_data.spectrum.y_values / np.max(abs_data.spectrum.y_values) # noqa
+        _osc = abs_data.osc_strengths / np.max(abs_data.osc_strengths)
+        ax.set_ylabel('Normalised Absorption')
     else:
-        ax.set_ylabel(r'$\epsilon$ (cm$^\mathregular{-1}$ mol$^\mathregular{-1}$ L)') # noqa
-
-    _txt_save_name = save_name.with_suffix('.txt')
-    np.savetxt(
-        _txt_save_name,
-        np.vstack([x_grid, spectrum]).T,
-        fmt='%.5f',
-        header=f'{plot_type.capitalize()} spectrum data\nx (wavenumber, wavelength or energy), y (absorbance)' # noqa
-    )
-    if verbose:
-        ut.cprint(
-            f'\n{plot_type.capitalize()} spectrum data saved to\n {_txt_save_name}', # noqa
-            'cyan'
-        )
+        _y_values = abs_data.spectrum.y_values
+        _osc = abs_data.osc_strengths
+        ax.set_ylabel(abs_data.spectrum.y_label)
+
+    if abs_data.spectrum.x_label == 'Wavelength (nm)':
+        ax.invert_xaxis()
+        stick_x_values = [
+            wavelength + x_shift
+            for wavelength in abs_data.wavelengths
+        ]
+    elif abs_data.spectrum.x_label == 'Energy (eV)':
+        stick_x_values = [
+            energy + x_shift
+            for energy in abs_data.energies
+        ]
+    elif abs_data.spectrum.x_label == r'Wavenumber (cm$\mathregular{^{-1}}$)':
+        stick_x_values = [
+            wavenumber + x_shift
+            for wavenumber in abs_data.wavenumbers
+        ]
+
+    x_values = abs_data.spectrum.x_grid + x_shift
 
     # Main spectrum
-    ax.plot(x_grid, spectrum, color='k')
+    ax.plot(
+        x_values,
+        _y_values,
+        color=linecolor,
+        label=abs_data.spectrum.comment
+    )
 
     if osc_style == 'separate':
-        fax = ax.twinx()
         # Oscillator strength twin axis
-        fax.stem(x_values, foscs, basefmt=' ', markerfmt=' ')
-        fax.yaxis.set_minor_locator(AutoMinorLocator())
-        fax.set_ylabel(r'$f_\mathregular{osc}$')
-        fax.set_ylim([0., fax.get_ylim()[1]])
+        oax.stem(
+            stick_x_values,
+            _osc,
+            basefmt=' ',
+            markerfmt=' ',
+            linefmt=stickcolour
+        )
+        oax.yaxis.set_minor_locator(AutoMinorLocator())
+        oax.set_ylabel(r'$f_\mathregular{osc}$')
+        oax.set_ylim([0., oax.get_ylim()[1]])
     elif osc_style == 'combined':
-        fax = None
-        plt.subplots_adjust(right=0.2)
         ax.stem(
-            x_values,
-            foscs/np.max(foscs) * np.max(spectrum),
+            stick_x_values,
+            abs_data.osc_strengths/np.max(abs_data.osc_strengths) * np.max(_y_values), # noqa
             basefmt=' ',
-            markerfmt=' '
+            markerfmt=' ',
+            linefmt=stickcolour
         )
+        oax.set_yticks([])
+        oax.spines['right'].set_visible(False)
+        oax.spines['top'].set_visible(False)
         ax.spines['right'].set_visible(False)
         ax.spines['top'].set_visible(False)
     else:
-        fax = None
         # No oscillator strength plot
         plt.subplots_adjust(right=0.2)
+        oax.set_yticks([])
+        oax.spines['right'].set_visible(False)
+        oax.spines['top'].set_visible(False)
         ax.spines['right'].set_visible(False)
         ax.spines['top'].set_visible(False)
 
-    if y_lim[0] != y_lim[1]:
-        if isinstance(y_lim[0], str):
-            if y_lim[0] == 'auto':
-                y_lim[0] = ax.get_ylim()[0]
+    # Set y limits if specified
+    _y_lim = y_lim.copy()
+    if _y_lim[0] != _y_lim[1]:
+        # Lower limit either auto or specified
+        if isinstance(_y_lim[0], str):
+            if _y_lim[0] == 'auto':
+                _y_lim[0] = ax.get_ylim()[0]
             else:
-                y_lim[0] = float(y_lim[0])
-        if isinstance(y_lim[1], str):
-            if y_lim[1] == 'auto':
-                y_lim[1] = ax.get_ylim()[1]
+                _y_lim[0] = float(_y_lim[0])
+        # Upper limit either auto or specified
+        if isinstance(_y_lim[1], str):
+            if _y_lim[1] == 'auto':
+                _y_lim[1] = ax.get_ylim()[1]
             else:
-                y_lim[1] = float(y_lim[1])
-        ax.set_ylim([y_lim[0], y_lim[1]])
+                _y_lim[1] = float(_y_lim[1])
+        # Set values
+        ax.set_ylim([_y_lim[0], _y_lim[1]])
 
     ax.xaxis.set_minor_locator(AutoMinorLocator())
     ax.yaxis.set_minor_locator(AutoMinorLocator())
 
-    xtype_to_label = {
-        'wavenumber': r'Wavenumber (cm$^\mathregular{-1}$)',
-        'wavelength': 'Wavelength (nm)',
-        'energy': r'Energy (eV)'
-    }
-
-    ax.set_xlabel(xtype_to_label[x_type.lower()])
+    ax.set_xlabel(abs_data.spectrum.x_label)
 
     fig.tight_layout()
 
+    if legend:
+        ax.legend()
+
     if save:
         plt.savefig(save_name, dpi=500)
         if verbose:
             ut.cprint(
-                f'\n{plot_type.capitalize()} spectrum saved to\n {save_name}',
+                f'\nSpectrum saved to\n {save_name}',
                 'cyan'
             )
 
     if show:
         plt.show()
 
-    return fig, [ax, fax]
+    return fig, ax, oax
 
 
 def wl_to_wn(wl: float) -> float:
@@ -407,8 +331,8 @@ def plot_ir(wavenumbers: ArrayLike, linear_absorbance: ArrayLike,
     fig, ax = plt.subplots(1, 1, num=window_title)
 
     ls_func = {
-        'gaussian': gaussian,
-        'lorentzian': lorentzian
+        'gaussian': ut.gaussian,
+        'lorentzian': ut.lorentzian
     }
 
     if None not in x_lim:

orto/utils.py

@@ -293,3 +293,126 @@ def orbname_to_mathmode(names: ArrayLike) -> NDArray:
     ])
 
     return mmode
+
+
+def check_font_envvar() -> None:
+    '''
+    Checks if orto_fontname environment variable is set, and if so
+    sets matplotlib font to specified font
+    '''
+
+    import matplotlib.pyplot as plt
+
+    if os.getenv('orto_fontname'):
+        try:
+            plt.rcParams['font.family'] = os.getenv('orto_fontname')
+        except ValueError:
+            red_exit(
+                'Error setting font to {}'.format(
+                    os.getenv('orto_fontname')
+                )
+            )
+
+    return
+
+
+def gaussian(p: ArrayLike, fwhm: float, b: float, area: float) -> NDArray:
+    """
+    Gaussian g(p) with given peak position (b), fwhm, and area
+
+    g(p) = area/(c*sqrt(2pi)) * exp(-(p-b)**2/(2c**2))
+
+    c = fwhm/(2*np.sqrt(2*np.log(2)))
+
+    Parameters
+    ----------
+    p : array_like
+        Continuous variable
+    fwhm: float
+        Full Width at Half-Maximum
+    b : float
+        Peak position
+    area : float
+        Area of Gaussian function
+
+    Return
+    ------
+    list[float]
+        g(p) at each value of p
+    """
+
+    c = fwhm / (2 * np.sqrt(2 * np.log(2)))
+
+    a = 1. / (c * np.sqrt(2 * np.pi))
+
+    gaus = a * np.exp(-(p - b)**2 / (2 * c**2))
+
+    gaus *= area
+
+    return gaus
+
+
+def lorentzian(p: ArrayLike, fwhm, p0, area) -> NDArray:
+    """
+    Lotenztian L(p) with given peak position (b), fwhm, and area
+
+    L(p) = (0.5*area*fwhm/pi) * 1/((p-p0)**2 + (0.5*fwhm)**2)
+
+    Parameters
+    ----------
+    p : array_like
+        Continuous variable
+    fwhm: float
+        Full Width at Half-Maximum
+    p0 : float
+        Peak position
+    area : float
+        Area of Lorentzian function
+
+    Return
+    ------
+    list[float]
+        L(p) at each value of p
+    """
+
+    lor = 0.5 * fwhm / np.pi
+    lor *= 1. / ((p - p0)**2 + (0.5 * fwhm)**2)
+
+    lor *= area
+
+    return lor
+
+
+def find_unique_substring(names):
+    '''
+    Finds unique substring in each name from list of names
+    '''
+
+    unique_names = []
+    for name in names:
+        for il, letter in enumerate(name):
+            if all(oname[il] != letter for oname in names if oname != name):
+                unique_names.append(name[il:])
+                break
+    return unique_names
+
+def is_floatable(string: str) -> bool:
+    '''
+    Checks if string can be converted to float
+
+    Parameters
+    ----------
+    string : str
+        String to check
+
+    Returns
+    -------
+    bool
+        True if string can be converted to float, False otherwise
+    '''
+
+    try:
+        float(string)
+        return True
+    except ValueError:
+        return False

{orto-1.5.0.dist-info → orto-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orto
-Version: 1.5.0
+Version: 1.6.0
 Summary: A package to make life easier when performing Orca calculations.
 Home-page: https://orto.kragskow.group
 Author: Jon Kragskow
@@ -12,6 +12,7 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: numpy>=2.1.2
 Requires-Dist: xyz_py>=5.13.1
 Requires-Dist: matplotlib>=3.9.2
@@ -25,6 +26,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: requires-python

orto-1.6.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+orto/__init__.py,sha256=IedlltYr3qYZxChNUdz62qogXA9Pos_MUvXdGXqAa0E,41
+orto/__version__.py,sha256=bYN93DTWr8alkTnO3wj31CU5gqTshxIcsbXUcJcUAc8,22
+orto/cli.py,sha256=AH9Cnfu21XGTs2ygLZGb8yxzJPe1gxxnF9qOsm_H1II,76491
+orto/constants.py,sha256=anxaiTykO8Q_CXliR7zuOAdnXZrQ2-C4ndaviyl7kGc,419
+orto/data.py,sha256=r6Ht1X0-FhjUbEAAi3a9F2R2_QG3QFElaAAcZNz4GRQ,11213
+orto/exceptions.py,sha256=D7oNeAEGeJNt5thzt6PaCn5FY6JcbJOWUE1N1LVhhuE,159
+orto/extractor.py,sha256=d2_pGQeIjK_JbsMINTawUgcO2vcPq0b9uQj9VKuI720,75953
+orto/input.py,sha256=N8JbySSVEC_qmXZ7ppJsZ7Z1qel6PfalGYRtnX1hJ6U,9900
+orto/job.py,sha256=SM0nlc_bqhhPvfuuykhMvaUnkwC3Gp-6RvYw_a0TyGc,5855
+orto/plotter.py,sha256=-8Lgv-kDjw_wHZrDrQzQGT521gSZ3IJdIeLqzdQgflQ,17656
+orto/utils.py,sha256=fghKZnrO1HTtOZPZRbNK6QTgUOXiIQ6NEFvesDSoY0o,9836
+orto-1.6.0.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+orto-1.6.0.dist-info/METADATA,sha256=zfjB9HzSeKgJKRlTqLMw2AmqspP1nyYAlJZDa_vS3kE,1184
+orto-1.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orto-1.6.0.dist-info/entry_points.txt,sha256=HXenCglMp_03JkN34pK2phkjXK9CFcXTGHKv5QaVY8I,39
+orto-1.6.0.dist-info/top_level.txt,sha256=hQ-z28gTN_FZ2B5Kiwxr_9cUTcCoib9W5HjbkceDXw4,5
+orto-1.6.0.dist-info/RECORD,,