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

pysisyphus/calculators/parser.py

@@ -0,0 +1,150 @@
+import glob
+import os
+
+import numpy as np
+import pyparsing as pp
+import re
+
+
+def to_float(s, loc, toks):
+    match = toks[0].replace("D", "E")
+    return float(match)
+
+
+def make_float_class(**kwargs):
+    return pp.Word(pp.nums + ".-DE+", **kwargs).setParseAction(to_float)
+
+
+def parse_turbo_gradient(path):
+    results = {}
+    gradient_fn = glob.glob(os.path.join(path, "gradient"))
+    if not gradient_fn:
+        raise Exception("gradient file not found!")
+    assert len(gradient_fn) == 1
+    gradient_fn = gradient_fn[0]
+    with open(gradient_fn) as handle:
+        text = handle.read()
+
+    float_ = make_float_class()
+    cycle = pp.Word(pp.nums).setResultsName("cycle")
+    scf_energy = float_.setResultsName("scf_energy")
+    grad_norm = float_.setResultsName("grad_norm")
+    float_line = float_ + float_ + float_
+    coord_line = pp.Group(float_line + pp.Word(pp.alphas))
+    grad_line = pp.Group(float_line)
+    cart_grads = pp.Literal("cartesian gradients")
+    energy_type = pp.Or(
+        (
+            pp.Literal("SCF energy"),
+            pp.Literal("ex. state energy"),
+            pp.Literal("CC2 energy"),
+            pp.Literal("ADC(2) energy"),
+            pp.Literal("MP2 energy"),
+        )
+    )
+
+    parser = (
+        pp.Or((pp.Literal("$grad"), pp.Literal("$gradient")))
+        + pp.Optional(cart_grads)
+        + pp.Literal("cycle =")
+        + cycle
+        + energy_type
+        + pp.Literal("=")
+        + scf_energy
+        + pp.Literal("|dE/dxyz| =")
+        + grad_norm
+        + pp.OneOrMore(coord_line).setResultsName("coords")
+        + pp.OneOrMore(grad_line).setResultsName("grad")
+        + pp.Literal("$end")
+    )
+    parsed = parser.parseString(text)
+    gradient = np.array(parsed["grad"].asList()).flatten()
+
+    results["energy"] = parsed["scf_energy"]
+    results["forces"] = -gradient
+    return results
+
+
+def parse_turbo_ccre0_ascii(text):
+    float_ = make_float_class()
+    float_20 = make_float_class(exact=20)
+    int_ = pp.Word(pp.nums).setParseAction(lambda s, loc, toks: int(toks[0]))
+
+    title = pp.Literal("$CCRE0-") + pp.Word(pp.nums + "-")
+    method = pp.Word(pp.alphanums + "()") + float_ + float_ + int_ + int_ + int_
+    data = pp.Group(pp.OneOrMore(float_20))
+    end = pp.Literal("$end")
+
+    parser = title + method + data.setResultsName("data") + end
+    result = parser.parseString(text)
+    data = np.array(result["data"].asList())
+    return data
+
+
+def parse_turbo_mos(text):
+    float_20 = make_float_class(exact=20)
+    int_ = pp.Word(pp.nums)
+    comment = pp.Literal("#") + pp.restOfLine
+
+    mo_num = int_
+    sym = pp.Word(pp.alphanums)
+    eigenvalue = pp.Literal("eigenvalue=") + float_20
+    nsaos = pp.Literal("nsaos=") + int_
+    mo_coeffs = pp.OneOrMore(float_20)
+
+    mo = pp.Group(
+        mo_num + sym + eigenvalue + nsaos + mo_coeffs.setResultsName("mo_coeffs")
+    )
+
+    parser = (
+        pp.Literal("$scfmo")
+        + pp.Literal("scfconv=")
+        + pp.Word(pp.nums)
+        + pp.Literal("format(4d20.14) ")
+        + pp.ZeroOrMore(comment)
+        + pp.OneOrMore(mo).setResultsName("mos")
+        + pp.Literal("$end")
+    )
+    parsed = parser.parseString(text)
+    mo_coeffs = np.array([mo.mo_coeffs.asList() for mo in parsed.mos]).T
+
+    # MOs are in columns
+    return mo_coeffs
+
+
+def parse_turbo_exstates(text):
+    """Parse excitation energies (first blocks) from an exstates file."""
+    float_ = make_float_class()
+    exc_energies_line = (
+        pp.Literal("$excitation_energies_")
+        + pp.Word(pp.alphanums + "()").setResultsName("model")
+        + pp.Word("_")
+        + pp.restOfLine
+    )
+    exc_energy = pp.Suppress(pp.Word(pp.nums)) + float_
+    exc_energies_block = pp.Group(
+        exc_energies_line + pp.Group(pp.OneOrMore(exc_energy)).setResultsName("exc_ens")
+    )
+
+    parser = pp.OneOrMore(exc_energies_block).setResultsName("exc_blocks")
+    result = parser.parseString(text)
+    exc_energies_by_model = [(b.model, b.exc_ens.asList()) for b in result.exc_blocks]
+    return exc_energies_by_model
+
+
+def parse_turbo_exstates_re(text):
+    results = dict()
+    exc_ens_str = "excitation_energies_"
+    model_re = re.compile(exc_ens_str + r"(\w+?)_")
+    blocks = text.strip().split("$")
+    for block in blocks:
+        if not block.startswith(exc_ens_str):
+            continue
+        model_line, *exc_lines = block.strip().split("\n")
+        mobj = model_re.search(model_line)
+        model = mobj.group(1)
+        exc_lines = [line.strip().split() for line in exc_lines]
+        assert all([len(line) == 2 for line in exc_lines])
+        exc_ens = np.array([exc_en for _, exc_en in exc_lines], dtype=float)
+        results[model] = exc_ens
+    return results

pysisyphus/color.py

@@ -0,0 +1,19 @@
+def red(str_):
+    return f"\033[91m{str_}\033[0m"
+
+
+def green(str_):
+    return f"\033[92m{str_}\033[0m"
+
+
+BOOL_COLORS = {
+    True: green,
+    False: red,
+}
+
+
+def bool_color(bool_, str_=None):
+    if str_ is None:
+        str_ = str(bool_)
+    color = BOOL_COLORS[bool_]
+    return color(str_)

pysisyphus/config.py

@@ -0,0 +1,133 @@
+import argparse
+import configparser
+from io import StringIO
+import os
+from pathlib import Path
+import shutil
+import sys
+import tempfile
+
+
+from pysisyphus import logger
+
+
+CONFIG_DIR = Path(os.path.abspath(os.path.dirname(__file__)))
+BASIS_LIB_DIR = Path(CONFIG_DIR / "basis_library")
+LIB_DIR = Path(CONFIG_DIR / "geom_library")
+WF_LIB_DIR = Path(CONFIG_DIR / "wf_library")
+T_DEFAULT = 298.15  # Kelvin
+p_DEFAULT = 101325  # Pascal
+OUT_DIR_DEFAULT = str(Path(tempfile.gettempdir()) / "qm_calcs")
+BEND_MIN_DEG = 15
+LB_MIN_DEG = 175
+DIHED_MAX_DEG = 175
+L_MAX = 4
+L_AUX_MAX = 5
+AFIR_RMSD_THRESH = 0.25
+DEFAULTS = {
+    # .pysisyphusrc key: command
+    "mwfn": "Multiwfn",
+    "jmol": "jmol",
+    "packmol": "packmol",
+    "formchk": "formchk",
+    "unfchk": "unfchk",
+    "rwfdump": "rwfdump",
+    # QC codes
+    "orca": "orca",
+    "orca5": "orca",
+    "gaussian16": "g16",
+    "wfoverlap": "wfoverlap.x",
+    "openmolcas": "pymolcas",
+    "gamess": "rungms",
+    "xtb": "xtb",
+    "mopac": "mopac",
+}
+
+
+# First try to read path to .pysisyphusrc from environment variable
+try:
+    pysisrc_env = os.getenv("PYSISRC", default=None)
+    config_fn = Path(pysisrc_env).resolve()
+    print(f"Read pysisyphus configuration from '{config_fn}'")
+# Fallback to $HOME/.pysisyphusrc
+except TypeError:
+    config_fn = Path.home() / ".pysisyphusrc"
+
+if not config_fn.is_file():
+    print(f"Couldn't find configuration file. Expected it at '{config_fn}'.")
+
+Config = configparser.ConfigParser()
+read_fns = Config.read(config_fn)
+
+
+def get_cmd(section, key="cmd", use_defaults=True):
+    cmd = None
+    msg = f" and no default was specified for '{section}'."
+
+    # First we try to load the command from .pysisyphusrc
+    try:
+        cmd = Config[section][key]
+        msg = "."
+    # When the command is not available on .pysisyphusrc we check the defaults
+    except KeyError:
+        if use_defaults:
+            default_key = section if key == "cmd" else key
+            try:
+                default_cmd = DEFAULTS[default_key]
+                cmd = shutil.which(default_cmd)
+                # 'msg' will only be printed when 'cmd' is None, so the msg is
+                # always negative.
+                msg = f" and default cmd='{default_cmd}' was not found in $PATH."
+            except KeyError:
+                pass
+
+    if cmd is None:
+        logger.warning(
+            f"Failed to load '{key}' from [{section}] "
+            f"in ~/.pysisyphusrc{msg}"
+        )
+        cmd = None
+    return cmd
+
+
+def detect_paths():
+    config = configparser.ConfigParser()
+
+    for k, v in DEFAULTS.items():
+        print(f"{k: >16}: ... ", end="")
+        if not (path := shutil.which(v)):
+            print("not found.")
+        else:
+            path = Path(path).resolve()
+            config[k] = {"cmd": str(path)}
+            print(path)
+
+    fp = StringIO()
+    config.write(fp, space_around_delimiters=False)
+    fp.seek(0)
+    config_text = fp.read()
+    return config_text
+
+
+def parse_args(args):
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--out", "-o", help="Filename to which the detected cmds are dumped."
+    )
+
+    return parser.parse_args(args)
+
+
+def run_detect_paths():
+    args = parse_args(sys.argv[1:])
+    out = args.out
+
+    config_text = detect_paths()
+    if out:
+        print("Dumped detected cmds to '{out}'")
+        with open(out, "w") as handle:
+            handle.write(config_text)
+    else:
+        print("\nExample .pysisyphusrc:\n")
+        print(config_text)

pysisyphus/constants.py

@@ -0,0 +1,65 @@
+import scipy.constants as spc
+
+PI = spc.pi
+
+# Speed of light in m/s
+C = spc.c
+# Speed of light in atomic units
+CAU = spc.value("inverse fine-structure constant")
+# ħ = h / 2π in J/s
+HBAR = spc.hbar
+# h
+PLANCK = spc.Planck
+PLANCKAU = 2 * spc.pi  # With ħ_au = 1 and ħ_au=h_au/2π -> h_au = 2π
+# Conversion factor for momentum in SI to atomic units
+P_AU = spc.value("atomic unit of momentum")
+
+# Bohr radius in m
+BOHR2M = spc.value("Bohr radius")
+# Bohr -> Å conversion factor
+BOHR2ANG = BOHR2M * 1e10
+# Å -> Bohr conversion factor
+ANG2BOHR = 1 / BOHR2ANG
+# Hartree to J
+AU2J = spc.value("Hartree energy")
+# Hartree to kJ / mol
+AU2KJPERMOL = AU2J / 1000 * spc.Avogadro
+# Hartree to kcal mol⁻¹
+AU2KCALPERMOL = AU2KJPERMOL / spc.calorie
+# Hartree to eV
+AU2EV = spc.value("Hartree energy in eV")
+# Joule to eV
+JOULE2EV = AU2EV / AU2J
+# Wavenumber to Hartree
+NU2AU = spc.h * C * 1e2 / AU2J
+# eV/Å -> Hartree/Bohr
+EVANG2AUBOHR = 1 / AU2EV / ANG2BOHR
+# fs -> Bohr * sqrt(amu/Hartree)
+FS2AU = 0.9682885864793366
+# Boltzman constant, (m² kg s⁻² K⁻¹) or just (J / K)
+KB = spc.Boltzmann
+KBAU = KB / AU2J
+# Ideal gas constant
+R = spc.gas_constant
+# Atomic unit of time to second
+AU2SEC = spc.value("atomic unit of time")
+# Atomic mass unit to kg
+AMU2KG = spc.value("atomic mass constant")
+M_E = spc.electron_mass
+AMU2AU = AMU2KG / M_E
+# Avogadro constant
+NA = spc.Avogadro
+
+##############
+# MD related #
+##############
+
+# Force/amu to acceleration
+#   Hartree/(Bohr*amu) -> Bohr / fs²
+FORCE2ACC = AU2J / (AMU2KG * BOHR2M**2 * 1e30)
+# Velocity*amu -> Energy
+#   Bohr²/fs²*amu -> Hartree
+# VELO2E = AMU2KG * BOHR2M**2 / (1e-30 * AU2J)
+VELO2E = 1 / FORCE2ACC
+# Velocity from Bohr/fs to Bohr/t_atomic_unit
+BOHRPERFS2AU = AU2SEC * 1e15

pysisyphus/cos/AdaptiveNEB.py

@@ -0,0 +1,230 @@
+# [1] https://aip.scitation.org/doi/pdf/10.1063/1.1495401
+# [2] http://dx.doi.org/10.1063/1.4962019
+#     Zhang, 2016
+#     FreeEnd Adaptive NEB
+
+# See /scratch/projekte/biaryl/me_cn/cycloadd22/guess01/neb2
+
+import numpy as np
+
+from pysisyphus.cos.NEB import NEB
+from pysisyphus.interpolate import interpolate
+
+
+class AdaptiveNEB(NEB):
+
+    def __init__(self, images, adapt=True, adapt_fact=.25, adapt_between=1,
+                 scale_fact=False, keep_hei=True, free_ends=True,
+                 **kwargs):
+        """(Free-End) Adaptive Nudged Elastic Band.
+
+        Parameters
+        ----------
+        images : list of Geometry objects
+            Images of the band.
+        adapt : bool, default True
+            Whether to adapt the image number or not. This switch is included
+            to support the FreeEndNEB class, that is just a thin wrapper around
+            this class.
+        adapt_fact : positive float
+            Factor that is used to decide wether to adapt. The inital
+            threshold is calculated by multiplying the RMS force of the
+            band with this factor. When the RMS of the force falls
+            below this threshold adaption takes place.
+        adapat_between : positive integer
+            Number of images to interpolate between the highest energy
+            image and its neighbours. The number of starting images
+            must be higher or equal then 2*adapt_between+3, as we
+            reuse/transfer the calculators from the starting images onto
+            the new ones.
+        scale_fact : bool, default False
+            Whether to increase adapt_fact in deeper levels. This may lead
+            to earlier adapation.
+        keep_hei : bool, optional
+            Whether to keep the highest energy image (usually a very good
+            idea) or to interpolate only between the neighbouring images.
+        free_ends : bool, default True
+            Whether to use modified forces on the end images.
+        """
+        super().__init__(images, **kwargs)
+
+        self.adapt = adapt
+        self.adapt_fact = adapt_fact
+        self.adapt_between = adapt_between
+        self.scale_fact = scale_fact
+        self.keep_hei = keep_hei
+        self.free_ends = free_ends
+
+        self.adapt_thresh = None
+        self.level = 1
+        self.coords_backup = list()
+
+    @NEB.forces.getter
+    def forces(self):
+        """See Eq. (7) in [2]."""
+
+        forces = super().forces
+        forces_size = self.images[-1].forces.size
+
+        if self.free_ends and (not self.fix_first):
+            mod_forces = self.get_perpendicular_forces(0)
+            forces[:forces_size] = mod_forces
+
+        if self.free_ends and (not self.fix_last):
+            mod_forces = self.get_perpendicular_forces(self.last_index)
+            forces[-forces_size:] = mod_forces
+
+        self._forces = forces
+        return self._forces
+
+    def update_adapt_thresh(self, forces):
+        """Update the adaption threshold.
+
+        Parameters
+        ----------
+        forces : np.array
+            Forces of the previous optimization cycle.
+        """
+        old_thresh = self.adapt_thresh
+
+        # Dividing by (1 / level)**1/2 scales the adapt_fact as
+        # level 1: 1. (No scaling)
+        # level 2: 1.414
+        # level 3: 1.732
+        # level 4: 2.
+        # level 5: 2.236
+        # ...
+        # This ensures that the adapt_fact increases as we recurse
+        # deeper.
+        if self.scale_fact:
+            self.adapt_thresh = (self.rms(forces) * self.adapt_fact
+                                 / np.sqrt(1 / self.level)
+            )
+        else:
+            self.adapt_thresh = self.rms(forces) * self.adapt_fact
+        #arr / np.sqrt(1/np.arange(1, 6))
+        self.log(f"Updating adapt_thres. Old thresh was {old_thresh:}. "
+                 f"New threshold is {self.adapt_thresh:.03f}")
+
+    def adapt_this_cycle(self, forces):
+        """Decide wether to adapt.
+
+        Parameters
+        ----------
+        forces : np.array
+            Forces of the previous optimization cycle.
+
+        Returns
+        -------
+        adapt : bool
+            Flag that indicates if adaption should take place in this cycle.
+        """
+        cur_rms = self.rms(forces)
+        adapt = cur_rms <= self.adapt_thresh
+        self.log(f"Current RMS of forces is {cur_rms:03f}. Current thresh "
+                 f"{self.adapt_thresh:03f}. Adapt = {adapt}")
+        return adapt
+
+    def prepare_opt_cycle(self, *args, **kwargs):
+        """Check for adaption and adapt if needed.
+
+        See ChainOfStates.prepare_opt_cycle for a complete docstring.
+        """
+        base_reset = super().prepare_opt_cycle(*args, **kwargs)
+        if not self.adapt:
+            return base_reset
+
+        # Transferring Calculators including WFOWrapper objects
+        # in excited state calculations may be problematic.
+        # A problem would be the interpolation between two images with
+        # different roots. What root should be taken for the interpolated
+        # image? Additionally we probably would have to shift around the
+        # iterations stored in the WFOWrapper.
+        img0 = self.images[0]
+        if hasattr(img0, "track") and (img0.track == True):
+            raise Exception(
+                "track = True and interpolating new images "
+                "may give problems with excited state tracking, so this "
+                "is disabled for now."
+            )
+
+        # Initialize adapt_thresh
+        if not self.adapt_thresh:
+            self.update_adapt_thresh(self.forces_list[-1])
+
+        if not self.adapt_this_cycle(self.forces_list[-1]):
+            return base_reset
+
+        #
+        # Adapation from here on
+        #
+        # Backup coords if we have to step back
+        self.coords_backup.append(self.coords)
+        # Determine highest energy index and image (HEI)
+        hei_index = self.get_hei_index(self.all_energies[-1])
+        self.log(f"Index of highest energy image is {hei_index}")
+        if (hei_index == 0) or (hei_index == len(self.images)-1):
+            self.log("Cant adapt, HEI is first or last!")
+            return base_reset
+        else:
+            self.fix_first = False
+            self.fix_last = False
+            self.log("First and last image are now free to move.")
+        prev_index = hei_index - 1
+        next_index = hei_index + 1
+        prev_image = self.images[prev_index]
+        hei_image = self.images[hei_index]
+        next_image = self.images[next_index]
+
+        # Two interpolations
+        #   prev. neighbour - HEI
+        #   HEI - next neighbour
+        # Usually the better idea
+        kwargs = {
+            "kind": "lst",
+            "only_between": True,
+            "interpol_kwargs": {"silent": True},
+        }
+        if self.keep_hei:
+            # Interpolation of new images between previous neighbour
+            # and the HEI.
+            kwargs["between"] = self.adapt_between
+            new_images_1 = interpolate(prev_image, hei_image, **kwargs)
+            new_images_2 = interpolate(hei_image, next_image, **kwargs)
+            # Between next neighbour and the HEI.
+            all_new_images = ([prev_image] + new_images_1
+                              + [hei_image]
+                              + new_images_2 + [next_image])
+        # One interpolation
+        #   prev. neighbour - next neighbour
+        else:
+            kwargs["between"] = 2*self.adapt_between+1
+            new_images = interpolate(prev_image, next_image, **kwargs)
+            all_new_images = [prev_image] + new_images + [next_image]
+
+        assert len(all_new_images) <= len(self.images), \
+            f"The number of new images ({len(all_new_images)}) is smaller than " \
+            f"the number of current images ({len(self.images)}). Increase the number " \
+             "of starting images or decrease 'adapt_between'."
+        self.level += 1
+
+        print(f"Adapted images! New number of images is {len(all_new_images)}. "
+              f"Current level is {self.level}.")
+
+        # Backup old calculators
+        calcs = [img.calculator for img in self.images]
+        # Get numbered indices of the current calcs, so we can continue with
+        # higher numbers for the new images.
+        calc_numbers = [calc.calc_number for calc in calcs]
+        new_calc_number_start = max(calc_numbers) + 1
+        # Transfer calculators to the new images
+        for i, (new_image, calc) in enumerate(zip(all_new_images, calcs)):
+            calc.calc_number = new_calc_number_start + i
+            new_image.set_calculator(calc)
+        self.images = all_new_images
+        self.set_zero_forces_for_fixed_images()
+
+        # Reset adapt_thresh so it will be set again in the beginning
+        # of the next iteration.
+        self.adapt_thresh = None
+        return True