kim-tools 0.3.6__py3-none-any.whl → 0.4.2__py3-none-any.whl

kim_tools/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.6"
+__version__ = "0.4.2"
 
 from .aflow_util import *
 from .aflow_util import __all__ as aflow_all

kim_tools/aflow_util/core.py

@@ -17,7 +17,6 @@ import numpy as np
 import numpy.typing as npt
 from ase import Atoms
 from ase.cell import Cell
-from ase.neighborlist import natural_cutoffs, neighbor_list
 from semver import Version
 from sympy import Symbol, linear_eq_to_matrix, matrix2numpy, parse_expr
 
@@ -30,6 +29,7 @@ from ..symmetry_util import (
     cartesian_rotation_is_in_point_group,
     get_possible_primitive_shifts,
     get_primitive_wyckoff_multiplicity,
+    get_smallest_nn_dist,
     get_wyck_pos_xform_under_normalizer,
     space_group_numbers_are_enantiomorphic,
 )
@@ -398,9 +398,7 @@ def get_atom_indices_for_each_wyckoff_orb(prototype_label: str) -> List[Dict]:
     orbit.
 
     Returns:
-        The information is in this format:
-
-        [{"letter":"a", "indices":[0,1]}, ... ]
+        The information is in this format -- ``[{"letter":"a", "indices":[0,1]}, ... ]``
     """
     return_list = []
     wyck_lists = get_wyckoff_lists_from_prototype(prototype_label)
@@ -416,6 +414,45 @@ def get_atom_indices_for_each_wyckoff_orb(prototype_label: str) -> List[Dict]:
     return return_list
 
 
+def get_all_equivalent_labels(prototype_label: str) -> List[str]:
+    """
+    Return all possible permutations of the Wyckoff letters in a prototype
+    label under the operations of the affine normalizer.
+
+    NOTE: For now this function will not completely enumerate the possibilities
+    for triclinic and monoclinic space groups
+    """
+    sgnum = get_space_group_number_from_prototype(prototype_label)
+    prototype_label_split = prototype_label.split("_")
+    equivalent_labels = []
+    for wyck_pos_xform in get_wyck_pos_xform_under_normalizer(sgnum):
+        prototype_label_split_permuted = prototype_label_split[:3]
+        for wycksec in prototype_label_split[3:]:
+            # list of letters joined with their nums, e.g. ["a", "2i"]
+            wycksec_permuted_list = []
+            prev_lett_ind = -1
+            for i, num_or_lett in enumerate(wycksec):
+                if isalpha(num_or_lett):
+                    if num_or_lett == "A":
+                        # Wyckoff position A comes after z in sg 47
+                        lett_index = ord("z") + 1 - ord("a")
+                    else:
+                        lett_index = ord(num_or_lett) - ord("a")
+                    # The start position of the (optional) numbers +
+                    # letter describing this position
+                    this_pos_start_ind = prev_lett_ind + 1
+                    permuted_lett_and_num = wycksec[this_pos_start_ind:i]
+                    permuted_lett_and_num += wyck_pos_xform[lett_index]
+                    wycksec_permuted_list.append(permuted_lett_and_num)
+                    prev_lett_ind = i
+            wycksec_permuted_list_sorted = sorted(
+                wycksec_permuted_list, key=lambda x: x[-1]
+            )
+            prototype_label_split_permuted.append("".join(wycksec_permuted_list_sorted))
+        equivalent_labels.append("_".join(prototype_label_split_permuted))
+    return list(set(equivalent_labels))
+
+
 def prototype_labels_are_equivalent(
     prototype_label_1: str,
     prototype_label_2: str,
@@ -1510,7 +1547,8 @@ class AFLOW:
         cell_rtol: float = 0.01,
         rot_rtol: float = 0.01,
         rot_atol: float = 0.01,
-    ) -> Tuple[List[float], Optional[str]]:
+        match_library_proto: bool = True,
+    ) -> Union[List[float], Tuple[List[float], Optional[str]]]:
         """
         Given an Atoms object that is a primitive cell of its Bravais lattice as
         defined in doi.org/10.1016/j.commatsci.2017.01.017, and its presumed prototype
@@ -1547,12 +1585,16 @@ class AFLOW:
                 Parameter to pass to :func:`numpy.allclose` for compariong fractional
                 rotations. Default value chosen to be commensurate with AFLOW
                 default distance tolerance of 0.01*(NN distance)
+            match_library_proto:
+                Whether to attempt matching to library prototypes
 
         Returns:
             * List of free parameters that will regenerate `atoms` (up to permutations,
               rotations, and translations) when paired with `prototype_label`
-            * Library prototype label from the AFLOW prototype encyclopedia, if any
-            * Title of library prototype from the AFLOW prototype encyclopedia, if any
+            * Additionally, if 'match_library_proto' is True (default):
+                * Library prototype label from the AFLOW prototype encyclopedia, if any
+                * Title of library prototype from the AFLOW prototype encyclopedia,
+                  if any
 
         Raises:
             AFLOW.ChangedSymmetryException:
@@ -1563,20 +1605,12 @@ class AFLOW:
         """
         # If max_resid not provided, determine it from neighborlist
         if max_resid is None:
-            nl_len = 0
-            cov_mult = 1
-            while nl_len == 0:
-                logger.info(
-                    "Attempting to find NN distance by searching "
-                    f"within covalent radii times {cov_mult}"
-                )
-                nl = neighbor_list("d", atoms, natural_cutoffs(atoms, mult=cov_mult))
-                nl_len = nl.size
-                cov_mult += 1
             # set the maximum error to 1% of NN distance to follow AFLOW convention
             # rescale by cube root of cell volume to get rough conversion from
             # cartesian to fractional
-            max_resid = nl.min() * 0.01 * atoms.get_volume() ** (-1 / 3)
+            max_resid = (
+                get_smallest_nn_dist(atoms) * 0.01 * atoms.get_volume() ** (-1 / 3)
+            )
             logger.info(
                 "Automatically set max fractional residual for solving position "
                 f"equations to {max_resid}"
@@ -1599,10 +1633,25 @@ class AFLOW:
             "aflow_prototype_label"
         ]
 
-        library_prototype_label, short_name = (
-            self.get_library_prototype_label_and_shortname_from_atoms(atoms)
-        )
+        if match_library_proto:
+            try:
+                library_prototype_label, short_name = (
+                    self.get_library_prototype_label_and_shortname_from_atoms(atoms)
+                )
+            except subprocess.CalledProcessError:
+                library_prototype_label = None
+                short_name = None
+                msg = (
+                    "WARNING: aflow --compare2prototypes returned error, skipping "
+                    "library matching"
+                )
+                print()
+                print(msg)
+                print()
+                logger.warning(msg)
 
+        # NOTE: Because of below, this only works if the provided prototype label is
+        # correctly alphabetized. Change this?
         if not prototype_labels_are_equivalent(
             prototype_label, prototype_label_detected
         ):
@@ -1665,7 +1714,7 @@ class AFLOW:
         )
 
         position_set_list = get_equivalent_atom_sets_from_prototype_and_atom_map(
-            atoms, prototype_label, atom_map, sort_atoms=True
+            atoms, prototype_label_detected, atom_map, sort_atoms=True
         )
 
         # get equation sets
@@ -1785,11 +1834,14 @@ class AFLOW:
                         f"Found set of parameters for prototype {prototype_label} "
                         "that is unrotated"
                     )
-                    return (
-                        candidate_prototype_param_values,
-                        library_prototype_label,
-                        short_name,
-                    )
+                    if match_library_proto:
+                        return (
+                            candidate_prototype_param_values,
+                            library_prototype_label,
+                            short_name,
+                        )
+                    else:
+                        return candidate_prototype_param_values
                 else:
                     logger.info(
                         f"Found set of parameters for prototype {prototype_label}, "
@@ -1863,7 +1915,9 @@ class AFLOW:
             cell_lengths_and_angles = ref_atoms.cell.cellpar()
 
         test_atoms_copy = test_atoms.copy()
+        del test_atoms_copy.constraints
         ref_atoms_copy = ref_atoms.copy()
+        del ref_atoms_copy.constraints
 
         test_atoms_copy.set_cell(
             Cell.fromcellpar(cell_lengths_and_angles), scale_atoms=True

kim_tools/ase/core.py

@@ -34,7 +34,6 @@ Helper routines for KIM Tests and Verification Checks
 import itertools
 import logging
 import random
-from typing import Union
 
 import numpy as np
 from ase import Atoms
@@ -208,45 +207,137 @@ def randomize_positions(atoms, pert_amp, seed=None):
 
 
 ################################################################################
-def get_isolated_energy_per_atom(model: Union[str, Calculator], symbol: str) -> float:
+def get_isolated_energy_per_atom(
+    model,
+    symbol,
+    initial_separation=1.0,
+    max_separation=15.0,
+    separation_neg_exponent=4,
+    quit_early_after_convergence=True,
+    energy_tolerance=1e-12,
+):
     """
     Construct a non-periodic cell containing a single atom and compute its energy.
+    It tries to iteratively finetune the atomic separation for a dimer up to a
+    specified precision (separation_neg_exponent). If between two successive phases
+    the energy difference is less than energy_tolerance, it stops early, i.e. if
+    4.0x and 4.00x are within energy_tolerance, it stops at 4.00x.
+    All separations are in Angstroms.
 
     Args:
-        model:
-            A KIM model ID or an ASE calculator for computing the energy
-        symbol:
-            The chemical species
-
-    Returns:
-        The isolated energy of a single atom
+        model: KIM model to use for calculations
+        symbol: Chemical symbol
+        initial_separation: Initial separation for dimer calculations
+        max_separation: maximum separation for dimer calculations
+        separation_neg_exponent: Number of decimal places to refine the separation
+        quit_early_after_convergence: Whether to stop early if energy converges
+        energy_tolerance: Energy difference tolerance for convergence check
     """
-    single_atom = Atoms(
-        symbol,
-        positions=[(0.1, 0.1, 0.1)],
-        cell=(20, 20, 20),
-        pbc=(False, False, False),
-    )
-    if isinstance(model, str):
-        calc = KIM(model)
-    elif isinstance(model, Calculator):
-        calc = model
-    else:
-        raise KIMASEError(
-            "`model` argument must be a string indicating a KIM model "
-            f"or an ASE Calculator. Instead got an object of type {type(model)}."
+    try:
+        single_atom = Atoms(
+            symbol,
+            positions=[(0.1, 0.1, 0.1)],
+            cell=(20, 20, 20),
+            pbc=(False, False, False),
         )
-    single_atom.calc = calc
-    energy_per_atom = single_atom.get_potential_energy()
-    # if we are attaching an existing LAMMPS calculator to an atoms object,
-    # we can't delete it. Only do so if we are making a new one from a KIM ID.
-    if isinstance(model, str):
+        if isinstance(model, str):
+            calc = KIM(model)
+        elif isinstance(model, Calculator):
+            calc = model
+
+        single_atom.calc = calc
+        energy_per_atom = single_atom.get_potential_energy()
+
+        # Clean up
         if hasattr(calc, "clean"):
             calc.clean()
         if hasattr(calc, "__del__"):
             calc.__del__()
-    del single_atom
-    return energy_per_atom
+        del single_atom
+
+        return energy_per_atom
+
+    except Exception:
+
+        def _try_dimer_energy(separation):
+            try:
+                dimer = Atoms(
+                    [symbol, symbol],
+                    positions=[(0.1, 0.1, 0.1), (0.1 + separation, 0.1, 0.1)],
+                    cell=(max(20, separation + 10), 20, 20),
+                    pbc=(False, False, False),
+                )
+                calc = KIM(model)
+                dimer.calc = calc
+
+                total_energy = dimer.get_potential_energy()
+                energy_per_atom = total_energy / 2.0
+
+                if hasattr(calc, "clean"):
+                    calc.clean()
+                if hasattr(calc, "__del__"):
+                    calc.__del__()
+                del dimer
+
+                return energy_per_atom
+
+            except Exception:
+                try:
+                    if hasattr(calc, "clean"):
+                        calc.clean()
+                    if hasattr(calc, "__del__"):
+                        calc.__del__()
+                    if "dimer" in locals():
+                        del dimer
+                except Exception:
+                    pass
+                return None
+
+        # Start with integer separations: 1.0, 2.0, 3.0, 4.0, ...
+        last_successful_separation = None
+        last_successful_energy = None
+
+        separation = initial_separation
+        while separation <= max_separation:
+            energy = _try_dimer_energy(separation)
+            if energy is not None:
+                last_successful_separation = separation
+                last_successful_energy = energy
+                separation += 1.0
+            else:
+                break
+
+        if last_successful_separation is None:
+            raise RuntimeError(
+                f"Failed to obtain isolated energy for {symbol} - no separations worked"
+            )
+
+        # refine
+        current_separation = last_successful_separation
+        previous_phase_energy = last_successful_energy
+
+        for decimal_place in range(1, separation_neg_exponent + 1):
+
+            step_size = 10 ** (-decimal_place)
+
+            for i in range(1, 10):
+                test_sep = current_separation + step_size
+                energy = _try_dimer_energy(test_sep)
+
+                if energy is not None:
+                    current_separation = test_sep
+                    last_successful_energy = energy
+                else:
+                    break
+
+            if quit_early_after_convergence:
+                energy_diff = abs(last_successful_energy - previous_phase_energy)
+                if energy_diff <= energy_tolerance:
+                    return last_successful_energy
+
+            previous_phase_energy = last_successful_energy
+
+        return last_successful_energy
 
 
 ################################################################################
@@ -434,9 +525,7 @@ def check_if_atoms_interacting(
         atoms_interacting_energy = check_if_atoms_interacting_energy(
             model, symbols, etol
         )
-        atoms_interacting_force = check_if_atoms_interacting_energy(
-            model, symbols, ftol
-        )
+        atoms_interacting_force = check_if_atoms_interacting_force(model, symbols, ftol)
         return atoms_interacting_energy, atoms_interacting_force
 
 

kim_tools/kimunits.py

@@ -12,6 +12,8 @@ import re
 import subprocess
 import warnings
 
+import numpy as np
+
 warnings.simplefilter("ignore")
 
 
@@ -24,17 +26,31 @@ _units_output_expression = re.compile(
 )
 
 
-def check_units_util():
+def check_units_util() -> str:
     """
-    Check that units util can be found
+    Figure out if units (first choice) or gunits (second choice) works
+    with the options that we use
     """
+    args = ["-o", r"%1.15e", "-qt1", "0.0 eV/angstrom^3 bar"]
     try:
-        subprocess.check_output(["units", "--help"])
+        output = subprocess.check_output(["units"] + args, encoding="utf-8")
+        assert np.isclose(float(output), 0)
+        units_command = "units"
     except Exception:
-        raise UnitConversion(
-            "Failed to run a 'units' test command. It is likely "
-            "that the 'units' executable was not found."
-        )
+        try:
+            output = subprocess.check_output(["gunits"] + args, encoding="utf-8")
+            assert np.isclose(float(output), 0)
+            units_command = "gunits"
+        except Exception:
+            raise UnitConversion(
+                "Neither "
+                r"units -o %1.15e -qt1 '0.0 eV/angstrom^3 bar'"
+                " nor "
+                r"gunits -o %1.15e -qt1 '0.0 eV/angstrom^3 bar'"
+                " successfully ran and returned 0.e0. Please install a "
+                "compatible version of units."
+            )
+    return units_command
 
 
 def linear_fit(x, y):
@@ -68,7 +84,7 @@ def islinear(unit, to_unit=None):
 
 def convert_units(from_value, from_unit, wanted_unit=None, suppress_unit=False):
     """Works with 'units' utility"""
-    check_units_util()
+    units_util = check_units_util()
     from_sign = from_value < 0
     from_value = str(abs(from_value))
     from_unit = str(from_unit)
@@ -77,7 +93,7 @@ def convert_units(from_value, from_unit, wanted_unit=None, suppress_unit=False):
 
     if from_unit in TEMPERATURE_FUNCTION_UNITS:
         args = [
-            "units",
+            units_util,
             "-o",
             "%1.15e",
             "-qt1",
@@ -85,7 +101,7 @@ def convert_units(from_value, from_unit, wanted_unit=None, suppress_unit=False):
         ]
 
     else:
-        args = ["units", "-o", "%1.15e", "-qt1", " ".join((from_value, from_unit))]
+        args = [units_util, "-o", "%1.15e", "-qt1", " ".join((from_value, from_unit))]
 
     if wanted_unit:
         args.append(wanted_unit)