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

orto/data.py

@@ -0,0 +1,351 @@
+import numpy as np
+from numpy.typing import NDArray, ArrayLike
+
+from .exceptions import DataFormattingError
+from . import constants as const
+from . import extractor as oe
+from . import utils as ut
+
+
+class AbsorptionSpectrum():
+    '''
+    Stores absorption spectrum data
+
+    Parameters
+    ----------
+    x_grid: NDArray
+        Grid of x values (energies, wavelengths, or wavenumbers)
+    x_unit: str
+        Unit of x values: 'eV', 'nm', or 'cm^-1'
+    x_label: str
+        Label for x axis using LaTeX formatting
+    y_unit: str
+        Unit of y values, e.g. 'cm^-1 mol^-1 L'
+    y_label: str
+        Label for y axis using LaTeX formatting
+    spectrum: NDArray
+        Absorption spectrum values at each point in x_grid
+    fwhm: float
+        Full width at half maximum used in spectrum generation
+    comment: str, default=''
+        Comment or metadata for the spectrum
+
+    Attributes
+    ----------
+    x_grid: NDArray
+        Grid of x values (energies, wavelengths, or wavenumbers)
+    x_unit: str
+        Unit of x values: 'eV', 'nm', or 'cm^-1'
+    x_label: str
+        Label for x axis using LaTeX formatting
+    y_unit: str
+        Unit of y values, e.g. 'cm^-1 mol^-1 L'
+    y_label: str
+        Label for y axis using LaTeX formatting
+    y_values: NDArray
+        Absorption spectrum values at each point in x_grid
+    fwhm: float
+        Full width at half maximum used in spectrum generation
+    comment: str
+        Comment or metadata for the spectrum
+    '''
+
+    def __init__(self, x_grid: NDArray, x_unit: str, x_label: str, y_unit: str,
+                 y_label: str, y_values: NDArray, fwhm: float,
+                 comment: str = '') -> None:
+        self.x_grid = x_grid
+        self.x_unit = x_unit
+        self.x_label = x_label
+        self.y_unit = y_unit
+        self.y_label = y_label
+        self.fwhm = fwhm
+        self.y_values = y_values
+        self.comment = comment
+        return
+
+    @classmethod
+    def from_data(cls, x_grid: NDArray, y_values: NDArray,
+                  fwhm: float) -> 'AbsorptionSpectrum':
+        '''
+        Creates AbsorptionSpectrum object from data
+
+        Parameters
+        ----------
+        x_grid: NDArray
+            Grid of x values (energies, wavelengths, or wavenumbers)
+        y_values: NDArray
+            Absorption spectrum values at each point in x_grid
+        fwhm: float
+            Full width at half maximum used in spectrum generation
+
+        Returns
+        -------
+        AbsorptionSpectrum
+            Created AbsorptionSpectrum object
+        '''
+        return cls(x_grid, y_values, fwhm)
+
+
+class AbsorptionData():
+    '''
+    Stores absorption data for a given set of transitions
+
+    Parameters
+    ----------
+    energies: array_like
+        Transition energies in eV
+    osc_strengths: array_like
+        Oscillator strengths for each transition
+    operator: str
+        Type of operator used to calculate transitions
+
+    Attributes
+    ----------
+    energies: list
+        Transition energies in eV
+    osc_strengths: list
+        Oscillator strengths for each transition
+    operator: str
+        Type of operator used to calculate transitions
+    spectrum: AbsorptionSpectrum
+        Spectrum object containing spectrum curve
+    wavelengths: list
+        Transition wavelengths in nm
+    wavenumbers: list
+        Transition wavenumbers in cm^-1
+    '''
+
+    def __init__(self, energies: ArrayLike, osc_strengths: ArrayLike,
+                 operator: str) -> None:
+        self.energies = energies
+        self.osc_strengths = osc_strengths
+        self.operator = operator
+        self.spectrum: None | AbsorptionSpectrum = None
+        return
+
+    @property
+    def osc_strengths(self) -> list:
+        '''Oscillator strengths for each transition'''
+        return self._osc_strengths
+
+    @osc_strengths.setter
+    def osc_strengths(self, osc_strengths: ArrayLike) -> None:
+        self._osc_strengths = list(osc_strengths)
+        return
+
+    @property
+    def energies(self) -> list:
+        '''Transition energies in eV'''
+        return self._energies
+
+    @energies.setter
+    def energies(self, energies: ArrayLike) -> None:
+        self._energies = list(energies)
+        return
+
+    @property
+    def wavelengths(self) -> list:
+        '''Transition wavelengths in nm'''
+        return [const.EV_TO_NM / energy for energy in self.energies]
+
+    @property
+    def wavenumbers(self) -> list:
+        '''Transition wavenumbers in cm^-1'''
+        return [energy * const.EV_TO_WAVENUMBER for energy in self.energies]
+
+    @property
+    def spectrum(self) -> AbsorptionSpectrum:
+        '''Absorption spectrum object'''
+        if self._spectrum is None:
+            raise ValueError(
+                'Spectrum has not been generated yet\n'
+                'Call generate_spectrum() first.'
+            )
+        return self._spectrum
+
+    @spectrum.setter
+    def spectrum(self, spectrum: AbsorptionSpectrum) -> None:
+        if not isinstance(spectrum, AbsorptionSpectrum | None):
+            raise TypeError('spectrum must be an AbsorptionSpectrum object')
+        self._spectrum = spectrum
+        return
+
+    @classmethod
+    def from_extractor(cls, extractor: oe.AbsorptionExtractor,
+                       remove_zero_osc: bool = True) -> list['AbsorptionData']: # noqa
+        '''
+        Creates AbsorptionData object from data extractor
+
+        Parameters
+        ----------
+        extractor: Extractor
+            Data extractor object containing transition data
+        remove_zero_osc: bool
+            If True, removes transitions with zero oscillator strength
+
+        Returns
+        -------
+        list['AbsorptionData']
+            AbsorptionData objects, one for each section in extractor
+        '''
+
+        all_abs_data = [
+            cls.from_extractor_dataset(
+                dataset,
+                extractor.operator_type,
+                remove_zero_osc=remove_zero_osc
+            )
+            for dataset in extractor.data
+        ]
+
+        return all_abs_data
+
+    @classmethod
+    def from_extractor_dataset(cls,
+                               dataset: dict[str, list[int | float]],
+                               operator: str,
+                               remove_zero_osc: bool = False) -> 'AbsorptionData': # noqa
+        '''
+        Creates AbsorptionData object from data extractor
+
+        Parameters
+        ----------
+        dataset: dict[str, list[int | float]]
+            Dataset from orto AbsorptionExtractor.data
+        operator: str
+            Type of operator used to calculate transitions
+        remove_zero_osc: bool
+            If True, removes transitions with zero oscillator strength
+
+        Returns
+        -------
+        AbsorptionData
+            AbsorptionData object for dataset
+        '''
+
+        energies = dataset['energy (ev)']
+        osc_strengths = dataset['fosc']
+
+        # Remove transitions with zero oscillator strength from
+        # beginning and end of spectrum
+        if remove_zero_osc:
+            osc_strengths = np.array(osc_strengths)
+            # Find first non-zero oscillator strength
+            first_nonzero = np.where(osc_strengths > 1E-4)[0][0]
+            # Find last non-zero oscillator strength
+            last_nonzero = np.where(osc_strengths > 1E-4)[0][-1]
+
+            # Trim data
+            energies = energies[first_nonzero:last_nonzero + 1]
+            osc_strengths = osc_strengths[first_nonzero:last_nonzero + 1]
+
+        return cls(energies, osc_strengths, operator)
+
+    def generate_spectrum(self, fwhm: float, lineshape: str, x_min: float,
+                          x_max: float, num_points: int,
+                          x_type: str = 'energy',
+                          comment: str = '') -> AbsorptionSpectrum:
+        '''
+        Generates absorption spectrum using Gaussian broadening
+
+        Parameters
+        ----------
+        fwhm: float
+            Full width at half maximum for Gaussian broadening\n
+            in same units as x_type. Applied to each transition.
+        lineshape: str
+            Lineshape function to use: 'gaussian' or 'lorentzian'
+        x_min: float | str
+            Minimum x value for spectrum (eV, nm, or cm^-1)
+        x_max: float | str
+            Maximum x value for spectrum (eV, nm, or cm^-1)
+        num_points: int
+            Number of points in the spectrum grid
+        x_type: str
+            Type of x values: \n
+              'energy' (eV)\n
+              'wavelength' (nm)\n
+              'wavenumber' (cm^-1)
+        comment: str
+            Comment to add to spectrum metadata
+
+        Returns
+        -------
+        None
+        '''
+
+        if len(self.energies) == 0 or len(self.osc_strengths) == 0:
+            raise DataFormattingError(
+                'No transition data available to generate spectrum.'
+            )
+        elif len(self.energies) != len(self.osc_strengths):
+            raise DataFormattingError(
+                'Energies and oscillator strengths must have the same length.'
+            )
+
+        # Set labels and x values based on x_type
+        if x_type == 'energy':
+            x_unit = 'eV'
+            x_label = 'Energy (eV)'
+            x_vals = self.energies
+        elif x_type == 'wavelength':
+            x_unit = 'nm'
+            x_label = 'Wavelength (nm)'
+            x_vals = self.wavelengths
+        elif x_type == 'wavenumber':
+            x_unit = 'cm^-1'
+            x_label = r'Wavenumber (cm$\mathregular{^{-1}}$)'
+            x_vals = self.wavenumbers
+        else:
+            raise DataFormattingError(f'Invalid x_type: {x_type}')
+
+        y_unit = 'cm mol^-1 eV^-1'
+        y_label = r'$\epsilon$ (cm$^\mathregular{-1}$ mol$^\mathregular{-1}$ L)'  # noqa
+
+        # Create grid for spectrum
+        x_grid = np.linspace(x_min, x_max, num_points)
+        spectrum = np.zeros_like(x_grid)
+
+        # Conversion from oscillator strength to napierian integrated
+        # absorption coefficient
+        # This is the value of A for a harmonically oscillating electron
+        A_elec = 2.31E8
+        #
+        A_logs = [fosc * A_elec for fosc in self.osc_strengths]
+
+        ls_func = {
+            'gaussian': ut.gaussian,
+            'lorentzian': ut.lorentzian
+        }
+
+        # Spectrum as sum of signals in given unit
+        y_vals = np.sum([
+            ls_func[lineshape](x_grid, fwhm, x_value, A_log)
+            for x_value, A_log in zip(x_vals, A_logs)
+        ], axis=0)
+
+        # Transform y values into epsilon in cm^-1 mol^-1 L
+        if x_type == 'energy':
+            y_vals /= const.EV_TO_WAVENUMBER
+        elif x_type == 'wavelength':
+            # calc x grid in wavenumbers
+            xgwn = 1E7 / x_grid
+            # Calculate jacobian for non linear transformation
+            jacobian = (1E7 / xgwn**2)  # d(nm)/d(cm^-1)
+            # obtain y values in wavenumbers
+            y_vals = y_vals * jacobian
+
+        spectrum = AbsorptionSpectrum(
+            x_grid=x_grid,
+            x_unit=x_unit,
+            x_label=x_label,
+            y_unit=y_unit,
+            y_label=y_label,
+            y_values=y_vals,
+            fwhm=fwhm,
+            comment=comment
+        )
+
+        self.spectrum = spectrum
+
+        return

orto/extractor.py

@@ -8,6 +8,7 @@ import pandas as pd
 from io import StringIO
 import pathlib
 import copy
+from abc import abstractmethod
 
 from .exceptions import DataFormattingError
 from . import constants as const
@@ -1313,12 +1314,26 @@ class HessianExtractor(extto.BetweenExtractor):
         return _ext.data
 
 
-class AbsorptionElectricDipoleExtractor(extto.BetweenExtractor):
+class AbsorptionExtractor(extto.BetweenExtractor):
+
+    @property
+    @abstractmethod
+    def OPERATOR_TYPE() -> bytes:
+        '''
+        Name of operator type being extracted, e.g. 'Electric Dipole'
+        '''
+        raise NotImplementedError
+
+
+class AbsorptionElectricDipoleExtractor(AbsorptionExtractor):
     '''
     Extracts ABSORPTION SPECTRUM VIA TRANSITION ELECTRIC DIPOLE MOMENTS table\n
     from ORCA output file for versions newer than 6.
     '''
 
+    #: Operator Type
+    OPERATOR_TYPE = 'Electric Dipole'
+
     # Regex Start Pattern
     START_PATTERN = rb'(?<=ABSORPTION SPECTRUM VIA TRANSITION ELECTRIC DIPOLE MOMENTS\s[\S\s]{408}\s)' # noqa
 
@@ -1408,6 +1423,9 @@ class AbsorptionVelocityDipoleExtractor(AbsorptionElectricDipoleExtractor):
     from ORCA output file for versions newer than 6.
     '''
 
+    #: Operator Type
+    OPERATOR_TYPE = 'Electric Dipole (Velocity)'
+
     # Regex Start Pattern
     START_PATTERN = rb'(?<=ABSORPTION SPECTRUM VIA TRANSITION VELOCITY DIPOLE MOMENTS\s[\S\s]{408}\s)' # noqa
 
@@ -1421,8 +1439,11 @@ class AbsorptionSemiClassicalDipoleExtractor(AbsorptionElectricDipoleExtractor):
     from ORCA output file for versions newer than 6.
     '''
 
+    #: Operator Type
+    OPERATOR_TYPE = 'Semi-Classical'
+
     # Regex Start Pattern
-    START_PATTERN = rb'(?<=ABSORPTION SPECTRUM VIA FULL SEMI-CLASSICAL FORMULATION\s[\S\s]{408}\s)' # noqa
+    START_PATTERN = rb'(?<=ABSORPTION SPECTRUM VIA FULL SEMI-CLASSICAL FORMULATION\s[\S\s]{4}-{77}[\S\s]{206}\s)' # noqa
 
     # Regex End Pattern
     END_PATTERN = rb'(?=-{77})'
@@ -1464,6 +1485,10 @@ class AbsorptionSemiClassicalDipoleExtractor(AbsorptionElectricDipoleExtractor):
         result = np.asarray(result, dtype=str).T
 
         fresult = result[1:].astype(float)
+        if not len(result):
+            raise ValueError(
+                'No data found in the block. Please check the output file.'
+            )
 
         data = {
             'state': result[0].tolist(),
@@ -1476,12 +1501,15 @@ class AbsorptionSemiClassicalDipoleExtractor(AbsorptionElectricDipoleExtractor):
         return data
 
 
-class OldAbsorptionElectricDipoleExtractor(extto.BetweenExtractor):
+class OldAbsorptionElectricDipoleExtractor(AbsorptionExtractor):
     '''
     Extracts ABSORPTION SPECTRUM VIA TRANSITION ELECTRIC DIPOLE MOMENTS table
     from ORCA output file for versions older than 6.
     '''
 
+    #: Operator Type
+    OPERATOR_TYPE = 'Electric Dipole (Old)'
+
     # Regex Start Pattern
     START_PATTERN = rb'(?<=ABSORPTION SPECTRUM VIA TRANSITION ELECTRIC DIPOLE MOMENTS\s[\S\s]{311}\s)' # noqa
 
@@ -1495,6 +1523,7 @@ class OldAbsorptionElectricDipoleExtractor(extto.BetweenExtractor):
         A dictionary with keys:\n
             state\n
             energy (cm^-1)\n
+            energy (ev)\n
             wavelength (nm)\n
             fosc\n
             t2 (a.u.^2)\n
@@ -1529,6 +1558,7 @@ class OldAbsorptionElectricDipoleExtractor(extto.BetweenExtractor):
 
         data = {
             'state': result[0].tolist(),
+            'energy (ev)': list(result[1] / const.EV_TO_WAVENUMBER),
             'energy (cm^-1)': result[1].tolist(),
             'wavelength (nm)': result[2].tolist(),
             'fosc': result[3].tolist(),
@@ -1562,11 +1592,105 @@ class OldAbsorptionElectricDipoleExtractor(extto.BetweenExtractor):
         return _ext.data
 
 
+class XASElectricDipoleExtractor(AbsorptionExtractor):
+    '''
+    Extracts XAS SPECTRUM VIA TRANSITION ELECTRIC DIPOLE MOMENTS table\n
+    from ORCA output file for versions newer than 6.
+    '''
+
+    #: Operator Type
+    OPERATOR_TYPE = 'Electric Dipole'
+
+    # Regex Start Pattern
+    START_PATTERN = rb'(?<=ABSORPTION SPECTRUM VIA TRANSITION ELECTRIC DIPOLE MOMENTS\s[\S\s]{408}\s)' # noqa
+
+    # Regex End Pattern
+    END_PATTERN = rb'(?=-{77})'
+
+    @property
+    def data(self) -> dict[str, list[str | float]]:
+        '''
+        Absorption spectrum data:\n
+        A dictionary with keys:\n
+            transition\n
+            energy (cm^-1)\n
+            energy (ev)\n
+            wavelength (nm)\n
+            fosc\n
+            d2 (a.u.^2)\n
+            dx (a.u.)\n
+            dy (a.u.)\n
+            dz (a.u.)\n
+        All values are list[float], but 'transition' entries are list[str]
+        '''
+        return self._data
+
+    @staticmethod
+    def _process_block(block: str) -> dict[str, list[int | float]]: # noqa
+        '''
+        Converts single block into data entries described in self.data
+
+        Parameters
+        ----------
+        block: str
+            String block extracted from file
+
+        Returns
+        -------
+        dict[str, list[float]]
+        '''
+
+        result = re.findall(
+            r'\s+(\d+[A-Za-z]*-\d*[A-Za-z]\s+->\s+\d+[A-Za-z]*-\d*[A-Za-z])\s+(\d+\.\d+)\s+(\d+\.\d+)\s+(\d+\.\d+)\s+(\d+\.\d+)\s+(\d\.\d{5})\s+(-*\d\.\d{5})\s+(-*\d\.\d{5})\s+(-*\d\.\d{5})', # noqa
+            block
+        )
+
+        result = np.asarray(result, dtype=str).T
+
+        fresult = result[1:].astype(float)
+
+        data = {
+            'state': result[0].tolist(),
+            'energy (ev)': fresult[0].tolist(),
+            'energy (cm^-1)': fresult[1].tolist(),
+            'wavelength (nm)': fresult[2].tolist(),
+            'fosc': fresult[3].tolist(),
+            't2 (a.u.^2)': fresult[4].tolist(),
+            'tx (a.u).': fresult[5].tolist(),
+            'ty (a.u).': fresult[6].tolist(),
+            'tz (a.u).': fresult[7].tolist()
+        }
+
+        return data
+
+    @classmethod
+    def extract(cls, file_name: str | pathlib.Path) -> dict[str, list[int | float]]: # noqa
+        '''
+        Convenience method which instantiates class, extracts blocks, and
+        returns processed datasets
+
+        Parameters
+        ----------
+        file_name: str | pathlib.Path
+            File to parse
+
+        Returns
+        -------
+        dict[str, list[int | float]]
+            Each entry contains processed data, as defined in cls.data
+        '''
+        _ext = cls()
+        _ext(file_name, process=True)
+        return _ext.data
+
+
 class OldAbsorptionVelocityDipoleExtractor(OldAbsorptionElectricDipoleExtractor): # noqa
     '''
     Extracts ABSORPTION SPECTRUM VIA TRANSITION VELOCITY DIPOLE MOMENTS table
     from ORCA output file for versions older than 6.
     '''
+    #: Operator Type
+    OPERATOR_TYPE = 'Electric Dipole (Velocity, Old)'
 
     # Regex Start Pattern
     START_PATTERN = rb'(?<=ABSORPTION SPECTRUM VIA TRANSITION VELOCITY DIPOLE MOMENTS\s[\S\s]{311}\s)' # noqa
@@ -1575,6 +1699,89 @@ class OldAbsorptionVelocityDipoleExtractor(OldAbsorptionElectricDipoleExtractor)
     END_PATTERN = rb'(?=-{77})'
 
 
+class XESElectricDipoleExtractor(AbsorptionElectricDipoleExtractor):
+    '''
+    Extracts X-RAY EMISSION SPECTRUM VIA TRANSITION ELECTRIC DIPOLE MOMENTS table\n # noqa
+    from ORCA output file for versions newer than 6.
+    '''
+
+    #: Operator Type
+    OPERATOR_TYPE = 'Electric Dipole'
+
+    # Regex Start Pattern
+    START_PATTERN = rb'(?<=              X-RAY   EMISSION SPECTRUM VIA TRANSITION VELOCITY DIPOLE MOMENTS\s[\S\s]{408}\s)' # noqa
+
+    # Regex End Pattern
+    END_PATTERN = rb'(?=-{77})'
+
+
+class XESVelocityDipoleExtractor(AbsorptionElectricDipoleExtractor):
+    '''
+    Extracts X-RAY EMISSION SPECTRUM VIA TRANSITION VELOCITY DIPOLE MOMENTS table\n # noqa
+    from ORCA output file for versions newer than 6.
+    '''
+    #: Operator Type
+    OPERATOR_TYPE = 'Electric Dipole (Velocity)'
+
+    # Regex Start Pattern
+    START_PATTERN = rb'(?<=              X-RAY   EMISSION SPECTRUM VIA TRANSITION VELOCITY DIPOLE MOMENTS\s[\S\s]{415}\s)' # noqa
+
+
+class SOXESElectricDipoleExtractor(XESElectricDipoleExtractor):
+    '''
+    Extracts SPIN-ORBIT X-RAY EMISSION SPECTRUM VIA TRANSITION ELECTRIC DIPOLE MOMENTS table\n # noqa
+    from ORCA output file for versions newer than 6.
+    '''
+
+    #: Operator Type
+    OPERATOR_TYPE = 'Electric Dipole'
+
+    # Regex Start Pattern
+    START_PATTERN = rb'(?<=SPIN-ORBIT X-RAY   EMISSION SPECTRUM VIA TRANSITION ELECTRIC DIPOLE MOMENTS\s[\S\s\(\)]{415}\s)' # noqa
+
+
+class SOXESVelocityDipoleExtractor(XESVelocityDipoleExtractor):
+    '''
+    Extracts SPIN-ORBIT X-RAY EMISSION SPECTRUM VIA TRANSITION VELOCITY DIPOLE MOMENTS table\n # noqa
+    from ORCA output file for versions newer than 6.
+    ''' 
+
+    #: Operator Type
+    OPERATOR_TYPE = 'Electric Dipole (Velocity)'
+
+    # Regex Start Pattern
+    START_PATTERN = rb'(?<=   SPIN-ORBIT X-RAY   EMISSION SPECTRUM VIA TRANSITION VELOCITY DIPOLE MOMENTS\s[\S\s]{415}\s)' # noqa
+
+    # Regex End Pattern
+    END_PATTERN = rb'(?=-{104})'
+
+
+class XESSemiClassicalDipoleExtractor(AbsorptionSemiClassicalDipoleExtractor):
+    '''
+    Extracts X-RAY EMISSION SPECTRUM VIA FULL SEMI-CLASSICAL FORMULATION table\n # noqa
+    from ORCA output file for versions newer than 6.
+    '''
+
+    #: Operator Type
+    OPERATOR_TYPE = 'Semi-Classical'
+
+    # Regex Start Pattern
+    START_PATTERN = rb'(?<=              X-RAY   EMISSION SPECTRUM VIA FULL SEMI-CLASSICAL FORMULATION\s[\S\s]{408}\s)' # noqa
+
+
+class SOXESSemiClassicalDipoleExtractor(AbsorptionSemiClassicalDipoleExtractor): # noqa
+    '''
+    Extracts SPIN-ORBIT X-RAY EMISSION SPECTRUM VIA TRANSITION VELOCITY DIPOLE MOMENTS table\n # noqa
+    from ORCA output file for versions newer than 6.
+    '''
+
+    #: Operator Type
+    OPERATOR_TYPE = 'Semi-Classical'
+
+    # Regex Start Pattern
+    START_PATTERN = rb'(?<=   SPIN-ORBIT X-RAY   EMISSION SPECTRUM VIA FULL SEMI-CLASSICAL FORMULATION\s[\S\s]{408}\s)' # noqa
+
+
 class HessNameInputExtractor(extto.LineExtractor):
     '''
     Extracts Hessian file name from %mtr block of input file