ensemble-analyzer 1.2__tar.gz → 1.2.1__tar.gz

{ensemble_analyzer-1.2/src/ensemble_analyzer.egg-info → ensemble_analyzer-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ensemble-analyzer
-Version: 1.2
+Version: 1.2.1
 Summary: Automatic Refinement of Conformational Ensemble
 Author-email: Andrea Pellegrini <andrea.pellegrini15@unibo.it>, Paolo Righi <paolo.righi@unibo.it>, Andrea Mazzanti <andrea.mazzanti@unibo.it>, Michele Mancinelli <michele.mancinelli@unibo.it>
 Maintainer-email: Andrea Pellegrini <andrea.pellegrini15@unibo.it>, Paolo Righi <paolo.righi@unibo.it>

{ensemble_analyzer-1.2 → ensemble_analyzer-1.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ensemble-analyzer"
-version = '1.2'
+version = '1.2.1'
 description = "Automatic Refinement of Conformational Ensemble"
 readme = "README.md"
 license = { text = "MIT" }

{ensemble_analyzer-1.2 → ensemble_analyzer-1.2.1}/src/ensemble_analyzer/parsers/gaussian.py

@@ -1,6 +1,10 @@
 
 
 from ensemble_analyzer.parsers.base import BaseParser, register_parser
+from ensemble_analyzer.parsers.vibrations import (
+    gaussian_get_freq, gaussian_get_ir_intensities, gaussian_get_normal_modes,
+    gaussian_align_normal_modes, to_displacements,
+)
 
 import re
 import numpy as np
@@ -29,6 +33,12 @@ class GaussianParser(BaseParser):
         "start_spec": "Excited states from",
         "e_freq": "\n\n\n",
         "idx_freq": 1,  # index for frequency in frequency table
+        # frequency section (same keys as frogchem regex_gaussian)
+        "freq_section": "Harmonic frequencies (cm**-1), IR intensities (KM/Mole), Raman scattering",
+        "freq_end": "\n\n\n",
+        "freq_pattern": r'Frequencies\s*--\s*((?:[+-]?\d+\.\d+\s*)+)',
+        "ir_pattern": r'IR Inten\s*--\s*((?:[+-]?\d+\.\d+\s*)+)',
+        "rot_pattern": r'Rot\. str\.\s*--\s*((?:[+-]?\d+\.\d+\s*)+)',
         "opt_done": "Optimization completed",
         "geom_start": """Input orientation:                          
  ---------------------------------------------------------------------
@@ -59,68 +69,50 @@ class GaussianParser(BaseParser):
     
     def parse_freq(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
         """
-        Parse vibrational frequencies, IR and VCD intensities.
+        Parse vibrational frequencies, IR and VCD intensities (FROGChem parser).
 
         Returns:
             Tuple: (Frequencies array, IR spectrum array, VCD spectrum array).
         """
 
-        if not self.regex['s_freq'] in self.fl: 
+        if not self.regex['freq_section'] in self.fl:
             return np.array([]), np.zeros(shape=(1,2)), np.zeros(shape=(1,2))
-        
-        fl = self.get_filtered_text(start=self.regex['s_freq'], end=self.regex['e_freq'])
-        freq_pattern = re.compile(r'Frequencies\s*--\s*((?:[+-]?\d+\.\d+\s*)+)')
-        ir_pattern   = re.compile(r'IR Inten\s*--\s*((?:[+-]?\d+\.\d+\s*)+)')
-        rot_pattern  = re.compile(r'Rot\. str\.\s*--\s*((?:[+-]?\d+\.\d+\s*)+)')
 
-        # extract and flatten into a single list of floats
-        frequencies = np.array([float(x) for m in freq_pattern.findall(fl) for x in m.split()])
-        ir_inten    = np.array([float(x) for m in ir_pattern.findall(fl) for x in m.split()])
-        rot_str     = np.array([float(x) for m in rot_pattern.findall(fl) for x in m.split()])
+        frequencies = gaussian_get_freq(self.fl, self.regex)
+        ir = gaussian_get_ir_intensities(self.fl, self.regex)
 
-        return frequencies, np.column_stack((frequencies,ir_inten)), np.column_stack((frequencies,rot_str))
+        # VCD: rotational strengths, only printed with freq=VCD
+        fl = self.get_filtered_text(start=self.regex['freq_section'], end=self.regex['freq_end'])
+        rot_str = np.array([float(x) for m in re.findall(self.regex['rot_pattern'], fl) for x in m.split()])
+        if len(rot_str) == len(frequencies) and len(rot_str) > 0:
+            vcd = np.column_stack((frequencies, rot_str))
+        else:
+            vcd = np.zeros(shape=(1, 2))
+
+        return frequencies, ir, vcd
 
     def parse_normal_modes(self, n_atoms: int) -> np.ndarray:
-        if self.regex['s_freq'] not in self.fl:
-            return np.empty((0, n_atoms, 3))
-        fl = self.get_filtered_text(start=self.regex['s_freq'], end=self.regex['e_freq'])
-        parts = fl.split('Frequencies --')
-        if len(parts) < 2:
-            return np.empty((0, n_atoms, 3))
-        all_modes = []
-        for chunk in parts[1:]:
-            lines = chunk.split('\n')
-            freq_vals = re.findall(r'[-+]?\d+\.\d+(?:[eE][+-]?\d+)?', lines[0])
-            n_freq = min(len(freq_vals), 3)
-            if n_freq == 0:
-                continue
-            idx = 1
-            while idx < len(lines):
-                line = lines[idx].strip()
-                if not line:
-                    idx += 1
-                    continue
-                if re.match(r'^\s*\d+\s+\d+', line):
-                    break
-                idx += 1
-            mode_disps = np.zeros((n_freq, n_atoms, 3))
-            for i in range(idx, min(idx + n_atoms, len(lines))):
-                line = lines[i].strip()
-                if not line or not re.match(r'^\d+\s+\d+', line):
-                    break
-                parts_line = line.split()
-                if len(parts_line) < 2 + 3 * n_freq:
-                    continue
-                atom_idx = int(parts_line[0]) - 1
-                vals = [float(x) for x in parts_line[2:]]
-                for k in range(n_freq):
-                    mode_disps[k, atom_idx, 0] = vals[3 * k]
-                    mode_disps[k, atom_idx, 1] = vals[3 * k + 1]
-                    mode_disps[k, atom_idx, 2] = vals[3 * k + 2]
-            all_modes.append(mode_disps)
-        if not all_modes:
-            return np.empty((0, n_atoms, 3))
-        return np.vstack(all_modes)
+        """Cartesian displacement vectors of the vibrational modes (FROGChem parser).
+
+        Gaussian prints them in the standard orientation; they are rotated onto the input
+        orientation, i.e. the frame of parse_geom.
+
+        Returns:
+            np.ndarray: (n_modes, n_atoms, 3), same order as the frequencies of parse_freq.
+            Empty (0, n_atoms, 3) array when the frequency section is missing.
+        """
+        empty = np.empty((0, n_atoms, 3))
+        try:
+            matrix = gaussian_get_normal_modes(self.fl, self.regex, N=3 * n_atoms)
+        except ValueError:
+            return empty
+        except Exception as err:
+            self.log.warning(f"Normal modes could not be parsed: {err}")
+            return empty
+        if matrix.shape[1] == 0:
+            return empty
+        matrix = gaussian_align_normal_modes(self.fl, matrix)
+        return to_displacements(matrix, n_atoms)
 
     def parse_tddft(self) -> Tuple[np.ndarray, np.ndarray]:
         """

{ensemble_analyzer-1.2 → ensemble_analyzer-1.2.1}/src/ensemble_analyzer/parsers/orca.py

@@ -1,6 +1,7 @@
 
 from ensemble_analyzer.parsers.base import BaseParser, register_parser
 from ensemble_analyzer.constants import FACTOR_EV_CM_1
+from ensemble_analyzer.parsers.vibrations import orca_get_freq, orca_get_normal_modes, to_displacements
 
 import re
 import numpy as np
@@ -50,6 +51,9 @@ class OrcaParser(BaseParser):
         "s_freq": "VIBRATIONAL FREQUENCIES",
         "e_freq": "------------",
         "idx_freq": 1,  # index for frequency in frequency table
+        # frequency / normal-mode blocks (same keys as frogchem regex_ORCA)
+        "frequency": r'VIBRATIONAL FREQUENCIES([\S\s]*?)\n\n\n',
+        "normal_modes": r'NORMAL MODES([\S\s]*?)\n\n\n',
         "opt_done": "THE OPTIMIZATION HAS CONVERGED",
         "geom_start": """CARTESIAN COORDINATES (ANGSTROEM)
 ---------------------------------""",
@@ -88,6 +92,9 @@ State  Energy     Wavelength     R         MX        MY        MZ
         "s_freq": "VIBRATIONAL FREQUENCIES",
         "e_freq": "------------",
         "idx_freq": 1,  # index for frequency in frequency table
+        # frequency / normal-mode blocks (same keys as frogchem regex_ORCA)
+        "frequency": r'VIBRATIONAL FREQUENCIES([\S\s]*?)\n\n\n',
+        "normal_modes": r'NORMAL MODES([\S\s]*?)\n\n\n',
         "opt_done": "THE OPTIMIZATION HAS CONVERGED",
         "geom_start": """CARTESIAN COORDINATES (ANGSTROEM)
 ---------------------------------""",
@@ -136,13 +143,9 @@ State  Energy     Wavelength     R         MX        MY        MZ
         if not self.regex['s_freq'] in self.fl: 
             return np.array([]), np.zeros(shape=(1,2)), np.zeros(shape=(1,2))
 
-        fl = self.get_filtered_text(self.regex['s_freq'], end='\n\n\n')
-    
-        pattern = r'(?:\d+:)\s*(-?\d+.\d*)'
-        # freq
-        freq = np.array(re.findall(pattern, fl, flags=re.MULTILINE), dtype=float)
-        self._freq_mask = freq != 0
-        freq = freq[self._freq_mask]
+        # freq (FROGChem parser): translations/rotations are printed as zeros and dropped here
+        freq = self._all_freq()
+        freq = freq[freq != 0]
 
         # IR
         if self.regex['s_IR'] not in self.fl:
@@ -160,58 +163,33 @@ State  Energy     Wavelength     R         MX        MY        MZ
 
         return freq, ir, vcd
 
+    def _all_freq(self) -> np.ndarray:
+        """All ORCA frequencies (cm-1), translations/rotations included as zeros."""
+        if not re.search(self.regex['frequency'], self.fl):
+            return np.array([])
+        return orca_get_freq(self.fl, self.regex)[1]
+
     def parse_normal_modes(self, n_atoms: int) -> np.ndarray:
-        if "NORMAL MODES" not in self.fl:
-            return np.empty((0, n_atoms, 3))
+        """Cartesian displacement vectors of the vibrational modes (FROGChem parser).
+
+        Returns:
+            np.ndarray: (n_modes, n_atoms, 3), same order as the frequencies of parse_freq
+            (translation/rotation modes, i.e. zero frequencies, are dropped). Empty
+            (0, n_atoms, 3) array when the NORMAL MODES block is missing.
+        """
+        empty = np.empty((0, n_atoms, 3))
         try:
-            block = self.fl.split("NORMAL MODES")[-1].split("\n\n\n")[0]
-            lines = block.split("\n")
-            n_total = 3 * n_atoms
-            max_col = -1
-            for line in lines:
-                stripped = line.strip()
-                if not stripped or stripped.startswith("-"):
-                    continue
-                header_match = re.match(r'^\s*(\d+(?:\s+\d+)*)\s*$', stripped)
-                if header_match:
-                    cols = [int(x) for x in header_match.group(1).split()]
-                    if cols and cols[-1] > max_col:
-                        max_col = cols[-1]
-            if max_col < 0:
-                return np.empty((0, n_atoms, 3))
-            matrix = np.zeros((n_total, max_col + 1))
-            current_columns = []
-            for line in lines:
-                stripped = line.strip()
-                if not stripped or stripped.startswith("-"):
-                    continue
-                header_match = re.match(r'^\s*(\d+(?:\s+\d+)*)\s*$', stripped)
-                if header_match:
-                    current_columns = [int(x) for x in header_match.group(1).split()]
-                    continue
-                data_match = re.match(
-                    r'^\s*(\d+)\s+((?:[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?\s*)+)', stripped
-                )
-                if data_match and current_columns:
-                    row_idx = int(data_match.group(1))
-                    coeff_str = data_match.group(2)
-                    coeffs = [float(c) for c in re.findall(
-                        r'[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?', coeff_str
-                    )]
-                    for i, c in enumerate(coeffs):
-                        if i < len(current_columns) and row_idx < n_total:
-                            col = current_columns[i]
-                            matrix[row_idx, col] = c
-            n_modes = matrix.shape[1]
-            all_modes = np.zeros((n_modes, n_atoms, 3))
-            for mode_idx in range(n_modes):
-                vec = matrix[:n_total, mode_idx]
-                all_modes[mode_idx] = vec.reshape(n_atoms, 3)
-            if hasattr(self, '_freq_mask') and self._freq_mask is not None and len(self._freq_mask) == len(all_modes):
-                all_modes = all_modes[self._freq_mask]
-            return all_modes
-        except Exception:
-            return np.empty((0, n_atoms, 3))
+            matrix = orca_get_normal_modes(self.fl, self.regex, N=3 * n_atoms)
+        except ValueError:
+            return empty
+        except Exception as err:
+            self.log.warning(f"Normal modes could not be parsed: {err}")
+            return empty
+        modes = to_displacements(matrix, n_atoms)
+        freq = self._all_freq()
+        if len(freq) == len(modes):
+            modes = modes[freq != 0]
+        return modes
 
     def parse_tddft(self) -> Tuple[np.ndarray, np.ndarray]:
         """

ensemble_analyzer-1.2.1/src/ensemble_analyzer/parsers/vibrations.py

@@ -0,0 +1,228 @@
+"""Vibrational-analysis parsers shared with FROGChem (frogchem).
+
+COPY of the FROGChem frequency parsers -- keep in sync with:
+    frogchem/orca_parser/hessian.py      get_freq, get_normal_modes, to_displacements
+    frogchem/gaussian_parser/hessian.py  get_freq, get_ir_intensities, get_normal_modes,
+                                         align_normal_modes (+ private helpers)
+Functions are renamed with an ``orca_`` / ``gaussian_`` prefix; bodies are identical.
+They take the whole output text ``fl`` and a regex dict ``reg`` with the FROGChem keys.
+
+Layout of the normal modes returned by ``*_get_normal_modes``: (3N, n_modes), rows
+x0, y0, z0, x1, ...; ``to_displacements`` turns it into (n_modes, N, 3) displacement vectors.
+"""
+import re
+import logging
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# ORCA  (frogchem/orca_parser/hessian.py)
+# ---------------------------------------------------------------------------
+
+def orca_get_freq(fl, reg):
+    """Mode numbers and frequencies (cm-1) of the last VIBRATIONAL FREQUENCIES block.
+
+    Translations/rotations are included as zero frequencies, imaginary modes are negative.
+
+    NOTE: copied verbatim in ensemble_analyzer/parsers/vibrations.py (orca_get_freq).
+    """
+    f_ = re.findall(reg['frequency'], fl)[-1]
+    match = np.array(re.findall(r'(\d+):\s+(-?[\d.]+)\s+cm\*\*-1*', f_), dtype=np.float64)
+    numbers_mode, freq = match[:, 0].astype(int), match[:, 1]
+    return numbers_mode, freq.astype(np.float64)
+
+
+def orca_get_normal_modes(fl, reg, N):
+    """Cartesian displacement vectors of the NORMAL MODES block.
+
+    Returns an (N, n_modes) matrix: N = 3 * n_atoms rows (x0, y0, z0, x1, ...), one column per
+    mode as numbered by ORCA (translations/rotations included, so n_modes = N for a full Hessian).
+    The number of columns is read from the block headers.
+
+    NOTE: copied verbatim in ensemble_analyzer/parsers/vibrations.py (orca_get_normal_modes).
+    Keep the two copies in sync.
+    """
+    matches = re.findall(reg['normal_modes'], fl, re.DOTALL)
+    if not matches:
+        raise ValueError("Pattern 'normal_modes' non trovato nel file")
+
+    target_text = matches[-1].split('\n\n')[-1]
+    header_pattern = r'^\s*(\d+(?:\s+\d+)*)\s*$'
+    data_pattern = r'^\s*(\d+)\s+((?:[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?\s*)+)'
+
+    lines = target_text.strip().split('\n')
+    n_cols = max(
+        (int(line.split()[-1]) + 1 for line in lines if re.match(header_pattern, line.strip())),
+        default=N,
+    )
+    matrix = np.zeros((N, n_cols))
+    current_columns = []
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+
+        header_match = re.match(header_pattern, line)
+        if header_match:
+            current_columns = [int(x) for x in header_match.group(1).split()]
+            continue
+
+        data_match = re.match(data_pattern, line)
+        if data_match and current_columns:
+            try:
+                row_idx = int(data_match.group(1))
+                coefficients_str = data_match.group(2)
+                coefficients = re.findall(r'[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?', coefficients_str)
+                coefficients = [float(c) for c in coefficients]
+
+                for i, coeff in enumerate(coefficients):
+                    if i < len(current_columns) and row_idx < N and current_columns[i] < n_cols:
+                        matrix[row_idx, current_columns[i]] = coeff
+            except (ValueError, IndexError) as e:
+                logger.warning("Errore processando riga dati '%s': %s", line, e)
+                continue
+
+    return matrix
+
+
+def to_displacements(normal_modes, n_atoms):
+    """(3N, n_modes) normal-mode matrix -> (n_modes, n_atoms, 3) displacement vectors.
+
+    NOTE: copied verbatim in ensemble_analyzer/parsers/vibrations.py.
+    """
+    normal_modes = np.asarray(normal_modes, dtype=np.float64)
+    return np.ascontiguousarray(normal_modes[:3 * n_atoms].T).reshape(-1, n_atoms, 3)
+
+
+# ---------------------------------------------------------------------------
+# Gaussian  (frogchem/gaussian_parser/hessian.py)
+# ---------------------------------------------------------------------------
+
+_ORIENT_ROW = re.compile(r'^\s*\d+\s+(\d+)\s+(?:-?\d+\s+)?(-?\d+\.\d+)\s+(-?\d+\.\d+)\s+(-?\d+\.\d+)\s*$')
+_MODE_ROW = re.compile(r'^\s*(\d+)\s+(\d+)((?:\s+[-+]?\d+\.\d+)+)\s*$')
+_FLOAT = re.compile(r'[-+]?\d+\.\d+')
+
+
+def _freq_block(fl, reg):
+    # last frequency section (with freq=HPModes the standard 3-column section is printed last)
+    return fl.split(reg['freq_section'])[-1].split(reg['freq_end'])[0]
+
+
+def gaussian_get_freq(fl, reg):
+    if reg['freq_section'] not in fl:
+        return np.array([])
+
+    block = _freq_block(fl, reg)
+    freq = np.array([float(x) for m in re.findall(reg['freq_pattern'], block) for x in m.split()])
+    return freq
+
+
+def gaussian_get_ir_intensities(fl, reg):
+    if reg['freq_section'] not in fl:
+        return np.zeros(shape=(1, 2))
+
+    block = _freq_block(fl, reg)
+    freq = np.array([float(x) for m in re.findall(reg['freq_pattern'], block) for x in m.split()])
+    ir = np.array([float(x) for m in re.findall(reg['ir_pattern'], block) for x in m.split()])
+    if len(freq) == 0 or len(ir) == 0:
+        return np.zeros(shape=(1, 2))
+    return np.column_stack((freq, ir))
+
+
+def gaussian_get_normal_modes(fl, reg, N):
+    """Cartesian displacement vectors of the normal modes, in Gaussian's *standard orientation*.
+
+    Returns an (N, n_modes) matrix, N = 3 * n_atoms rows (x0, y0, z0, x1, ...), one column per
+    vibrational mode in the order of get_freq (same layout as orca_parser.hessian.get_normal_modes,
+    but Gaussian prints no translations/rotations). Read from the standard 3-modes-per-block table
+    ('Atom  AN  X Y Z ...'). Use align_normal_modes to express them in the frame of the parsed
+    geometry. Raises ValueError when the file has no frequency section.
+    """
+    if reg['freq_section'] not in fl:
+        raise ValueError("Frequency section not found")
+
+    columns = []        # one (N,) vector per mode
+    block_modes = 0     # modes in the current block (from its 'Frequencies --' line)
+    in_table = False
+    for line in _freq_block(fl, reg).splitlines():
+        freq_match = re.search(reg['freq_pattern'], line)
+        if freq_match:
+            block_modes = len(freq_match.group(1).split())
+            block = [np.zeros(N) for _ in range(block_modes)]
+            columns.extend(block)
+            in_table = False
+            continue
+        if block_modes and line.split()[:2] == ['Atom', 'AN']:
+            in_table = True
+            continue
+        if not in_table:
+            continue
+        row = _MODE_ROW.match(line)
+        if row is None:
+            in_table = False
+            continue
+        atom = int(row.group(1)) - 1
+        values = [float(x) for x in _FLOAT.findall(row.group(3))]
+        if len(values) != 3 * block_modes or 3 * atom + 2 >= N:
+            logger.warning("Skipping malformed normal-mode row: %r", line)
+            continue
+        for k in range(block_modes):
+            block[k][3 * atom:3 * atom + 3] = values[3 * k:3 * k + 3]
+
+    if not columns:
+        return np.zeros((N, 0))
+    return np.column_stack(columns)
+
+
+def _last_orientation(fl, header):
+    """Coordinates (Å) of the last orientation table with the given header, or None."""
+    if header not in fl:
+        return None
+    coords, dashes = [], 0
+    for line in fl.split(header)[-1].splitlines():
+        if line.strip().startswith('---'):
+            dashes += 1
+            if dashes >= 3:
+                break
+            continue
+        if dashes == 2:
+            match = _ORIENT_ROW.match(line)
+            if not match:
+                break
+            coords.append([float(match.group(i)) for i in (2, 3, 4)])
+    return np.array(coords, dtype=float) if coords else None
+
+
+def _kabsch(P, Q):
+    """Proper rotation R and RMSD (Å) such that (P - <P>) @ R ≈ (Q - <Q>)."""
+    Pc, Qc = P - P.mean(axis=0), Q - Q.mean(axis=0)
+    U, _, Vt = np.linalg.svd(Pc.T @ Qc)
+    d = np.sign(np.linalg.det(U @ Vt))
+    R = U @ np.diag([1.0, 1.0, d]) @ Vt
+    rmsd = float(np.sqrt(np.mean(np.sum((Pc @ R - Qc) ** 2, axis=1))))
+    return R, rmsd
+
+
+def gaussian_align_normal_modes(fl, normal_modes, target='Input orientation:', source='Standard orientation:', tol=1e-2):
+    """Rotate (3N, n_modes) normal modes from the standard orientation to the `target` frame.
+
+    Gaussian prints the normal coordinates in the standard orientation, while the parsers return
+    the input-orientation geometry when it is printed. The rotation is the Kabsch fit of the last
+    standard-orientation table onto the last `target` table; when one of the two tables is
+    missing (e.g. NoSymm jobs print only the input orientation) the modes are returned unchanged.
+    """
+    std = _last_orientation(fl, source)
+    tgt = _last_orientation(fl, target)
+    if std is None or tgt is None or std.shape != tgt.shape or normal_modes.shape[0] != std.size:
+        return normal_modes
+    R, rmsd = _kabsch(std, tgt)
+    if rmsd > tol:
+        logger.warning("Standard and input orientations do not superimpose (RMSD %.3g Å): "
+                       "normal modes left in the standard orientation", rmsd)
+        return normal_modes
+    n_atoms = std.shape[0]
+    disp = normal_modes.T.reshape(-1, n_atoms, 3) @ R
+    return np.ascontiguousarray(disp.reshape(-1, 3 * n_atoms).T)

{ensemble_analyzer-1.2 → ensemble_analyzer-1.2.1/src/ensemble_analyzer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ensemble-analyzer
-Version: 1.2
+Version: 1.2.1
 Summary: Automatic Refinement of Conformational Ensemble
 Author-email: Andrea Pellegrini <andrea.pellegrini15@unibo.it>, Paolo Righi <paolo.righi@unibo.it>, Andrea Mazzanti <andrea.mazzanti@unibo.it>, Michele Mancinelli <michele.mancinelli@unibo.it>
 Maintainer-email: Andrea Pellegrini <andrea.pellegrini15@unibo.it>, Paolo Righi <paolo.righi@unibo.it>

{ensemble_analyzer-1.2 → ensemble_analyzer-1.2.1}/src/ensemble_analyzer.egg-info/SOURCES.txt

@@ -97,6 +97,7 @@ src/ensemble_analyzer/parsers/base.py
 src/ensemble_analyzer/parsers/gaussian.py
 src/ensemble_analyzer/parsers/nwchem.py
 src/ensemble_analyzer/parsers/orca.py
+src/ensemble_analyzer/parsers/vibrations.py
 src/ensemble_analyzer/protocol/__init__.py
 src/ensemble_analyzer/protocol/protocol.py
 src/ensemble_analyzer/protocol/solvent.py