mlmm-toolkit 0.2.2.dev0__py3-none-any.whl

pysisyphus/calculators/EGO.py

@@ -0,0 +1,76 @@
+# [1] http://dx.doi.org/10.1021/acs.jctc.8b00885
+#     Exploring Potential Energy Surface with External Forces
+
+import numpy as np
+
+from pysisyphus.calculators.Calculator import Calculator
+
+
+class EGO(Calculator):
+    def __init__(
+        self,
+        calculator,
+        ref_geom,
+        max_force=0.175,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.calculator = calculator
+        self.ref_geom = ref_geom
+        self.max_force = max_force
+        assert (
+            self.max_force > 0.0
+        ), f"Maximum force must be positve bug to max_force={self.max_force:.4f} au"
+
+        self._ref_hessian = None
+        self._s = None
+
+    @property
+    def ref_hessian(self):
+        if self._ref_hessian is None:
+            geom = self.ref_geom
+            results = self.calculator.get_hessian(geom.atoms, geom.cart_coords)
+            self._ref_hessian = results["hessian"]
+            Hr0 = self._ref_hessian @ self.ref_geom.cart_coords[:, None]
+            self._s = self.max_force / np.abs(Hr0).max()
+            self.log(f"Set EGO s={self._s:.6f}")
+        return self._ref_hessian
+
+    @property
+    def s(self):
+        return self._s
+
+    def get_mods(self, atoms, coords):
+        assert atoms == self.ref_geom.atoms
+        Hr = self.ref_hessian @ coords[:, None]
+        s = self.s
+        energy_mod = float(coords[None, :] @ Hr)
+        forces_mod = -s * Hr.flatten()
+        return energy_mod, forces_mod
+
+    def get_energy(self, atoms, coords, **prepare_kwargs):
+        true_energy = self.calculator.get_energy(atoms, coords)["energy"]
+        energy_mod, _ = self.get_mods(atoms, coords)
+
+        results = {
+            "energy": true_energy + energy_mod,
+            "true_energy": true_energy,
+        }
+        self.calc_counter += 1
+        return results
+
+    def get_forces(self, atoms, coords, **prepare_kwargs):
+        true_results = self.calculator.get_forces(atoms, coords, **prepare_kwargs)
+        true_energy = true_results["energy"]
+        true_forces = true_results["forces"]
+        energy_mod, forces_mod = self.get_mods(atoms, coords)
+
+        results = {
+            "energy": true_energy + energy_mod,
+            "forces": true_forces + forces_mod,
+            "true_forces": true_forces,
+            "true_energy": true_energy,
+        }
+        self.calc_counter += 1
+        return results

pysisyphus/calculators/EnergyMin.py

@@ -0,0 +1,224 @@
+# [1] https://doi.org/10.1063/5.0021923
+#     Extending NEB method to reaction pathways involving multiple spin states
+#     Zhao et al, 2020
+# [2] https://doi.org/10.1021/jp0761618
+#     Optimizing Conical Intersections without Derivative Coupling Vectors:
+#     Application to Multistate Multireference Second-Order Perturbation Theory
+#     Levine, Coe, Martinez 2008
+
+import numpy as np
+
+from pysisyphus.calculators.Calculator import Calculator
+from pysisyphus.constants import AU2KJPERMOL
+from pysisyphus.helpers import norm_max_rms
+
+
+class EnergyMin(Calculator):
+    def __init__(
+        self,
+        calculator1: Calculator,
+        calculator2: Calculator,
+        mix: bool = False,
+        alpha: float = 0.02,  # Hartree
+        sigma: float = 3.5,  # Unitless; default for ethene case in [1]
+        min_energy_diff: float = 0.0,
+        check_after: int = 0,
+        **kwargs,
+    ):
+        """
+        Use energy and derivatives of the calculator with lower energy.
+
+        This calculators carries out two calculations with different settings
+        and returns the results of the lower energy one. This can be used
+        to consider flips between a singlet and a triplet PES etc.
+
+        Parameters
+        ----------
+        calculator1
+            Wrapped QC calculator that provides energies and its derivatives.
+        calculator2
+            Wrapped QC calculator that provides energies and its derivatives.
+        mix
+            Enable mixing of both forces, according to the approach outlined
+            in [2]. Can be used to optimize guesses for MECPs.
+            Pass
+        alpha
+            Smoothing parameter in Hartree. See [2] for a discussion.
+        sigma
+            Unitless gap size parameter. The final gap becomes
+            smaller for bigga sigmas. Has to be adapted for each case. See
+            [2] for a discussion (p. 407 right column and p. 408 left column.)
+        min_energy_diff
+            Energy difference in Hartree. When set to a value != 0 and the
+            energy difference between both
+            calculators drops below this value, execution of both calculations
+            is diabled for 'check_after' cycles. In these cycles the calculator choice
+            remains fixed. After 'check_after' cycles, both energies
+            will be calculated and it is checked, if the previous calculator
+            choice remains valid.
+            In conjunction with 'check_after' both arguments can be used to
+            save computational ressources.
+        check_after
+            Amount of cycles in which the calculator choice remains fixed.
+
+        Other Parameters
+        ----------------
+        **kwargs
+            Keyword arguments passed to the Calculator baseclass.
+        """
+        super().__init__(**kwargs)
+        self.calc1 = calculator1
+        self.calc2 = calculator2
+        self.alpha = alpha
+        self.sigma = sigma
+        self.min_energy_diff = float(min_energy_diff)
+        self.check_after = int(check_after)
+        assert self.check_after >= 0, "'check_after' must not be negative!"
+
+        self.mix = mix
+        self.recalc_in = self.check_after
+        self.fixed_calc = None
+
+    def do_calculations(self, name, atoms, coords, **prepare_kwargs):
+        def run_calculation(calc, name=name):
+            results = getattr(calc, name)(atoms, coords, **prepare_kwargs)
+            return results
+
+        if (self.fixed_calc is not None) and self.recalc_in > 0:
+            self.log(
+                f"Used fixed calculator '{self.fixed_calc}'. Re-checking both "
+                f"calculators in {self.recalc_in} cycles."
+            )
+            results = run_calculation(self.fixed_calc)
+            self.recalc_in -= 1
+            self.calc_counter += 1
+            return results
+        elif (self.fixed_calc is not None) and self.recalc_in == 0:
+            self.log(f"Unset fixed calculator {self.calc1}.")
+            self.fixed_calc = None
+
+        # Avoid unnecessary costly Hessian calculations; decide which Hessian
+        # to calculate from previous energy calculation.
+        if name == "get_hessian":
+            tmp_energy1 = run_calculation(self.calc1, "get_energy")["energy"]
+            tmp_energy2 = run_calculation(self.calc2, "get_energy")["energy"]
+            if tmp_energy1 <= tmp_energy2:
+                results1 = run_calculation(self.calc1)
+                results2 = {"energy": tmp_energy2}
+                self.log("Calculated Hessian for calc1, skipped it for calc2.")
+            else:
+                results1 = {"energy": tmp_energy1}
+                results2 = run_calculation(self.calc2)
+                self.log("Calculated Hessian for calc2, skipped it for calc1.")
+        # Do both full calculation otherwise
+        else:
+            results1 = run_calculation(self.calc1, name)
+            results2 = run_calculation(self.calc2, name)
+        energy1 = results1["energy"]
+        energy2 = results2["energy"]
+        all_energies = np.array((energy1, energy2))
+
+        # Mixed forces to optimize crossing points
+        if self.mix:
+            # Must be positive, so substract lower energy from higher energy.
+            # I is the higher state, j the lower one.
+            en_i, en_j = (
+                (energy2, energy1) if (energy1 < energy2) else (energy1, energy2)
+            )
+            energy_diff = en_i - en_j
+            energy_diff_kJ = energy_diff * AU2KJPERMOL
+            assert energy_diff > 0.0
+            self.log(
+                f"Mix mode, ΔE={energy_diff:.6f} au ({energy_diff_kJ:.2f} kJ mol⁻¹)"
+            )
+            energy_diff_sq = energy_diff**2
+            denom = energy_diff + self.alpha
+            energy = (en_i + en_j) / 2 + self.sigma * energy_diff_sq / denom
+            results = {
+                "energy": energy,
+                "all_energies": all_energies,
+            }
+            self.log(f"Mixed energy: {energy:.6f} au")
+            if name == "get_forces":
+                forces1 = results1["forces"]
+                forces2 = results2["forces"]
+                forces_i, forces_j = (
+                    (forces2, forces1) if (energy1 < energy2) else (forces1, forces2)
+                )
+                # There seems to be a typo in Eq. (8) in [1]; the final term
+                # should be (dV_J - dV_I) instead of the (dV_I - dV_J).
+                # The formula is correct though, in the original publication
+                # (Eq. (7) in [2]).
+                forces = (forces_i + forces_j) / 2 + self.sigma * (
+                    energy_diff_sq + 2 * self.alpha * energy_diff
+                ) / denom**2 * (forces_i - forces_j)
+                results["forces"] = forces
+                for key, forces in (
+                    ("mixed forces", forces),
+                    ("forces1", forces1),
+                    ("forces2", forces2),
+                ):
+                    norm, max_, rms_ = norm_max_rms(forces)
+                    self.log(
+                        f"{key: >14s}: (norm={norm:.4f}, max(|{key: >14s}|)={max_:.4f}, "
+                        f"rms={rms_:.4f}) au a0⁻¹"
+                    )
+            self.calc_counter += 1
+            return results
+        # Mixed forces end
+
+        min_ind = [1, 0][int(energy1 < energy2)]
+        en1_or_en2 = ("calc1", "calc2")[min_ind]
+        energy_diff = energy1 - energy2
+        # Try to fix calculator, if requested
+        if (self.min_energy_diff and self.check_after) and (
+            # When the actual difference is above to minimum differences
+            # or
+            # no calculator is fixed yet
+            (energy_diff > self.min_energy_diff)
+            or (self.fixed_calc is None)
+        ):
+            self.fixed_calc = (self.calc1, self.calc2)[min_ind]
+            self.recalc_in = self.check_after
+            self.log(
+                f"Fixed calculator choice ({en1_or_en2}) for {self.recalc_in} cycles."
+            )
+        results = (results1, results2)[min_ind]
+        results["all_energies"] = all_energies
+        energy_diff_kJ = abs(energy_diff) * AU2KJPERMOL
+
+        self.log(
+            f"energy_calc1={energy1:.6f} au, energy_calc2={energy2:.6f} au, returning "
+            f"results for {en1_or_en2}, {energy_diff_kJ: >10.2f} kJ mol⁻¹ lower."
+        )
+        self.calc_counter += 1
+        return results
+
+    def get_energy(self, atoms, coords, **prepare_kwargs):
+        return self.do_calculations("get_energy", atoms, coords, **prepare_kwargs)
+
+    def get_forces(self, atoms, coords, **prepare_kwargs):
+        return self.do_calculations("get_forces", atoms, coords, **prepare_kwargs)
+
+    def get_hessian(self, atoms, coords, **prepare_kwargs):
+        return self.do_calculations("get_hessian", atoms, coords, **prepare_kwargs)
+
+    def get_chkfiles(self) -> dict:
+        chkfiles = {}
+        for key in ("calc1", "calc2"):
+            try:
+                chkfiles[key] = getattr(self, key).get_chkfiles()
+            except AttributeError:
+                pass
+        return chkfiles
+
+    def set_chkfiles(self, chkfiles: dict):
+        for key in ("calc1", "calc2"):
+            try:
+                getattr(self, key).set_chkfiles(chkfiles[key])
+                msg = f"Set chkfile on '{key}'"
+            except KeyError:
+                msg = f"Found no information for '{key}' in chkfiles!"
+            except AttributeError:
+                msg = f"Setting chkfiles is not supported by '{key}'"
+            self.log(msg)

pysisyphus/calculators/ExternalPotential.py

@@ -0,0 +1,264 @@
+from math import pi
+from typing import Optional
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+from pysisyphus.calculators.Calculator import Calculator
+from pysisyphus.constants import KB, AU2J
+from pysisyphus.Geometry import Geometry
+from pysisyphus.intcoords.PrimTypes import prims_from_prim_inputs
+from pysisyphus.intcoords.update import correct_dihedrals
+from pysisyphus.intcoords import Torsion
+from pysisyphus.linalg import rmsd_grad
+from pysisyphus.calculators.DFTD3 import DFTD3
+
+class LogFermi:
+    def __init__(self, beta, radius, T=300, origin=(0.0, 0.0, 0.0), geom=None):
+        """As described in the XTB docs.
+
+        https://xtb-docs.readthedocs.io/en/latest/xcontrol.html#confining-in-a-cavity
+        """
+        self.beta = beta
+        self.radius = radius
+        self.T = T
+        self.origin = np.array(origin)
+
+        # In Hartree
+        self.kT = KB * self.T / AU2J
+
+    def calc(self, coords3d, gradient=False):
+        t0 = coords3d - self.origin[None, :]
+        t1 = np.linalg.norm(t0, axis=1)
+        t2 = np.exp(self.beta * (t1 - self.radius))
+
+        energy = (self.kT * np.log(1 + t2)).sum()
+        if not gradient:
+            return energy
+
+        grad = self.kT * ((self.beta * t2) / ((1 + t2) * t1))[:, None] * t0
+        return energy, grad.flatten()
+
+    def __repr__(self):
+        return (
+            f"LogFermi(beta={self.beta:.6f}, radius={self.radius:.6f}, "
+            f"T={self.T:.6f}, origin={self.origin})"
+        )
+
+
+class HarmonicSphere:
+    def __init__(self, k, radius, origin=(0.0, 0.0, 0.0), geom=None):
+        self.k = k
+        self.radius = radius
+        self.origin = np.array(origin)
+
+    def calc(self, coords3d, gradient=False):
+        c3d_wrt_origin = coords3d - self.origin
+        distances = np.linalg.norm(c3d_wrt_origin, axis=1)
+        energies = np.where(distances > self.radius, self.k * distances**2, 0.0)
+        energy = energies.sum()
+
+        if not gradient:
+            return energy
+
+        """
+        E(r(x)) = k*r**2
+        dE(r(x))/dx = dE/dr * dr/dx
+        dE/dr = 2*k*r
+        dr/dx = x/r
+        dE/dr * dr/dx = 2*k*x
+        """
+        grad = np.where(distances > self.radius, 2 * self.k * c3d_wrt_origin, 0.0)
+
+        return energy, grad.flatten()
+
+    @property
+    def surface_area(self):
+        """In Bohr**2"""
+        return 4 * pi * self.radius**2
+
+    def instant_pressure(self, coords3d):
+        _, gradient = self.calc(coords3d, gradient=True)
+        norm = np.linalg.norm(gradient)
+        p = norm / self.surface_area
+        return p
+
+
+class Restraint:
+    def __init__(self, restraints, geom=None):
+        self.restraints = list()
+
+        for prim_inp, *rest in restraints:
+            prims = prims_from_prim_inputs((prim_inp,))
+            assert len(prims) == 1
+            prim = prims[0]
+            force_const = rest.pop(0)
+
+            try:
+                ref_val = rest.pop(0)
+            except IndexError:
+                assert (
+                    geom is not None
+                ), "Need initial coordinates when no reference value is specified!"
+                ref_val = prim.calculate(geom.coords3d)
+
+            self.restraints.append((prim, force_const, ref_val))
+
+    @staticmethod
+    def calc_prim_restraint(prim, coords3d, force_const, ref_val):
+        val, grad = prim.calculate(coords3d, gradient=True)
+        if isinstance(prim, Torsion):
+            # correct_dihedrals always returns a 1d array, even for scalar inputs
+            val = correct_dihedrals(val, ref_val)[0]
+        diff = val - ref_val
+        pot = force_const * diff**2
+        pot_grad = 2 * force_const * diff * grad
+        return pot, pot_grad
+
+    def calc(self, coords3d, gradient=False):
+        energy = 0.0
+        grad = np.zeros(coords3d.size)
+
+        for prim, force_const, ref_val in self.restraints:
+            penergy, pgrad = self.calc_prim_restraint(
+                prim, coords3d, force_const, ref_val
+            )
+            energy += penergy
+            grad += pgrad
+
+        if not gradient:
+            return energy
+
+        return energy, grad.flatten()
+
+
+class RMSD:
+    def __init__(
+        self,
+        geom: Geometry,
+        k: float,
+        beta: float = 0.5,
+        atom_indices: Optional[ArrayLike] = None,
+    ):
+        """Restrain based on RMSD with a reference geometry.
+
+        As described in https://doi.org/10.1021/acs.jctc.0c01306, Eq. (5).
+
+        Parameters
+        ----------
+
+        geom:
+            Reference geometry for RMSD calculation.
+        k:
+            Gaussian height in units of energy. Should be a negative number if the system
+            under study should stay close to the reference geometry (pulling k).
+            A positive Gaussian height k results in forces that push the system under study
+            away from the reference geometry (pushing k).
+        b:
+            Gaussian width in inverse units of lengths.
+        atom_indices
+            Optional, numpy array or iterable of integer atom indices. Restricts the RMSD
+            calculation to these atoms. If omitted, all atoms are used.
+        """
+
+        self.k = k
+        self.beta = beta
+        natoms = len(geom.atoms)
+        if atom_indices is None:
+            atom_indices = np.arange(natoms)
+        self.atom_indices = np.array(atom_indices, dtype=int)
+        assert (self.atom_indices.min() >= 0) and (
+            self.atom_indices.max() <= (natoms - 1)
+        ), "Got atom_indices outside the valid range!"
+        self.ref_coords3d = geom.coords3d.copy()
+        # print("Using {self.atom_indices.size} of {natoms} atoms for RMSD calculations.")
+
+    def calc(self, coords3d, gradient=False):
+        rmsd, grad_ = rmsd_grad(
+            coords3d[self.atom_indices], self.ref_coords3d[self.atom_indices]
+        )
+
+        k = self.k
+        beta = self.beta
+        energy = k * np.exp(-beta * rmsd**2)
+
+        if not gradient:
+            return energy
+
+        grad = np.zeros_like(self.ref_coords3d)
+        grad[self.atom_indices] = -beta * 2 * grad_ * energy
+        return energy, grad.flatten()
+
+    def __repr__(self):
+        return f"RMSD(k={self.k:.4f}, beta={self.beta:.6f}, {self.atom_indices.size} atoms)"
+
+
+class ExternalPotential(Calculator):
+
+    available_potentials = {
+        "logfermi": LogFermi,
+        "harmonic_sphere": HarmonicSphere,
+        "restraint": Restraint,
+        "rmsd": RMSD,
+        "d3": DFTD3,
+    }
+
+    def __init__(self, calculator=None, potentials=None, geom=None, **kwargs):
+        super().__init__(**kwargs)
+
+        self.calculator = calculator
+
+        self.potentials = list()
+        self.log("Creating external potentials")
+        for i, pot_kwargs in enumerate(potentials):
+            pot_kwargs.update({"geom": geom})
+            pot_key = pot_kwargs.pop("type")
+            pot_cls = self.available_potentials[pot_key]
+            pot = pot_cls(**pot_kwargs)
+            self.potentials.append(pot)
+            self.log(f"\t{i:02d}: {pot}")
+
+    def get_potential_energy(self, coords):
+        coords3d = coords.reshape(-1, 3)
+        potential_energies = [pot.calc(coords3d) for pot in self.potentials]
+        potential_energy = sum(potential_energies)
+        self.log(f"Energies from external potential: {potential_energies}")
+        return potential_energy
+
+    def get_energy(self, atoms, coords):
+        potential_energy = self.get_potential_energy(coords)
+        if self.calculator is not None:
+            results = self.calculator.get_energy(atoms, coords)
+        else:
+            results = {"energy": 0.0}
+        results["energy"] += potential_energy
+        return results
+
+    def get_potential_forces(self, coords):
+        coords3d = coords.reshape(-1, 3)
+        energies_gradients = [
+            pot.calc(coords3d, gradient=True) for pot in self.potentials
+        ]
+        energies, gradients = zip(*energies_gradients)
+        self.log(f"Energies from external potential: {energies}")
+        energy = sum(energies)
+        forces = -np.sum(gradients, axis=0)
+        self.log(f"Forces from external potential: {forces}")
+        return energy, forces
+
+    def get_forces(self, atoms, coords):
+        potential_energy, potential_forces = self.get_potential_forces(coords)
+        if self.calculator is not None:
+            results = self.calculator.get_forces(atoms, coords)
+        else:
+            results = {"energy": 0.0, "forces": np.zeros_like(coords)}
+        results["energy"] += potential_energy
+        results["forces"] += potential_forces
+        return results
+
+    def get_hessian(self, atoms, coords):
+        raise Exception("Hessian is not implemented for ExternalPotential!")
+
+    def __str__(self):
+        pots = ", ".join([str(pot) for pot in self.potentials])
+        return f"ExternalPotential({pots})"

pysisyphus/calculators/FakeASE.py

@@ -0,0 +1,35 @@
+from pysisyphus.constants import BOHR2ANG
+
+class FakeASE:
+
+    def __init__(self, calc):
+        self.calc = calc
+
+        self.results = dict()
+
+    def get_atoms_coords(self, atoms):
+        return (atoms.get_chemical_symbols(),
+                # Convert ASE Angstrom to Bohr for pysisyphus
+                atoms.get_positions().flatten() / BOHR2ANG
+        )
+
+    def get_potential_energy(self, atoms=None):
+        atoms, coords = self.get_atoms_coords(atoms)
+        results = self.calc.get_energy(atoms, coords)
+
+        energy = results["energy"]
+        # self.results["energy"] = results["energy"]
+
+        return energy
+
+    def get_forces(self, atoms=None):
+        atoms, coords = self.get_atoms_coords(atoms)
+        results = self.calc.get_forces(atoms, coords)
+
+        # Convert back to Angstrom for ASE
+        forces = results["forces"].reshape(-1, 3) / BOHR2ANG
+
+        # self.results["energy"] = results["energy"]
+        # self.results["forces"] = forces
+
+        return forces

pysisyphus/calculators/FourWellAnaPot.py

@@ -0,0 +1,28 @@
+from pysisyphus.calculators.AnaPotBase import AnaPotBase
+
+# See J. Chem. Phys. 122 174106 (2005)
+# https://doi.org/10.1063/1.1885467
+# Eq. (11)
+
+class FourWellAnaPot(AnaPotBase):
+
+    def __init__(self): 
+        V_str = "x**4 + y**4 - 2*x**2 - 4*y**2 + x*y + 0.3*x + 0.1*y"
+        xlim = (-1.75, 1.75)
+        ylim = (-1.75, 1.75)
+        minima = (
+            (1.12410175, -1.48527428, 0.0),
+            (-0.82190767, -1.36672971, 0.0),
+            (-1.17405609,  1.47708706, 0.0),
+        )
+        super().__init__(V_str=V_str, xlim=xlim, ylim=ylim, minima=minima)
+
+    def __str__(self):
+        return "FourWellAnaPot calculator"
+
+
+if __name__ == "__main__":
+    fw = FourWellAnaPot()
+    fw.plot()
+    import matplotlib.pyplot as plt
+    plt.show()

pysisyphus/calculators/FreeEndNEBPot.py

@@ -0,0 +1,39 @@
+# import numpy as np
+from sympy import atan, symbols
+
+from pysisyphus.calculators.AnaPotBase import AnaPotBase
+from pysisyphus.calculators.LEPSExpr import LEPSExpr
+
+# [1] 10.1063/1.4962019 Free-end adaptive NEB
+
+class FreeEndNEBPot(AnaPotBase):
+
+    def __init__(self):
+        """Analyitcal potential as described in [1] Appendix A"""
+        leps_expr = LEPSExpr()
+        V_expr, xlim, ylim, levels = leps_expr.get_expr("harmonic")
+
+        self.x0 = 1.93
+        x = symbols("x")
+        
+        V_expr = V_expr - 2*atan(5*(x-self.x0)) - 2*x
+        V_str = str(V_expr)
+        # xlim = (0.5, 2.25)
+        # ylim = (0.0, 1.6)
+        # levels = np.linspace(-10, 0, 125)
+        xlim = (0.5, 4)
+        ylim = (-4, 2)
+        minima = ((0.828758,  1.2027524, 0), (3.0894413, -1.4060824, 0))
+
+        super().__init__(V_str=V_str, xlim=xlim, ylim=ylim, levels=levels,
+                         minima=minima)
+
+    def __str__(self):
+        return "FreeEndNEBPot calculator"
+
+
+if __name__ == "__main__":
+    import matplotlib.pyplot as plt
+    fep = FreeEndNEBPot()
+    fep.plot()
+    plt.show()

pysisyphus/calculators/Gaussian09.py

@@ -0,0 +1,18 @@
+from pysisyphus.calculators.Gaussian16 import Gaussian16
+
+
+class Gaussian09(Gaussian16):
+
+    conf_key = "gaussian09"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fn_base = "gaussian09"
+        self.inp_fn = f"{self.fn_base}.com"
+        self.out_fn = f"{self.fn_base}.log"
+        self.chk_fn = f"{self.fn_base}.chk"
+        self.base_cmd = self.get_cmd()
+        self.formchk_cmd = self.get_cmd("formchk")
+
+    def __str__(self):
+        return "Gaussian09 calculator"