chemparseplot 0.0.2__tar.gz → 0.0.3__tar.gz

{chemparseplot-0.0.2 → chemparseplot-0.0.3}/.gitignore

@@ -1,3 +1,4 @@
+apidocs/*
 ### Generated by gibo (https://github.com/simonwhitaker/gibo)
 ### https://raw.github.com/github/gitignore/4488915eec0b3a45b5c63ead28f286819c0917de/Python.gitignore
 

{chemparseplot-0.0.2 → chemparseplot-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: chemparseplot
-Version: 0.0.2
+Version: 0.0.3
 Summary: Parsers and plotting tools for computational chemistry
 Project-URL: Documentation, https://github.com/HaoZeke/chemparseplot#readme
 Project-URL: Issues, https://github.com/HaoZeke/chemparseplot/issues
@@ -22,16 +22,17 @@ Requires-Dist: numpy>=1.26.2
 Requires-Dist: pint>=0.22
 Provides-Extra: doc
 Requires-Dist: mdit-py-plugins>=0.3.4; extra == 'doc'
-Requires-Dist: myst-nb>=1.0.0; extra == 'doc'
-Requires-Dist: myst-parser>=2.0.0; extra == 'doc'
-Requires-Dist: sphinx-autodoc2>=0.5.0; extra == 'doc'
+Requires-Dist: myst-nb>=1; extra == 'doc'
+Requires-Dist: myst-parser>=2; extra == 'doc'
+Requires-Dist: sphinx-autodoc2>=0.5; extra == 'doc'
 Requires-Dist: sphinx-copybutton>=0.5.2; extra == 'doc'
 Requires-Dist: sphinx-library>=1.1.2; extra == 'doc'
 Requires-Dist: sphinx-sitemap>=2.5.1; extra == 'doc'
 Requires-Dist: sphinx-togglebutton>=0.3.2; extra == 'doc'
 Requires-Dist: sphinx>=7.2.6; extra == 'doc'
-Requires-Dist: sphinxcontrib-apidoc>=0.4.0; extra == 'doc'
+Requires-Dist: sphinxcontrib-apidoc>=0.4; extra == 'doc'
 Provides-Extra: plot
+Requires-Dist: cmcrameri>=1.7; extra == 'plot'
 Requires-Dist: matplotlib>=3.8.2; extra == 'plot'
 Description-Content-Type: text/markdown
 

chemparseplot-0.0.3/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.0.3'
+__version_tuple__ = version_tuple = (0, 0, 3)
+
+__commit_id__ = commit_id = None

chemparseplot-0.0.3/chemparseplot/analyze/dist.py

@@ -0,0 +1,130 @@
+import ase
+import numpy as np
+from ase.data import covalent_radii
+from ase.neighborlist import NeighborList
+from scipy.spatial.distance import cdist
+
+
+def analyze_structure(
+    atoms: ase.Atoms, covalent_scale: float = 1.2
+) -> tuple[np.ndarray, np.ndarray, list[list[int]]]:
+    """
+    Analyzes an ASE Atoms object to calculate the distance matrix, bond matrix,
+    and identify molecular fragments.
+
+    Args:
+        atoms: The ASE Atoms object to analyze.
+        covalent_scale:  A scaling factor applied to the covalent radii to
+            determine the bonding threshold.  A bond is formed if the distance
+            between two atoms is less than or equal to the sum of their
+            covalent radii, multiplied by this factor.
+
+    Returns:
+        A tuple containing:
+        - distance_matrix: A NumPy array representing the pairwise distances
+          between all atoms in the system.
+        - bond_matrix: A NumPy array representing the adjacency matrix of the
+          molecular graph.  bond_matrix[i, j] = 1 if atoms i and j are
+          bonded, and 0 otherwise.
+        - fragments: A list of lists, where each inner list contains the indices
+          of the atoms belonging to a connected fragment.
+    """
+
+    num_atoms = len(atoms)
+
+    # 1. Calculate the distance matrix.
+    distance_matrix = atoms.get_all_distances(
+        mic=True
+    )  # Use minimum image convention (MIC)
+
+    # 2. Calculate the bond matrix.
+    bond_matrix = np.zeros((num_atoms, num_atoms), dtype=int)
+    radii = [covalent_radii[atom.number] for atom in atoms]  # Atomic numbers
+
+    # More efficient with neighborlist
+    neighbor_list = NeighborList(
+        cutoffs=[covalent_scale * r for r in radii],  # Scaled cutoffs
+        skin=0.0,  # No skin, we use the cutoffs directly
+        bothways=True,  # Get both i->j and j->i
+        self_interaction=False,  # No i->i connections
+        primitive=ase.neighborlist.NewPrimitiveNeighborList,
+    )
+    neighbor_list.update(atoms)
+
+    for i in range(num_atoms):
+        indices, offsets = neighbor_list.get_neighbors(i)
+        for j, _ in zip(indices, offsets, strict=False):
+            bond_matrix[i, j] = 1
+
+    # 3. Identify fragments.
+    visited = [False] * num_atoms
+    fragments = []
+
+    def dfs(atom_index: int, current_fragment: list[int]):
+        """Depth-First Search to find connected components."""
+        visited[atom_index] = True
+        current_fragment.append(atom_index)
+        for neighbor_index in range(num_atoms):
+            if (
+                bond_matrix[atom_index, neighbor_index] == 1
+                and not visited[neighbor_index]
+            ):
+                dfs(neighbor_index, current_fragment)
+
+    for i in range(num_atoms):
+        if not visited[i]:
+            new_fragment = []
+            dfs(i, new_fragment)
+            fragments.append(new_fragment)
+
+    # 4. Calculate Centroid Distances and *Corrected* Distances.
+    num_fragments = len(fragments)
+    centroid_distances = np.zeros((num_fragments, num_fragments))
+    corrected_distances = []  # Initialize with infinity
+    positions = atoms.get_positions()
+    atomic_numbers = atoms.get_atomic_numbers()
+    atomic_symbols = atoms.get_chemical_symbols()
+
+    if num_fragments > 1:
+        for i in range(num_fragments):
+            frag_i_positions = positions[fragments[i]]
+            centroid_i = np.mean(frag_i_positions, axis=0)
+
+            for j in range(i + 1, num_fragments):  # Iterate only over i < j
+                frag_j_positions = positions[fragments[j]]
+                centroid_j = np.mean(frag_j_positions, axis=0)
+                centroid_dist = np.linalg.norm(centroid_i - centroid_j)
+                centroid_distances[i, j] = centroid_distances[j, i] = centroid_dist
+
+                # Find closest pair of atoms and calculate corrected distance
+                all_distances = cdist(frag_i_positions, frag_j_positions)
+                min_dist = np.min(all_distances)
+                min_index_i, min_index_j = np.unravel_index(
+                    np.argmin(all_distances), all_distances.shape
+                )
+
+                atom_i_number = atomic_numbers[fragments[i][min_index_i]]
+                atom_j_number = atomic_numbers[fragments[j][min_index_j]]
+                atom_i_symbol = atomic_symbols[fragments[i][min_index_i]]
+                atom_j_symbol = atomic_symbols[fragments[j][min_index_j]]
+                covrad_sum = float(
+                    covalent_radii[atom_i_number] + covalent_radii[atom_j_number]
+                )
+
+                corrected_distances.append(
+                    (
+                        float(min_dist),
+                        atom_i_symbol,
+                        atom_j_symbol,
+                        covrad_sum,
+                        float(min_dist - covrad_sum * covalent_scale),
+                    )
+                )
+
+    return (
+        distance_matrix,
+        bond_matrix,
+        fragments,
+        centroid_distances,
+        corrected_distances,
+    )

chemparseplot-0.0.3/chemparseplot/analyze/use_ira.py

@@ -0,0 +1,73 @@
+# This is a separate module because building ira_mod [1] needs a Makefile and a
+# PYTHONPATH export.. after that's cleared up this will probably be a dependency
+# [1]: https://github.com/mammasmias/IterativeRotationsAssignments
+import dataclasses
+
+import ira_mod
+import numpy as np
+from collections import Counter
+
+
+@dataclasses.dataclass
+class IRAComp:
+    rot: np.array
+    trans: np.array
+    perm: np.array
+    hd: float
+
+
+class IncomparableStructuresError(ValueError):
+    """Custom exception raised for incompatible atomistic structures."""
+
+    pass
+
+
+def _perform_ira_match(atm1, atm2, k_factor=2.8):
+    """Performs IRA matching. Internal function."""
+    if len(atm1) != len(atm2):
+        errmsg = "Atomistic structures must have the same number of atoms."
+        raise IncomparableStructuresError(errmsg)
+    if not Counter(atm1.symbols) == Counter(atm2.symbols):
+        errmsg = "Atomistic structures must have the same atom types."
+        raise IncomparableStructuresError(errmsg)
+
+    ira = ira_mod.IRA()
+    return ira.match(
+        len(atm1),
+        atm1.get_atomic_numbers(),
+        atm1.get_positions(),
+        len(atm2),
+        atm2.get_atomic_numbers(),
+        atm2.get_positions(),
+        k_factor,
+    )
+
+
+def is_ira_pair(atm1, atm2, hd_tol=1, k_factor=2.8):
+    """Checks if two atomistic structures are an IRA pair."""
+    try:
+        _, _, _, hd = _perform_ira_match(atm1, atm2, k_factor)
+        return hd < hd_tol
+    except IncomparableStructuresError:
+        return False
+
+
+def do_ira(atm1, atm2, k_factor=2.8):
+    """Performs IRA matching on two atomistic structures."""
+    rotation, translation, perm, hd = _perform_ira_match(atm1, atm2, k_factor)
+    return IRAComp(rot=rotation, trans=translation, perm=perm, hd=hd)
+
+
+def calculate_rmsd(atm1, atm2, k_factor=2.8):
+    """Calculates RMSD using do_ira."""
+    ira_comp = do_ira(atm1, atm2, k_factor)
+    atm2_coords_permuted = atm2.get_positions()[ira_comp.perm]
+    atm2_coords_transformed = (
+        np.dot(atm2_coords_permuted, ira_comp.rot) + ira_comp.trans
+    )
+    n_atoms = len(atm1.get_positions())
+    squared_distances = np.sum(
+        (atm1.get_positions() - atm2_coords_transformed) ** 2, axis=1
+    )
+    rmsd = np.sqrt(np.sum(squared_distances) / n_atoms)
+    return rmsd

{chemparseplot-0.0.2 → chemparseplot-0.0.3}/chemparseplot/basetypes.py

@@ -1,7 +1,11 @@
 # SPDX-FileCopyrightText: 2023-present Rohit Goswami <rog32@hi.is>
 #
 # SPDX-License-Identifier: MIT
+import datetime
 from collections import namedtuple
+from dataclasses import dataclass
+
+import numpy as np
 
 # namedtuple for storing NEB iteration data
 nebiter = namedtuple("nebiter", ["iteration", "nebpath"])
@@ -45,3 +49,42 @@ Notes
 The `nebpath` namedtuple is used within the `nebiter` namedtuple to store
 detailed path information for each NEB iteration.
 """
+
+
+@dataclass
+class DimerOpt:
+    saddle: str = "dimer"
+    rot: str = "lbfgs"
+    trans: str = "lbfgs"
+
+
+@dataclass
+class SpinID:
+    mol_id: int
+    spin: str
+
+
+@dataclass
+class MolGeom:
+    pos: np.array
+    energy: float
+    forces: np.array
+
+
+@dataclass
+class SaddleMeasure:
+    pes_calls: int = 0
+    iter_steps: int = 0
+    tot_time: datetime.timedelta = datetime.timedelta(0).total_seconds()
+    saddle_energy: float = np.nan
+    saddle_fmax: float = np.nan
+    success: bool = False
+    method: str = "not run"
+    dimer_rot: str = "n/a"
+    dimer_trans: str = "n/a"
+    init_energy: float = np.nan
+    barrier: float = np.nan
+    mol_id: int = np.nan
+    spin: str = "unknown"
+    scf: float = np.nan
+    termination_status: str = "not set"

chemparseplot-0.0.3/chemparseplot/parse/eon/gprd.py

@@ -0,0 +1,329 @@
+import os
+import typing
+
+import ase
+import ase.io as aseio
+import h5py
+import numpy as np
+from ase.calculators.calculator import Calculator, all_changes
+from ase.calculators.nwchem import NWChem
+from ase.io.trajectory import Trajectory
+
+
+class HDF5CalculatorDimerMidpoint(Calculator):
+    implemented_properties: typing.ClassVar[list[str]] = ["energy", "forces"]
+
+    def __init__(self, from_hdf5, natms, **kwargs):
+        Calculator.__init__(self, **kwargs)
+        # Reference to the HDF5 group or dataset
+        self.from_hdf5 = from_hdf5
+        self.natoms = natms
+
+    def calculate(
+        self, atoms=None, properties=["energy", "forces"], system_changes=all_changes
+    ):
+        Calculator.calculate(self, atoms, properties, system_changes)
+
+        # Access energy and gradients directly from the referenced HDF5 object
+        energy = self.from_hdf5["energy"][0]
+        forces = self.from_hdf5["gradients"][: self.natoms * 3].reshape(-1, 3) * -1
+
+        # Store results
+        self.results["energy"] = energy
+        self.results["forces"] = forces
+
+
+class HDF5Calculator(Calculator):
+    implemented_properties: typing.ClassVar[list[str]] = ["energy", "forces"]
+
+    def __init__(self, from_hdf5, **kwargs):
+        Calculator.__init__(self, **kwargs)
+        # Reference to the HDF5 group or dataset
+        self.from_hdf5 = from_hdf5
+
+    def calculate(
+        self, atoms=None, properties=["energy", "forces"], system_changes=all_changes
+    ):
+        Calculator.calculate(self, atoms, properties, system_changes)
+
+        # Access energy and gradients directly from the referenced HDF5 object
+        energy = self.from_hdf5["energy"][0]
+        forces = self.from_hdf5["gradients"][:].reshape(-1, 3) * -1
+
+        # Store results
+        self.results["energy"] = energy
+        self.results["forces"] = forces
+
+
+def get_atoms_from_hdf5(template_atoms: ase.Atoms, hdf5_group: h5py.Group) -> ase.Atoms:
+    """
+    Creates an ASE Atoms object from a template and an HDF5 group containing optimization data.
+
+    Args:
+        template_atoms (ase.Atoms): The template ASE Atoms object (initial structure).
+        hdf5_group (h5py.Group): The HDF5 group containing 'energy', 'gradients', and 'positions' datasets.
+
+    Returns:
+        ase.Atoms: An ASE Atoms object with positions, energy, and forces from
+        the HDF5 group.
+    """
+
+    atoms = template_atoms.copy()
+    calculator = HDF5Calculator(from_hdf5=hdf5_group)
+    atoms.calc = calculator
+    atoms.set_positions(hdf5_group["positions"][()].reshape(-1, 3))
+    return atoms
+
+
+def create_geom_traj_from_hdf5(
+    hdf5_file: str,
+    output_traj_file: str,
+    initial_structure_file: str,
+    outer_loop_group_name: str = "outer_loop",
+):
+    """
+    Creates an ASE trajectory file from an HDF5 file containing optimization
+    data. This only outputs the geometry steps after the initial rotations.
+
+    Generally this is what you want to see for checking the change in geometry
+    along the run. There are initial rotations and 2 additional calls (one in
+    the beginning and one at the end) which are not accounted for here.
+
+    Args:
+        hdf5_file (str): Path to the HDF5 file.
+        output_traj_file (str): Path to the output trajectory file (e.g.,
+        'gprd_run.traj').
+        initial_structure_file (str): Path to the file containing the initial structure (e.g., 'pos.con').
+        outer_loop_group_name (str, optional): Name of the group containing
+        outer loop data. Defaults to "outer_loop".
+    """
+
+    try:
+        f = h5py.File(hdf5_file, "r")
+    except FileNotFoundError:
+        print(f"Error: HDF5 file '{hdf5_file}' not found.")
+        return
+    except Exception as e:
+        print(f"An error occurred while opening HDF5 file: {e}")
+        return
+
+    outer_loop_keys = [
+        str(x) for x in np.sort([int(x) for x in f[outer_loop_group_name].keys()])
+    ]
+    print(f"Available outer loop keys: {outer_loop_keys}")
+
+    try:
+        init = aseio.read(initial_structure_file)
+    except FileNotFoundError:
+        print(f"Error: Initial structure file '{initial_structure_file}' not found.")
+        f.close()
+        return
+    except Exception as e:
+        print(f"An error occurred while reading initial structure file: {e}")
+        f.close()
+        return
+
+    traj = Trajectory(output_traj_file, "w")
+
+    for key in outer_loop_keys:
+        try:
+            # Create atoms object directly here
+            atoms = init.copy()
+            calculator = HDF5Calculator(from_hdf5=f[outer_loop_group_name][key])
+            atoms.calc = calculator
+            atoms.set_positions(
+                f[outer_loop_group_name][key]["positions"][:].reshape(-1, 3)
+            )
+
+            # Trigger calculation of energy and forces
+            atoms.get_potential_energy()
+
+            traj.write(atoms)
+        except KeyError as e:
+            print(f"Skipping key {key} due to missing data: {e}")
+        except Exception as e:
+            print(f"An error occurred while processing key {key}: {e}")
+
+    f.close()
+    traj.close()
+    print(f"Trajectory file '{output_traj_file}' created successfully.")
+
+
+def create_nwchem_trajectory(
+    template_atoms: ase.Atoms,
+    hdf5_file: str,
+    output_traj_file: str,
+    mult=1,
+    outer_loop_group_name: str = "outer_loop",
+):
+    """
+    Creates an ASE trajectory file with NWChem energy and forces calculated for positions
+    taken from an HDF5 file.
+
+    Args:
+        template_atoms (ase.Atoms): The template ASE Atoms object (initial structure).
+        hdf5_file (str): Path to the HDF5 file containing positions.
+        output_traj_file (str): Path to the output trajectory file (e.g., 'nwchem_run.traj').
+        outer_loop_group_name (str, optional): Name of the group containing outer loop data. Defaults to "outer_loop".
+    """
+
+    try:
+        f = h5py.File(hdf5_file, "r")
+    except FileNotFoundError:
+        print(f"Error: HDF5 file '{hdf5_file}' not found.")
+        return
+    except Exception as e:
+        print(f"An error occurred while opening HDF5 file: {e}")
+        return
+
+    outer_loop_keys = [
+        str(x) for x in np.sort([int(x) for x in f[outer_loop_group_name].keys()])
+    ]
+    print(f"Available outer loop keys: {outer_loop_keys}")
+
+    traj = Trajectory(output_traj_file, "w")
+
+    nwchem_path = os.environ["NWCHEM_COMMAND"]
+    memory = "2 gb"
+    nwchem_kwargs = {
+        "command": f"{nwchem_path} PREFIX.nwi > PREFIX.nwo",
+        "memory": memory,
+        "scf": {
+            "nopen": mult - 1,
+            "thresh": 1e-8,
+            "maxiter": 200,
+        },
+        "basis": "3-21G",
+        "task": "gradient",
+    }
+    if mult == 2:
+        nwchem_kwargs["scf"]["uhf"] = None  # switch to unrestricted calculation
+
+    for key in outer_loop_keys:
+        try:
+            # Create a copy of the template atoms
+            atoms = template_atoms.copy()
+
+            # Set positions from the HDF5 file
+            atoms.positions = f[outer_loop_group_name][key]["positions"][()].reshape(
+                -1, 3
+            )
+
+            # Assign calculator and calculate energy and forces
+            atoms.calc = NWChem(**nwchem_kwargs)
+            print(f"Calculating for {key}")
+            atoms.get_potential_energy()
+
+            # Write to trajectory
+            traj.write(atoms)
+
+        except KeyError as e:
+            print(f"Skipping key {key} due to missing data: {e}")
+
+    f.close()
+    traj.close()
+    print(f"NWChem trajectory file '{output_traj_file}' created successfully.")
+
+
+def create_full_traj_from_hdf5(
+    hdf5_file: str,
+    output_traj_file: str,
+    initial_structure_file: str,
+    outer_loop_group_name: str = "outer_loop",
+    inner_loop_group_name: str = "initial_rotations",
+):
+    """
+    Creates an ASE trajectory file from an HDF5 file containing optimization
+    data. Includes **estimated points** for the initial rotations and the
+    endpoints. These are correct (correspond to the actual counts) but is
+    slightly convoluted, since the HDF5 contains both the midpoint and the
+    "forward dimer". Instead, the length of the inner rotations keys is the
+    number of (0 energy) points added to the trajectory. This again makes
+    intuitive sense, since we have the Elvl cutoff in the GPRD as well.
+
+    Args:
+        hdf5_file (str): Path to the HDF5 file.
+        output_traj_file (str): Path to the output trajectory file (e.g.,
+        'gprd_run.traj').
+        initial_structure_file (str): Path to the file containing the initial structure (e.g., 'pos.con').
+        outer_loop_group_name (str, optional): Name of the group containing
+        outer loop data. Defaults to "outer_loop".
+    """
+
+    try:
+        f = h5py.File(hdf5_file, "r")
+    except FileNotFoundError:
+        print(f"Error: HDF5 file '{hdf5_file}' not found.")
+        return
+    except Exception as e:
+        print(f"An error occurred while opening HDF5 file: {e}")
+        return
+
+    outer_loop_keys = [
+        str(x) for x in np.sort([int(x) for x in f[outer_loop_group_name].keys()])
+    ]
+
+    inner_loop_keys = [
+        str(x) for x in np.sort([int(x) for x in f[inner_loop_group_name].keys()])
+    ]
+
+    print(f"Available innner loop keys: {inner_loop_keys}")
+    print(f"Available outer loop keys: {outer_loop_keys}")
+
+    try:
+        init = aseio.read(initial_structure_file)
+    except FileNotFoundError:
+        print(f"Error: Initial structure file '{initial_structure_file}' not found.")
+        f.close()
+        return
+    except Exception as e:
+        print(f"An error occurred while reading initial structure file: {e}")
+        f.close()
+        return
+
+    traj = Trajectory(output_traj_file, "w")
+
+    # Generate the initial rotation stuff here
+    # Basically the number of keys, + 1
+    for idx, key in enumerate(inner_loop_keys):
+        atoms = init.copy()
+        iloop_dat = f[inner_loop_group_name][key]
+        calculator = HDF5CalculatorDimerMidpoint(from_hdf5=iloop_dat, natms=len(atoms))
+        atoms.calc = calculator
+        atoms.set_positions(iloop_dat["positions"][: len(atoms) * 3].reshape(-1, 3))
+
+        # Trigger calculation of energy and forces
+        atoms.get_potential_energy()
+        traj.write(atoms)
+
+        # Do it again for the first step
+        if idx == 0:
+            traj.write(atoms)
+
+    for idx, key in enumerate(outer_loop_keys):
+        try:
+            # Create atoms object directly here
+            atoms = init.copy()
+            calculator = HDF5Calculator(from_hdf5=f[outer_loop_group_name][key])
+            atoms.calc = calculator
+            atoms.set_positions(
+                f[outer_loop_group_name][key]["positions"][:].reshape(-1, 3)
+            )
+
+            # Trigger calculation of energy and forces
+            atoms.get_potential_energy()
+
+            traj.write(atoms)
+            # Now for the final calculation done to finish the run
+            if idx == len(outer_loop_keys) - 1:
+                # Just write it one more time, same thing
+                traj.write(atoms)
+
+        except KeyError as e:
+            print(f"Skipping key {key} due to missing data: {e}")
+        except Exception as e:
+            print(f"An error occurred while processing key {key}: {e}")
+
+    f.close()
+    traj.close()
+    print(f"Trajectory file '{output_traj_file}' created successfully.")

chemparseplot-0.0.3/chemparseplot/parse/eon/minimization.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+
+import re
+from pathlib import Path
+
+
+def min_e_result(eresp: Path) -> dict:
+    """Reads and parses the results.dat file.
+
+    Args:
+        eresp: Path to the EON results directory.
+
+    Returns:
+        A dictionary containing the parsed data from results.dat, or None if the file
+        does not exist or the termination reason is not 0.
+    """
+    respth = eresp / "results.dat"
+    if not respth.exists():
+        return None
+
+    rdat = respth.read_text()
+    termination_reason = re.search(r"(\w+) termination_reason", rdat).group(1)
+    if termination_reason != "GOOD":
+        return None
+
+    min_energy = float(re.search(r"(-?\d+\.\d+) potential_energy", rdat).group(1))
+    return min_energy