micki 2.0.0__py3-none-any.whl

micki/__init__.py

@@ -0,0 +1,8 @@
+from micki.reactants import Liquid, Gas, Adsorbate, Electron
+from micki.model import Reaction, Model
+from micki.eref import EnergyReference
+from micki.analysis import ModelAnalysis
+from micki.lattice import Lattice
+
+__all__ = ['Liquid', 'Gas', 'Adsorbate', 'Electron', 'Reaction', 'Model',
+           'EnergyReference', 'ModelAnalysis', 'Lattice']

micki/analysis.py

@@ -0,0 +1,287 @@
+"""Module for doing sensitivity analysis of microkinetic model"""
+
+import collections.abc
+
+import numpy as np
+import sympy as sym
+
+from ase.units import kB
+
+from micki.reactants import Adsorbate, _Fluid
+
+
+class ModelAnalysis:
+    def __init__(self, model, product_reaction, Uequil, tol=1e-3, dt=3600):
+        self.model = model
+        self.reaction_name = product_reaction
+        self.product_reaction = model.reactions[product_reaction]
+        self.Uequil = Uequil
+        self.tol = tol
+        self.dt = dt
+
+        self.model.set_initial_conditions(self.Uequil)
+
+        t, self.U, self.r = self.model.find_steady_state()
+        model.finalize()
+
+        self.species_symbols = []
+        for species in self.model._species:
+            if species.symbol is not None:
+                self.species_symbols.append(species)
+        self.rmid = self.r[self.reaction_name]
+
+    def campbell_rate_control(self, rxn_name, scale=0.001):
+        reaction = self.model.reactions[rxn_name]
+
+        subs = {}
+        for species in self.species_symbols:
+            subs[species.symbol] = self.U[species.label]
+
+        kmid = reaction.get_kfor(self.model.T,
+                                 self.model.Asite,
+                                 self.model.z)
+
+        if isinstance(kmid, sym.Basic):
+            kmid = kmid.subs(subs)
+
+        reaction.set_scale('kfor', 1.0 - scale)
+        reaction.set_scale('krev', 1.0 - scale)
+        reaction.update(self.model.T,
+                        self.model.Asite,
+                        self.model.z,
+                        force=True)
+        klow = reaction.get_kfor()
+        model = self.model.copy()
+
+        try:
+            t1, U1, r1 = model.find_steady_state()
+        finally:
+            reaction.set_scale('kfor', 1.0)
+            reaction.set_scale('krev', 1.0)
+
+        model.finalize()
+        rlow = r1[self.reaction_name]
+        if isinstance(klow, sym.Basic):
+            subs = {}
+            for species in self.species_symbols:
+                subs[species.symbol] = U1[species.label]
+            klow = klow.subs(subs)
+
+        reaction.set_scale('kfor', 1.0 + scale)
+        reaction.set_scale('krev', 1.0 + scale)
+        reaction.update(self.model.T,
+                        self.model.Asite,
+                        self.model.z,
+                        force=True)
+        khigh = reaction.get_kfor()
+        model = self.model.copy()
+
+        try:
+            t2, U2, r2 = model.find_steady_state()
+        finally:
+            reaction.set_scale('kfor', 1.0)
+            reaction.set_scale('krev', 1.0)
+
+        model.finalize()
+        rhigh = r2[self.reaction_name]
+        if isinstance(khigh, sym.Basic):
+            subs = {}
+            for species in self.species_symbols:
+                subs[species.symbol] = U2[species.label]
+            khigh = khigh.subs(subs)
+        reaction.set_scale('kfor', 1.0)
+        reaction.set_scale('krev', 1.0)
+
+        return kmid * (rhigh - rlow) / (self.rmid * (khigh - klow))
+
+    def thermodynamic_rate_control(self, names, dg=None):
+        """Degree of thermodynamic rate control, -(kT/r) dr/dG.
+
+        The free energies of all species in `names` are shifted together
+        by -dg and +dg (default 0.001 kT) and the derivative is taken by
+        central differences.
+        """
+        T = self.model.T
+        if dg is None:
+            dg = 0.001 * kB * T
+
+        if not isinstance(names, (list, tuple)):
+            species = [self.model.species[names]]
+        else:
+            species = [self.model.species[name] for name in names]
+
+        for sp in species:
+            sp.dE -= dg
+
+        for reaction in self.model._reactions:
+            reaction.update(T=self.model.T,
+                            Asite=self.model.Asite,
+                            L=self.model.z,
+                            force=True)
+
+        model = self.model.copy(initialize=False)
+        model.set_initial_conditions(self.U)
+
+        try:
+            t1, U1, r1 = model.find_steady_state()
+        finally:
+            for sp in species:
+                sp.dE += dg
+
+        model.finalize()
+        rlow = r1[self.reaction_name]
+
+        for sp in species:
+            sp.dE += dg
+
+        for reaction in self.model._reactions:
+            reaction.update(T=self.model.T,
+                            Asite=self.model.Asite,
+                            L=self.model.z,
+                            force=True)
+
+        model = self.model.copy(initialize=False)
+        model.set_initial_conditions(self.U)
+
+        try:
+            t2, U2, r2 = model.find_steady_state()
+        finally:
+            for sp in species:
+                sp.dE -= dg
+
+        for reaction in self.model._reactions:
+            reaction.update(T=self.model.T,
+                            Asite=self.model.Asite,
+                            L=self.model.z,
+                            force=True)
+
+        model.finalize()
+        rhigh = r2[self.reaction_name]
+
+        # central difference: the two rates are 2 * dg apart in free energy
+        return (rlow - rhigh) * kB * T / (self.rmid * 2 * dg)
+
+    def activation_barrier(self, dT=0.01):
+        T = self.model.T
+
+        model = self.model.copy(initialize=False)
+        model.T = T - dT
+        model.set_initial_conditions(self.Uequil)
+        t1, U1, r1 = model.find_steady_state()
+        model.finalize()
+
+        rlow = r1[self.reaction_name]
+
+        model = self.model.copy(initialize=False)
+        model.T = T + dT
+        model.set_initial_conditions(self.Uequil)
+        t2, U2, r2 = model.find_steady_state()
+        model.finalize()
+
+        rhigh = r2[self.reaction_name]
+
+        return kB * T**2 * (rhigh - rlow) / (self.rmid * 2 * dT)
+
+    def rate_order(self, name, drho=0.05):
+        species = self.model.species[name]
+
+        rhomid = self.Uequil[species.label]
+        if not rhomid > 0:
+            raise ValueError('{} has no positive concentration'.format(name))
+
+        U0 = self.Uequil.copy()
+        rholow = rhomid * (1.0 - drho)
+        U0[species.label] = rholow
+        model = self.model.copy(initialize=False)
+        model.set_initial_conditions(U0)
+        t1, U1, r1 = model.find_steady_state()
+        model.finalize()
+        rlow = r1[self.reaction_name]
+
+        rhohigh = rhomid * (1.0 + drho)
+        U0[species.label] = rhohigh
+        model.set_initial_conditions(U0)
+        t2, U2, r2 = model.find_steady_state()
+        model.finalize()
+        rhigh = r2[self.reaction_name]
+
+        return (rhomid / self.rmid) * (rhigh - rlow) / (rhohigh - rholow)
+
+    def drate_order_dg(self, fluid, adsorbates, rho_scale=0.01, g_scale=0.01):
+        """(rho/r) d^2 r / (d rho dG): the change of the rate order in
+        `fluid` with the free energy of `adsorbates` (shifted together).
+
+        Central differences in the concentration of `fluid` (+-drho) and in
+        the free energies of `adsorbates` (+-dg).
+        """
+        if not isinstance(fluid, _Fluid):
+            raise TypeError('fluid must be a Gas or Liquid species')
+
+        if not isinstance(adsorbates, collections.abc.Iterable):
+            adsorbates = [adsorbates]
+
+        if not isinstance(adsorbates[0], Adsorbate):
+            raise TypeError('adsorbates must be Adsorbate species')
+
+        rhomid = self.U[fluid.label]
+        if not rhomid > 0:
+            raise ValueError('{} has no positive concentration'
+                             ''.format(fluid.label))
+        rmid = self.r[self.reaction_name]
+        gmid = adsorbates[0].get_G(self.model.T)
+        if isinstance(gmid, sym.Basic):
+            trans = {}
+            for species in self.model._species:
+                if isinstance(species, Adsorbate) \
+                        and species.symbol is not None:
+                    trans[species.symbol] = self.U[species.label]
+            gmid = gmid.subs(trans)
+        dg = np.abs(gmid * g_scale * 2)
+        drho = rhomid * rho_scale * 2
+
+        dr = 0
+
+        def set_dg(species, dg):
+            species.dE += dg
+
+        for i in [-1, 1]:
+            for adsorbate in adsorbates:
+                set_dg(adsorbate, i * dg)
+
+            for reaction in self.model._reactions:
+                reaction.update(T=self.model.T,
+                                Asite=self.model.Asite,
+                                L=self.model.z,
+                                force=True)
+
+            for j in [-1, 1]:
+                U0 = self.Uequil.copy()
+                U0[fluid.label] = rhomid + j * drho
+
+                model = self.model.copy(initialize=False)
+                model.set_initial_conditions(U0)
+
+                ti, Ui, ri = model.find_steady_state()
+                dr += i * j * ri[self.reaction_name]
+
+            for adsorbate in adsorbates:
+                set_dg(adsorbate, -i * dg)
+
+        for reaction in self.model._reactions:
+            reaction.update(T=self.model.T,
+                            Asite=self.model.Asite,
+                            L=self.model.z,
+                            force=True)
+
+        # the four rates are 2 * dg and 2 * drho apart
+        return (rhomid / rmid) * dr / (4 * dg * drho)
+
+    def check_converged(self, *vals):
+        for val in vals:
+            for i, key in enumerate(val[0]):
+                if np.abs(val[-1][key] - val[-2][key]) > self.tol:
+                    raise ValueError("Calculation not converged ({}: {}, "
+                                     "change {})! Increase dt or use better "
+                                     "initial guess.".format(
+                                         key, val[-1][key],
+                                         val[-1][key] - val[-2][key]))

micki/db.py

@@ -0,0 +1,80 @@
+import warnings
+
+from ase.db import connect
+from ase.db.core import Database
+
+from micki.reactants import Adsorbate, Gas, Liquid
+from micki.eref import EnergyReference
+
+class MickiDBReadError(ValueError):
+    pass
+
+# Attempts to parse attribute 'name' from dictionary 'data' and raises a
+# parse error if it cannot be found.
+def get_data(row, param):
+    if param not in row.data:
+        raise MickiDBReadError("DB row named {} does not have '{}' entry!"
+                               "".format(row.name, param))
+    return row.data[param]
+
+# Converts a single ASE DB row to a Micki Thermo object.
+def row_to_thermo(row):
+    name = row.name
+    freqs = get_data(row, 'freqs')
+    thermo = get_data(row, 'thermo')
+    sites = get_data(row, 'sites')
+    rhoref = get_data(row, 'rhoref')
+    dE = get_data(row, 'dE')
+    symm = get_data(row, 'symm')
+    ts = get_data(row, 'ts')
+    spin = get_data(row, 'spin')
+    D = get_data(row, 'D')
+    S = get_data(row, 'S')
+
+    if thermo == 'Adsorbate':
+        return Adsorbate(row.toatoms(), name, freqs,
+                         ts=ts, sites=sites, dE=dE, symm=symm)
+    elif thermo == 'Gas':
+        return Gas(row.toatoms(), name, freqs,
+                   symm=symm, spin=spin, rhoref=rhoref, dE=dE)
+    elif thermo == 'Liquid':
+        return Liquid(row.toatoms(), name, freqs,
+                      symm=symm, spin=spin, D=D, S=S, rhoref=rhoref, dE=dE)
+    else:
+        raise ValueError('Unknown Thermo type {}!'.format(thermo))
+
+# Creates a dictionary of Thermo objects from a properly-formatted ASE DB file.
+def read_from_db(db, names=None, eref=None):
+    if isinstance(db, str):
+        db = connect(db)
+    elif not isinstance(db, Database):
+        raise ValueError("Must pass active ASE DB connection, "
+                         "or name of ASE DB file!")
+
+    species = {}
+
+    for row in db.select():
+        name = row.name
+        try:
+            species[name] = row_to_thermo(row)
+        except MickiDBReadError:
+            warnings.warn("Could not parse row {}, skipping.".format(name),
+                          RuntimeWarning, stacklevel=2)
+
+    for name, sp in species.items():
+        newsites = []
+        for site in sp.sites:
+            if site in species:
+                newsites.append(species[site])
+            else:
+                raise ValueError("Unknown site named {}!".format(site))
+        sp.sites = newsites
+
+    if eref is not None:
+        reference = EnergyReference([species[name] for name in eref])
+        for name, sp in species.items():
+            sp.eref = reference
+
+    if names is not None:
+        return {name: species[name] for name in names}
+    return species

micki/eref.py

@@ -0,0 +1,85 @@
+"""Reference atoms object"""
+
+import numpy as np
+
+from ase import Atoms
+from ase.io import read
+from ase.data import chemical_symbols
+from ase.db.row import AtomsRow
+
+from micki.reactants import _Thermo
+
+
+class EnergyReference(dict):
+    """Construct an atomic energy reference.
+
+    This routine accepts an iterable containing N paths to ASE-readable
+    geometry files with N unique elements between them, and returns a dict-like
+    containing those unique elements as keys and their reference energy as
+    values.
+
+    By default, use the same geometry files as those which contain the
+    vibrational frequencies for the microkinetic model.
+    """
+    def __init__(self, species, index=0):
+        dict.__init__(self)
+        symbols = []
+        energies = []
+        elements = set()
+
+        self.initialized = False
+
+        for sp in species:
+            if isinstance(sp, Atoms):
+                conf = sp
+            elif isinstance(sp, AtomsRow):
+                conf = sp.toatoms()
+            elif isinstance(sp, _Thermo):
+                conf = sp.atoms
+            else:
+                conf = read(sp, index=index)
+            symbols.append(conf.get_chemical_symbols())
+            elements = elements.union(symbols[-1])
+            energies.append(conf.get_potential_energy())
+
+        size = len(elements)
+        if len(energies) < size:
+            raise ValueError("System is underdetermined!")
+        elif len(energies) > size:
+            raise ValueError("System is overdetermined!")
+
+        coeff = np.zeros((size, size), dtype=float)
+
+        for i in range(size):
+            for j, symbol in enumerate(elements):
+                coeff[i, j] = symbols[i].count(symbol)
+        eref = np.linalg.solve(coeff, energies)
+
+        for i, symbol in enumerate(elements):
+            self[symbol] = eref[i]
+
+        self.initialized = True
+
+    def __setitem__(self, key, value):
+        if self.initialized:
+            raise NotImplementedError
+        else:
+            super().__setitem__(key, value)
+
+    def __delitem__(self, key):
+        raise NotImplementedError
+
+    def __getitem__(self, key):
+        if isinstance(key, str):
+            key = key.capitalize()
+        elif isinstance(key, int):
+            key = chemical_symbols[key]
+        return super().__getitem__(key)
+
+    def copy(self):
+        new = EnergyReference.__new__(EnergyReference)
+        new.initialized = False
+        for key in self:
+            new[key] = self[key]
+        new.initialized = True
+        return new

micki/io.py

@@ -0,0 +1,138 @@
+import numpy as np
+
+from ase.io import read
+from ase.units import _hplanck, J, m, kg
+
+from micki.masses import masses
+
+def parse_vasp_out(filename, ignore_atoms=()):
+    atoms = read(filename, index=0)
+    for atom in atoms:
+        atom.mass = masses[atom.symbol]
+    if 'OUTCAR' in filename:
+        # This reads the hessian from the OUTCAR and diagonalizes it
+        # to find the frequencies, rather than reading the frequencies
+        # directly from the OUTCAR. This is to ensure we use the same
+        # unit conversion factors, and also to make sure we use the same
+        # atom masses for all calculations. Also, allows for the possibility
+        # of doing partial hessian diagonalization should we want to do that.
+        hessblock = 0
+        with open(filename, 'r') as f:
+            for line in f:
+                line = line.strip()
+                if line != '':
+                    if hessblock == 1:
+                        if line.startswith('---'):
+                            hessblock = 2
+
+                    elif hessblock == 2:
+                        line = line.split()
+                        dof = len(line)
+                        hess = np.zeros((dof, dof), dtype=float)
+                        index = np.zeros(dof, dtype=int)
+                        cart = np.zeros(dof, dtype=int)
+                        for i, direction in enumerate(line):
+                            index[i] = int(direction[:-1]) - 1
+                            if direction[-1] == 'X':
+                                cart[i] = 0
+                            elif direction[-1] == 'Y':
+                                cart[i] = 1
+                            elif direction[-1] == 'Z':
+                                cart[i] = 2
+                            else:
+                                raise ValueError("Error reading Hessian!")
+                        hessblock = 3
+                        j = 0
+
+                    elif hessblock == 3:
+                        line = line.split()
+                        hess[j] = np.array([float(val) for val in line[1:]],
+                                           dtype=float)
+                        j += 1
+
+                    elif line.startswith('SECOND DERIVATIVES'):
+                        hessblock = 1
+
+                elif hessblock == 3:
+                    break
+
+        hess = -(hess + hess.T) / 2.
+    elif 'vasprun.xml' in filename:
+        import xml.etree.ElementTree as ET
+
+        tree = ET.parse(filename)
+        root = tree.getroot()
+
+        vasp_mass = {}
+
+        for element in root.find("atominfo/array[@name='atomtypes']/set"):
+            vasp_mass[element[1].text.strip()] = float(element[2].text)
+
+        selective = np.ones((len(atoms), 3), dtype=bool)
+        constblock = root.find(
+                'structure[@name="initialpos"]/varray[@name="selective"]')
+        if constblock is not None:
+            for i, v in enumerate(constblock):
+                for j, fixed in enumerate(v.text.split()):
+                    selective[i, j] = (fixed == 'T')
+        index = []
+        for i, atom in enumerate(atoms):
+            for direction in selective[i]:
+                if direction:
+                    index.append(i)
+
+        hess = np.zeros((len(index), len(index)), dtype=float)
+
+        for i, v in enumerate(root.find(
+                'calculation/dynmat/varray[@name="hessian"]')):
+            hess[i] = -np.array([float(val) for val in v.text.split()])
+
+        vasp_massvec = np.zeros(len(index), dtype=float)
+        for i, j in enumerate(index):
+            vasp_massvec[i] = vasp_mass[atoms[j].symbol]
+
+        # VASP uses weird masses, so we un-mass-weight here
+        hess *= np.sqrt(np.outer(vasp_massvec, vasp_massvec))
+
+    else:
+        raise ValueError('Unknown file format {}!'.format(filename))
+    mass = np.array([atoms[i].mass for i in index], dtype=float)
+    hess /= np.sqrt(np.outer(mass, mass))
+
+    # Temporary work around: My test system OUTCARs include some
+    # metal atoms in the hessian, this seems to cause some problems
+    # with the MKM. So, here I'm taking only the non-metal part
+    # of the hessian and diagonalizing that.
+    partial = []
+    for i, j in enumerate(index):
+        if (j in ignore_atoms
+                or atoms[j] in ignore_atoms
+                or atoms[j].symbol in ignore_atoms):
+            continue
+        partial.append(i)
+    if not partial:
+        return atoms, np.array([])
+    partial_hess = np.zeros((len(partial), len(partial)))
+    partial_index = np.zeros(len(partial), dtype=int)
+    for i, a in enumerate(partial):
+        partial_index[i] = index[a]
+        for j, b in enumerate(partial):
+            partial_hess[i, j] = hess[a, b]
+
+    partial_hess *= _hplanck**2 * J * m**2 * kg / (4 * np.pi**2)
+    v, w = np.linalg.eig(partial_hess)
+
+    # We're taking the square root of an array that could include
+    # negative numbers, so the result has to be complex.
+    freq = np.sqrt(np.array(v, dtype=complex))
+    freqs = np.zeros_like(freq, dtype=float)
+
+    # We don't want to deal with complex numbers, so we just convert
+    # imaginary numbers to negative reals.
+    for i, val in enumerate(freq):
+        if val.imag == 0:
+            freqs[i] = val.real
+        else:
+            freqs[i] = -val.imag
+    freqs.sort()
+    return atoms, freqs

micki/lattice.py

@@ -0,0 +1,92 @@
+"""Lattice stuff"""
+
+from .reactants import _Thermo
+import numpy as np
+from ase.units import kB
+
+
+class Lattice:
+    def __init__(self, neighborlist):
+        self.neighborlist = neighborlist
+        self.sites = [site for site in neighborlist]
+        if isinstance(self.sites[0], str):
+            self.string_names = True
+        elif isinstance(self.sites[0], _Thermo):
+            self.string_names = False
+        else:
+            raise ValueError('All sites must be _Thermo objects or strings!')
+
+        sitetype = str if self.string_names else _Thermo
+
+        for site in self.sites:
+            if not isinstance(site, sitetype):
+                raise ValueError('All sites must be _Thermo objects or strings!')
+
+        # Sanity check the input
+        self.totneighbors = {}
+        for site, neighbors in neighborlist.items():
+            self.totneighbors[site] = 0
+            for neighbor, val in neighbors.items():
+                self.totneighbors[site] += val
+                if neighbor not in self.sites:
+                    raise ValueError("Neighbor {} is unknown!".format(neighbor))
+            for site in self.sites:
+                if site not in neighbors:
+                    neighbors[site] = 0
+
+        # Create a neighbor list matrix
+        nsites = len(self.sites)
+        if nsites == 1:
+            self.ratio = {self.sites[0]: 1}
+            return
+        nmat = np.zeros((nsites, nsites), dtype=float)
+        for i, a in enumerate(self.sites):
+            for j, b in enumerate(self.sites):
+                nmat[i, j] = self.neighborlist[b].get(a, 0) / self.totneighbors[a]
+        
+        # Diagonalize to find the element ratio. Only one eigenvector should
+        # have all positive values. This is the eigenvector that describes
+        # the element ratio
+        eigenvals, eigenvecs = np.linalg.eig(nmat)
+        for i in range(nsites):
+            if np.all(eigenvecs[:, i] < 0) or np.all(eigenvecs[:, i] > 0):
+                ratio = np.abs(eigenvecs[:, i])
+                ratio /= ratio.sum()
+                self.ratio = {site: ratio[i] for i, site in enumerate(self.sites)}
+                break
+        else:
+            raise ValueError("Failed to find the element ratio! Please "
+                             "double-check your neighbor count. "
+                             "Eigenvectors: {}".format(eigenvecs))
+
+    def update_site_names(self, string_to_thermo):
+        if not self.string_names:
+            raise RuntimeError('Sites are already _Thermo objects!')
+
+        for site in self.sites:
+            if site not in string_to_thermo:
+                raise ValueError('No _Thermo object for site {}!'.format(site))
+
+        for string in string_to_thermo:
+            if string not in self.sites:
+                raise ValueError('Unknown site name {}!'.format(string))
+
+        new_neighborlist = {}
+        for site, neighbors in self.neighborlist.items():
+            new_neighborlist[string_to_thermo[site]] = {
+                string_to_thermo[neighbor]: count
+                for neighbor, count in neighbors.items()}
+
+        # rebuild everything (totneighbors, ratio, ...) with the new keys
+        self.__init__(new_neighborlist)
+
+    def get_S_conf(self, sites):
+        if sites is None or isinstance(sites, _Thermo) or len(sites) == 1:
+            return 0
+        nconfs = 1
+        for i in range(1, len(sites)):
+            ncount = self.neighborlist[sites[i - 1]][sites[i]]
+            if ncount == 0:
+                raise ValueError("This binding geometry is impossible!")
+            nconfs *= ncount / self.ratio[sites[i]]
+        return kB * np.log(nconfs)