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

pysisyphus/calculators/LEPSExpr.py

@@ -0,0 +1,139 @@
+import numpy as np
+from sympy import symbols, exp
+
+# [1]   10.1142/9789812839664_0016
+#       G. Henkelman, G. Jóhannesson, and H. Jónsson
+#       Theoretical Methods in Condensed Phase Chemistry
+#       (Springer, Netherlands, 2002), pp. 287
+# [2]   https://aip.scitation.org/doi/pdf/10.1063/1.480097?class=pdf
+#       I'm very sure that Fig. 6 and Fig. 5 are not the potentials that are
+#       described in the paper. There are two errors in the paper. A_1 is
+#       actually -1.5 and not 1.5 and s_x_2 is 0.5 and not 5.0. You also
+#       have to divide by (2*s_x_i**2) and not only by (2*s_x_i) as given
+#       in Eq. (22).
+
+class LEPSExpr:
+
+
+    def __init__(self):
+        """Generates sympy expression for various LEPS potentials."""
+        # V_harmonic uses b = 0.80
+        self.abc = (0.05, 0.30, 0.05)
+        self.ds = (4.746, 4.746, 3.445)
+        self.r0 = 0.742
+        self.alpha = 1.942
+
+        # Used for LEPS + harmonic oscillator
+        self.rac = 3.742
+        self.kc = 0.2025
+        self.c_ = 1.154
+
+        self.choices = {
+            "leps": self.get_leps,
+            "harmonic": self.get_harmonic,
+            "tot": self.get_tot,
+            "dimer": self.get_dimer,
+        }
+
+    def get_leps(self):
+        V_expr = self.V_LEPS()
+        xlim = (0, 6)
+        ylim = (0, 12)
+        levels = np.linspace(-5, 5, 250)
+        return V_expr, xlim, ylim, levels
+
+    def get_harmonic(self):
+        V_expr = self.V_harmonic()
+        levels = np.linspace(-20, 20, 250)
+        xlim = (0.4, 3.2)
+        ylim = (-2, 2)
+        return V_expr, xlim, ylim, levels
+
+    def get_tot(self):
+        V_expr = self.V_tot()
+        levels = np.linspace(-5, 2, 75)
+        xlim = (0.4, 3.2)
+        ylim = (-2, 2)
+        return V_expr, xlim, ylim, levels
+
+    def get_dimer(self):
+        V_expr = self.V_dimer()
+        levels = None
+        xlim = (0.25, 3.25)
+        ylim = (-3.5, 3.5)
+        return V_expr, xlim, ylim, levels
+
+    def get_expr(self, pot_type="leps"):
+        assert pot_type in self.choices
+        return self.choices[pot_type]()
+
+
+    def Q(self, d, alpha, r0, r):
+        """Coulomb interactions."""
+        return d/2* (3/2*exp(-2*alpha*(r-r0)) - exp(-alpha*(r-r0)))
+
+    def J(self, d, alpha, r0, r):
+        """Quantum mechanical exchange interaction."""
+        return d/4 * (exp(-2*alpha*(r-r0))-6*exp(-alpha*(r-r0)))
+
+    def G(self, a, b):
+        "Gaussian function."""
+        return exp(-0.5*((a/0.1)**2 +(b/0.35)**2))
+
+    def Gdimer(self, x, y, A, x0, y0, sx, sy):
+        return A * exp(-(x-x0)**2/(2*sx**2)) * exp(-(y-y0)**2/(2*sy**2))
+
+    def V_LEPS(self, x=None, y=None, abc=None):
+        """Equation (A.1) in [1].
+        Mimics reaction involving three atoms confined to motion along
+        a line."""
+        if abc is None:
+            abc = self.abc
+        a, b, c = abc
+        if x is None:
+            x = symbols("x")
+        if y is None:
+            y = symbols("y")
+        rs = (x, y, self.rac)
+        
+        Qab, Qbc, Qac = [self.Q(d, self.alpha, self.r0, r)
+                         for d, r in zip(self.ds, rs)]
+        Jab, Jbc, Jac = [self.J(d, self.alpha, self.r0, r)
+                         for d, r in zip(self.ds, rs)]
+        
+        first_term = Qab/(1+a) + Qbc/(1+b) + Qac/(1+c)
+        second_term = Jab**2/(1+a)**2 + Jbc**2/(1+b)**2 + Jac**2/(1+c)**2
+        third_term = (-Jab*Jbc / ((1+a)*(1+b))
+                      -Jbc*Jac / ((1+b)*(1+c))
+                      -Jab*Jac / ((1+a)*(1+c))
+        )
+        return first_term - (second_term + third_term)**0.5
+
+    def V_harmonic(self):
+        """Equation (A.2) in [1].
+        A and C are fixed, only B can move. A condensed phase environment
+        is represented by adding a harmonic oscillator degree of freedom."""
+        x, y = symbols("x y")
+        abc = (0.05, 0.80, 0.05)
+        return (self.V_LEPS(x, self.rac-x, abc)
+                + 2*self.kc*(x-(self.rac/2 - y/self.c_))**2
+        )
+
+    def V_tot(self):
+        """Equation (A.3) in [1].
+        Additional saddle point."""
+        x, y = symbols("x y")
+        return self.V_harmonic() + 1.5 * self.G(x-2.02083, y+0.272881)
+
+    def V_dimer(self):
+        """III. Results Section A in [3]. Two additional saddle points
+        from two added gaussians."""
+        x, y = symbols("x y")
+        #           Ai , x0i    ,  y0i     , sxi, syi
+        params = ((-1.5, 2.02083, -0.172881, 0.1, 0.35),
+                  ( 6.0, 0.8    ,  2.0     , 0.5, 0.7 ))
+        G0, G1 = [self.Gdimer(x, y, *parms) for parms in params]
+        return self.V_harmonic() + G0 + G1
+
+    def __str__(self):
+        return "LEPSExpr"

pysisyphus/calculators/LennardJones.py

@@ -0,0 +1,80 @@
+import numpy as np
+
+from pysisyphus.calculators.Calculator import Calculator
+
+
+class LennardJones(Calculator):
+
+    # Corresponds to σ = 1 Å, as the default value in ASE, but
+    # pysisyphus uses au/Bohr.
+    def __init__(self, sigma=1.8897261251, epsilon=1, rc=None):
+        super().__init__()
+
+        self.sigma = sigma
+        self.epsilon = epsilon
+        # Cutoff distance
+        if rc is None:
+            rc = 3 * self.sigma
+        self.rc = rc
+        # Shift energy
+        self.e0 = (4 * self.epsilon *
+                   ((self.sigma/self.rc)**12 - (self.sigma/self.rc)**6)
+        )
+
+    def calculate(self, coords3d):
+        # Index pairs
+        a, b = np.triu_indices(len(coords3d), 1)
+
+        # Distances
+        diffs = coords3d[a] - coords3d[b]  # Shape: (N_atoms, 3)
+        rs = np.linalg.norm(diffs, axis=1)
+        c6 = np.where(rs <= self.rc, (self.sigma/rs)**6, np.zeros_like(rs))
+        energy = -self.e0 * (c6 != 0.0).sum()
+        c12 = c6**2
+        energy += np.sum(4*self.epsilon * (c12 - c6))
+
+        """
+        Gradient related remarks:
+
+        Lennard-Jones-potential:
+            LJ(r) =
+                4*ε*[(σ/r)**12 - (σ/r)**6]
+
+        Derivative of quotient appearing in LJ potential w.r.t first cartesian
+        coordinate:
+            d(σ/r)**n/dx_1
+                = σ**n * d/dx_1 r**(-n)
+                = σ**n * (-n/2) * (2x1-2x2) * r**(-n) * r**(-2)
+                = σ**n * r**(-n) * (-n) * (x1-x2) * r**(-2)
+                = (σ/r)**n * (-n) * (x1-x2) / r**2
+
+        Derivate w.r.t to cartesian x coordinate of atom A (x_1):
+            dLJ(r)/dx_1 = 
+                24*ε*[-2*(σ/r)**12 + (σ/r)**6]*(x1-x2)/r**2
+
+        Derivate w.r.t to cartesian x coordinate of atom B (x_2):
+            dLJ(r)/dx_2 = 
+                -24*ε*[-2*(σ/r)**12 + (σ/r)**6]*(x1-x2)/r**2
+
+        The derivate w.r.t to x_2 differs only by a factor of -1!
+        """
+        prefactors = 24*self.epsilon * (c6 - 2*c12) / rs**2
+        products = prefactors[:,None] * diffs
+
+        gradient = np.zeros_like(coords3d)
+        # Every pair (a, b) contributes to the total gradient of atoms a and b.
+        for i, prod in enumerate(products):
+            gradient[a[i]] += prod
+            gradient[b[i]] -= prod
+
+        return energy, -gradient
+
+    def get_energy(self, atoms, coords):
+        energy, _ = self.calculate(coords.reshape(-1, 3))
+        return {"energy": energy}
+
+    def get_forces(self, atoms, coords):
+        energy, forces = self.calculate(coords.reshape(-1, 3))
+        return {"energy": energy,
+                "forces": forces.flatten(),
+        }

pysisyphus/calculators/MOPAC.py

@@ -0,0 +1,219 @@
+import re
+import textwrap
+
+import numpy as np
+
+from pysisyphus.constants import BOHR2ANG, AU2KCALPERMOL
+from pysisyphus.calculators.Calculator import Calculator
+from pysisyphus.helpers_pure import file_or_str
+
+
+class MOPAC(Calculator):
+    """http://openmopac.net/manual/"""
+
+    conf_key = "mopac"
+
+    MULT_STRS = {
+        1: "SINGLET",
+        2: "DOUBLET",
+        3: "TRIPLET",
+        4: "QUARTET",
+        5: "QUINTET",
+        6: "SEXTET",
+        7: "SEPTET",
+        8: "OCTET",
+    }
+
+    CALC_TYPES = {
+        "energy": "1SCF",
+        "gradient": "1SCF GRADIENTS",
+        "hessian": "DFORCE FORCE LET",
+    }
+
+    METHODS = [
+        m.lower()
+        for m in "AM1 PM3 PM6 PM6-DH2 PM6-D3 PM6-DH+ PM6-DH2 PM6-DH2X "  # lgtm [py/non-iterable-in-for-loop]
+        "PM6-D3H4 PM6-D3H4X PM7 PM7-TS".split()
+    ]
+
+    def __init__(self, method="PM7", **kwargs):
+        super().__init__(**kwargs)
+
+        self.method = method
+        assert (
+            self.method.lower() in self.METHODS
+        ), f"Invalid method={self.method}! Supported methods are ({self.METHODS})"
+
+        self.uhf = "UHF" if self.mult != 1 else ""
+
+        _ = "mopac"
+        self.inp_fn = f"{_}.mop"
+        self.out_fn = f"{_}.out"
+        self.aux_fn = f"{_}.aux"
+        self.to_keep = ("mop", "out", "arc", "aux")
+
+        self.parser_funcs = {
+            "energy": self.parse_energy,
+            "grad": self.parse_grad,
+            "hessian": self.parse_hessian,
+        }
+
+        self.base_cmd = self.get_cmd()
+
+        """
+        1SCF: Do only SCF
+        AUX: Creates a checkpoint file
+        NOREO: Dont reorient geometry
+        """
+
+        self.inp = textwrap.dedent(
+            """
+        NOSYM {method} {mult} CHARGE={charge} {calc_type} {uhf} THREADS={pal} AUX(6,PRECISION=9) NOREOR
+
+ 
+        {coord_str}
+        """
+        ).strip()
+
+        self.log(f"Created MOPAC calculator using the '{self.method}' method.")
+
+    def prepare_coords(self, atoms, coords, opt=False):
+        coords = coords.reshape(-1, 3) * BOHR2ANG
+        # Optimization flag for coordinate
+        of = 1 if opt else 0
+        coord_str = "\n".join(
+            [
+                f"{a} {c[0]: 10.08f} {of} {c[1]: 10.08f} {of} {c[2]: 10.08f} {of}"
+                for a, c in zip(atoms, coords)
+            ]
+        )
+        return coord_str
+
+    def prepare_input(self, atoms, coords, calc_type, opt=False):
+        coord_str = self.prepare_coords(atoms, coords, opt)
+
+        inp = self.inp.format(
+            method=self.method,
+            charge=self.charge,
+            mult=self.MULT_STRS[self.mult],
+            uhf=self.uhf,
+            calc_type=self.CALC_TYPES[calc_type],
+            coord_str=coord_str,
+            pal=self.pal,
+            # mem=self.mem,
+        )
+        return inp
+
+    def get_energy(self, atoms, coords, **prepare_kwargs):
+        calc_type = "energy"
+        inp = self.prepare_input(atoms, coords, calc_type)
+        # with open("inp.mop", "w") as handle:
+        # handle.write(inp)
+        # import sys; sys.exit()
+        results = self.run(inp, calc="energy")
+        return results
+
+    def get_forces(self, atoms, coords, **prepare_kwargs):
+        calc_type = "gradient"
+        inp = self.prepare_input(atoms, coords, calc_type, opt=True)
+        results = self.run(inp, calc="grad")
+        return results
+
+    def get_hessian(self, atoms, coords, **prepare_kwargs):
+        calc_type = "hessian"
+        inp = self.prepare_input(atoms, coords, calc_type, opt=True)
+        results = self.run(inp, calc="hessian")
+        return results
+
+    def run_calculation(self, atoms, coords, **prepare_kwargs):
+        return self.get_energy(atoms, coords, **prepare_kwargs)
+
+    def read_aux(self, path):
+        with open(path / self.aux_fn) as handle:
+            text = handle.read()
+        return text
+
+    def parse_energy(self, path):
+        return self.parse_energy_from_aux(self.read_aux(path))
+
+    @staticmethod
+    @file_or_str(".aux", method=False)
+    def parse_energy_from_aux(text):
+        energy_re = r"HEAT_OF_FORMATION:KCAL/MOL=([\d\-D+\.]+)"
+        mobj = re.search(energy_re, text)
+        energy = float(mobj[1].replace("D", "E")) / AU2KCALPERMOL
+
+        result = {
+            "energy": energy,
+        }
+        return result
+
+    def parse_grad(self, path):
+        text = self.read_aux(path)
+        # grad_re = "GRADIENTS:KCAL.+$\s+(.+)$"
+        # mobj = re.search(grad_re, text, re.MULTILINE)
+        grad_re = r"GRADIENTS:KCAL/MOL/ANGSTROM\[\d+]=\s+(.+)\s+OVERLAP_MATRIX"
+        mobj = re.search(grad_re, text, re.DOTALL)
+        # Gradients are given in kcal*mol/angstrom
+        gradients = np.array(mobj[1].split(), dtype=float)
+        # Convert to hartree/bohr
+        gradients = gradients / AU2KCALPERMOL / BOHR2ANG
+
+        forces = -gradients
+        result = {
+            "forces": forces,
+        }
+        result.update(self.parse_energy(path))
+        return result
+
+    def parse_hessian(self, path):
+        return self.parse_hessian_from_aux(self.read_aux(path))
+
+    @staticmethod
+    @file_or_str(".aux", method=False)
+    def parse_hessian_from_aux(text):
+        # Parse employed masses, as the given hessian is mass-weighted
+        # and we have to un-weigh it.
+        mass_re = re.compile(
+            r"ISOTOPIC_MASSES\[(\d+)\]=\s*(.+?)ROTAT_CONSTS", re.DOTALL
+        )
+        # mobj = re.search(mass_re, text, re.MULTILINE)
+        mass_mobj = mass_re.search(text)
+        masses = np.array(mass_mobj[2].strip().split(), dtype=float)
+        # This matrix is used to un-weigh the hessian
+        M = np.diag(np.sqrt(np.repeat(masses, 3)))
+        # For N atoms we expect 3N cartesian coordinates
+        coord_num = masses.size * 3
+
+        hess_re = r" #  Lower half triangle only\s+([\s\.\-\d]+)\s+NORMAL_MODE"
+        tril_hess = re.search(hess_re, text)[1].strip().split()
+        tril_hess = np.array(tril_hess, dtype=float)
+        assert tril_hess.size == sum(range(coord_num + 1))
+        hessian_m = np.zeros((coord_num, coord_num))
+        tril_indices = np.tril_indices(coord_num)
+        hessian_m[tril_indices] = tril_hess
+
+        triu_indices = np.triu_indices(coord_num, k=1)
+        hessian_m[triu_indices] = hessian_m.T[triu_indices]
+
+        # Hessian is given in mdyn/(Å*amu).
+        # In a first step we have to unweigh the hessian using the matrix
+        # built from the parsed masses.
+        hessian = M @ hessian_m @ M
+        # Then we have to convert mdyn/Å to Hartree/Bohr²
+        #     mdyn/Å = 100 kg/s²
+        #     Hartree/Bohr² ~  1556.8931 kg/s²
+        #
+        #     1 mydn/Å * (100 / 1556.8931 Hartree/Bohr² * Å/mydn) = 0.06423 Hartree/Bohr²
+        hessian *= 0.06423
+
+        energy = MOPAC.parse_energy_from_aux(text)["energy"]
+
+        result = {
+            "energy": energy,
+            "hessian": hessian,
+        }
+        return result
+
+    def __str__(self):
+        return f"MOPAC({self.name})"

pysisyphus/calculators/MullerBrownSympyPot.py

@@ -0,0 +1,51 @@
+# [1] http://www.cims.nyu.edu/~eve2/string_jcp_simplified07.pdf
+
+import numpy as np
+
+from pysisyphus.calculators.AnaPotBase import AnaPotBase
+
+
+class MullerBrownPot(AnaPotBase):
+    def __init__(self):
+        A = (-200, -100, -170, 15)
+        x0 = (1.0, 0.0, -0.5, -1.0)
+        y0 = (0.0, 0.5, 1.5, 1.0)
+        a = (-1.0, -1.0, -6.5, 0.7)
+        b = (0.0, 0.0, 11.0, 0.6)
+        c = (-10.0, -10.0, -6.5, 0.7)
+
+        # V_str_base = """{Ai} * exp(
+        #                        {ai}*(x-{xi})**2
+        #                        + {bi}*(x-{xi})*(y-{yi})
+        #                        + {ci}*(y-{yi})**2
+        # )"""
+        V_str_base = (
+            "{Ai}*exp({ai}*(x-{xi})**2 + {bi}*(x-{xi})*(y-{yi}) + {ci}*(y-{yi})**2)"
+        )
+        V_str = ""
+        V_strs = [
+            V_str_base.format(Ai=A[i], ai=a[i], xi=x0[i], bi=b[i], yi=y0[i], ci=c[i])
+            for i in range(4)
+        ]
+        V_str = " + ".join(V_strs)
+        xlim = (-1.75, 1.25)
+        ylim = (-0.5, 2.25)
+        levels = np.linspace(-200, 100, 100)
+        minima = (
+            (-0.5582236, 1.441725842, 0.0),
+            (0.62349941, 0.028037758, 0.0),
+            (-0.0435, 0.4648, 0.0),
+        )
+        saddles = ((-0.822, 0.624, 0.0),)
+
+        super(MullerBrownPot, self).__init__(
+            V_str=V_str,
+            xlim=xlim,
+            ylim=ylim,
+            levels=levels,
+            minima=minima,
+            saddles=saddles,
+        )
+
+    def __str__(self):
+        return "MullerBrownPot calculator"

pysisyphus/calculators/MultiCalc.py

@@ -0,0 +1,85 @@
+import sys
+import time
+
+from pysisyphus.calculators.Calculator import Calculator
+from pysisyphus.calculators import ORCA, ORCA5, Turbomole, XTB
+
+CALC_CLASSES = {
+    "orca": ORCA.ORCA,
+    "orca5": ORCA5.ORCA5,
+    "turbomole": Turbomole.Turbomole,
+    "xtb": XTB.XTB,
+}
+
+try:
+    from pysisyphus.calculators import PySCF
+
+    CALC_CLASSES["pyscf"] = PySCF.PySCF
+except ModuleNotFoundError:
+    pass
+
+
+def calcs_from_dict(calc_dict, base_name, calc_number, charge, mult, pal, mem):
+    keys_calcs = {}
+    calc_kwargs_ = {
+        "calc_number": calc_number,
+        "charge": charge,
+        "mult": mult,
+        "pal": pal,
+        "mem": mem,
+    }
+    # Try to distinguish the calculators according to their base_name. If no
+    # base_name is given we rely on the calc_number.
+    base_name = base_name if base_name != "" else f"{calc_number:03d}"
+    for i, (key, kwargs) in enumerate(calc_dict.items()):
+        calc_kwargs = calc_kwargs_.copy()
+        calc_kwargs["base_name"] = f"{base_name}_{key}"
+        # Don't modify original dict
+        kwargs = kwargs.copy()
+        type_ = kwargs.pop("type")
+        calc_kwargs.update(**kwargs)
+        calc_cls = CALC_CLASSES[type_]
+        keys_calcs[key] = calc_cls(**calc_kwargs)
+    return keys_calcs
+
+
+class MultiCalc(Calculator):
+    def __init__(self, calcs, **kwargs):
+        super().__init__(**kwargs)
+
+        self.do_hess = {
+            key: calc_dict.pop("do_hess", False) for key, calc_dict in calcs.items()
+        }
+        self.keys_calcs = calcs_from_dict(
+            calcs,
+            self.base_name,
+            self.calc_number,
+            self.charge,
+            self.mult,
+            self.pal,
+            self.mem,
+        )
+        max_len = max([len(key) for key in self.keys_calcs.keys()])
+        self.max_fmt = f" >{max_len+2}"
+
+    def run_calculation(self, atoms, coords, **prepare_kwargs):
+        all_results = {}
+        for name, calc in self.keys_calcs.items():
+            if self.do_hess[name]:
+                run_func = calc.get_hessian
+            else:
+                run_func = calc.run_calculation
+            key = f"{self.base_name}_{name}"
+            print(f"Running {name:{self.max_fmt}} ... ", end="")
+            try:
+                start = time.time()
+                results = run_func(atoms, coords, **prepare_kwargs)
+                end = time.time()
+                duration = end - start
+                print(f"took {duration:.0f} s.")
+            except Exception as err:
+                print("\nCalculation failed!")
+                print(err)
+            sys.stdout.flush()
+            all_results[key] = results
+        return all_results

pysisyphus/calculators/NFK.py

@@ -0,0 +1,45 @@
+# [1] https://doi.org/10.1016/j.cplett.2004.07.079
+#     The reaction pathway of a potential energy surface as curve
+#     with induced tangent
+#     Hirsch, Quapp, 2004
+
+
+import numpy as np
+
+from pysisyphus.calculators.AnaPotBase import AnaPotBase
+
+
+class NFK(AnaPotBase):
+    def __init__(self, C=0.06, **kwargs):
+        """NFK surface of Hirsch and Quapp.
+
+        See Fig. 4 in [1] and the appendix.
+        """
+
+        # Note that C is substituted in
+        V_str = f"{C} * (x**2 + y**2)**2 + x*y - 9*exp(-(x-3)**2-y**2) - 9*exp(-(x+3)**2 - y**2)"
+        kwargs_ = {
+            "V_str": V_str,
+            "xlim": (-3, 3),
+            "ylim": (-3, 3),
+            "levels": np.linspace(-7, 3.5, 70),
+            "minima": ((2.71268103, -0.15093971, 0.0), (-2.7126810, 0.1509397, 0.0)),
+            "saddles": ((0.0, 0.0, 0.0),),
+        }
+        kwargs_.update(kwargs)
+        super().__init__(**kwargs_)
+
+    def __str__(self):
+        return "NFK calculator"
+
+
+class ModNFK(NFK):
+    def __init__(self, C=0.03, **kwargs):
+        kwargs["minima"] = (
+            (-2.84721930, 0.15702574, 0.0),
+            (2.84721930, -0.15702574, 0.0),
+        )
+        super().__init__(C, **kwargs)
+
+    def __str__(self):
+        return "ModNFK calculator"