kim-tools 0.2.5__py3-none-any.whl → 0.3.0__py3-none-any.whl

kim_tools/aflow_util/core.py

@@ -3,23 +3,21 @@
 import json
 import logging
 import os
-import re
 import subprocess
-import sys
 from curses.ascii import isalpha, isdigit
 from dataclasses import dataclass
-from math import acos, cos, degrees, radians, sin, sqrt
+from math import acos, cos, degrees, radians, sqrt
 from os import PathLike
-from random import random
 from tempfile import NamedTemporaryFile
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import ase
 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 numpy.typing import ArrayLike
+from semver import Version
 from sympy import Symbol, linear_eq_to_matrix, matrix2numpy, parse_expr
 
 from ..symmetry_util import (
@@ -64,6 +62,10 @@ __all__ = [
 ]
 
 AFLOW_EXECUTABLE = "aflow"
+REQUIRED_AFLOW = "4.0.5"
+AFLOW_PROTOTYPE_ENCYCLOPEDIA_PATH = os.path.join(
+    os.path.dirname(os.path.realpath(__file__)), "aflow_prototype_encyclopedia"
+)
 
 
 class IncorrectSpaceGroupException(Exception):
@@ -97,10 +99,10 @@ class EquivalentEqnSet:
     param_names: List[str]
     # m x 3 x n matrices of coefficients, where m is the multiplicity of the Wyckoff
     # position
-    coeff_matrix_list: List[ArrayLike]
+    coeff_matrix_list: List[npt.ArrayLike]
     # m x 3 x 1 columns of constant terms in the coordinates. This gets subtracted from
     # the RHS when solving
-    const_terms_list: List[ArrayLike]
+    const_terms_list: List[npt.ArrayLike]
 
 
 @dataclass
@@ -111,7 +113,7 @@ class EquivalentAtomSet:
 
     species: str
     wyckoff_letter: str
-    frac_position_list: List[ArrayLike]  # m x 3 x 1 columns
+    frac_position_list: List[npt.ArrayLike]  # m x 3 x 1 columns
 
 
 def write_tmp_poscar_from_atoms_and_run_function(
@@ -504,81 +506,27 @@ def get_bravais_lattice_from_prototype(prototype_label: str) -> str:
     return get_pearson_symbol_from_prototype(prototype_label)[:2]
 
 
-def read_shortnames() -> Dict:
+def read_shortnames(
+    aflow_prototype_encyclopedia_path: PathLike = AFLOW_PROTOTYPE_ENCYCLOPEDIA_PATH,
+) -> Dict:
     """
-    This function parses "README_PROTO.TXT". It finds each line that (after stripping
-    whitespace) starts with "ANRL Label". These are headers of sections of prototype
-    listings. It finds the column of the word "notes". This will be the column that the
-    shortnames are in. Skipping various non-prototype lines, the first column in each
-    prototype line (before the ".") is the prototype, while the end of the line
-    starting from the "notes" column, cleaned up to remove whitespace and
-    end-of-shortname comments (i.e. "(part 3)"), is the shortname.
+    Read the aflow prototype encyclopedia submodule
+
+    Args:
+        aflow_prototype_encyclopedia_path:
+            Path to aflow_prototype_encyclopedia_repo
 
     Returns:
         A dictionary where the keys are the prototype strings, and the values are the
         shortnames found in the corresponding lines.
     """
+    aflow_data_path = os.path.join(aflow_prototype_encyclopedia_path, "data")
     shortnames = {}
-    shortname_file = "data/README_PROTO.TXT"
-    notes_index = None
-    with open(
-        os.path.join(os.path.dirname(os.path.realpath(__file__)), shortname_file),
-        encoding="utf-8",
-    ) as f:
-        for line in f:
-            line = line.strip()
-            if line.startswith("ANRL Label"):
-                try:
-                    notes_index = line.index("notes")
-                    continue
-                except Exception:
-                    print("ERROR: ANRL Label line without notes header")
-                    print(line)
-                    sys.exit()
-            # Skip this line if it's before the first ANRL label
-            if notes_index is None:
-                continue
-            # Skip this line if it's empty, a comment, or a divider
-            if (
-                line == ""
-                or line == "\n"
-                or line.startswith("*")
-                or line.startswith("-")
-                or line.startswith("ANRL")
-            ):
-                continue
-            # Skip this line if it only has content in the first column
-            # (prototype runover from previous line)
-            try:
-                _ = line.split(" ")[1]
-            except Exception:
-                continue
-            # Clean up prototype (remove decorations suffix)
-            prototype = line.split(" ")[0]
-            if "." in prototype:
-                idx = prototype.index(".")
-                prototype = prototype[:idx]
-            # Clean up short name
-            sname = line[notes_index:]
-            if "(part " in sname:
-                idx = sname.index("(part")
-                sname = sname[:idx]
-            sname = sname.replace(", part 3", "")
-            if "ICSD" in sname:
-                idx = sname.index("ICSD")
-                tmp = sname[idx:].split(" ")[1]
-                if tmp.endswith(","):
-                    sname = sname[:idx] + "ICSD " + tmp[:-1]
-            if " similar to" in sname:
-                idx = sname.index(" similar to")
-                sname = sname[:idx]
-            if " equivalent to" in sname:
-                idx = sname.index(" equivalent to")
-                sname = sname[:idx]
-            if sname.endswith(","):
-                sname = sname[:-1]
-            # add prototype to shortnames dictionary
-            shortnames[prototype] = sname.rstrip()
+    for libproto in os.listdir(aflow_data_path):
+        info_file = os.path.join(aflow_data_path, libproto, "info.json")
+        with open(info_file) as f:
+            info = json.load(f)
+        shortnames[libproto] = info["title"]
     return shortnames
 
 
@@ -600,7 +548,7 @@ def get_real_to_virtual_species_map(input: Union[List[str], Atoms]) -> Dict:
 
 
 def solve_for_aflow_cell_params_from_primitive_ase_cell_params(
-    cellpar_prim: ArrayLike, prototype_label: str
+    cellpar_prim: npt.ArrayLike, prototype_label: str
 ) -> List[float]:
     """
     Get conventional cell parameters from primitive cell parameters. It is assumed that
@@ -720,7 +668,6 @@ class AFLOW:
         np (int):
             Number of processors to use, passed to the AFLOW executable using the
             ``--np=...`` argument
-
     """
 
     class AFLOWNotFoundException(Exception):
@@ -756,16 +703,22 @@ class AFLOW:
             np: Sets :attr:`np`
         """
         self.aflow_executable = aflow_executable
-
+        self.np = np
         try:
-            subprocess.check_output([aflow_executable, "--proto=A_cF4_225_a"])
+            ver_str = self.get_aflow_version()
         except Exception:
             raise self.AFLOWNotFoundException(
                 "Failed to run an AFLOW test command. It is likely "
                 "that the AFLOW executable was not found."
             )
-
-        self.np = np
+        # I am fine with allowing prereleases
+        aflow_ver_no_prerelease = Version.parse(ver_str)
+        aflow_ver_no_prerelease.replace(prerelease=None)
+        if aflow_ver_no_prerelease < Version.parse(REQUIRED_AFLOW):
+            raise self.AFLOWNotFoundException(
+                f"Your AFLOW version {ver_str} is less "
+                f"than the required {REQUIRED_AFLOW}"
+            )
         if aflow_work_dir != "" and not aflow_work_dir.endswith("/"):
             self.aflow_work_dir = aflow_work_dir + "/"
         else:
@@ -894,6 +847,7 @@ class AFLOW:
         species: List[str],
         parameter_values: Optional[List[float]] = None,
         proto_file: Optional[str] = None,
+        addtl_args: str = "",
         verbose: bool = True,
     ) -> Atoms:
         """
@@ -912,6 +866,9 @@ class AFLOW:
             proto_file:
                 Write the POSCAR to this permanent file for debugging
                 instead of a temporary file
+            addtl_args:
+                additional arguments to pass, e.g. ``--webpage`` to get deactivate
+                higher symmetry check
             verbose:
                 Print details in the log file
 
@@ -928,6 +885,7 @@ class AFLOW:
                 prototype_label=prototype_label,
                 species=species,
                 parameter_values=parameter_values,
+                addtl_args=addtl_args,
                 verbose=verbose,
             )
         except self.ChangedSymmetryException as e:
@@ -1135,6 +1093,10 @@ class AFLOW:
         else:
             matching_library_prototype_label = None
 
+        logger.info(
+            "Detected encyclopedia entry "
+            f"{matching_library_prototype_label}: {shortname}"
+        )
         return matching_library_prototype_label, shortname
 
     def get_library_prototype_label_and_shortname_from_atoms(
@@ -1199,9 +1161,9 @@ class AFLOW:
         sort_atoms1: bool = True,
         sort_atoms2: bool = True,
     ) -> Tuple[
-        Optional[ArrayLike],
-        Optional[ArrayLike],
-        Optional[ArrayLike],
+        Optional[npt.ArrayLike],
+        Optional[npt.ArrayLike],
+        Optional[npt.ArrayLike],
         Optional[List[int]],
     ]:
         """
@@ -1249,18 +1211,12 @@ class AFLOW:
 
     def get_param_names_from_prototype(self, prototype_label: str) -> List[str]:
         """
-        Get the parameter names by parsing the error message from AFLOW
+        Get the parameter names
         """
-        try:
-            self.write_poscar_from_prototype(prototype_label, parameter_values=[1.0])
-            # if no exception, it's a cubic crystal with no internal free params
-            return ["a"]
-        except subprocess.CalledProcessError as exc:
-            re_match = re.search(r"parameter_list=(.*) - \[dir", str(exc.stderr))
-            if re_match is not None:
-                return re_match.groups()[0].split(",")
-            # if we got here, the exception didn't have the format we expected, re-raise
-            raise exc
+        symbol_string = self.write_poscar_from_prototype(
+            prototype_label=prototype_label, addtl_args="--parameter_symbols_only"
+        )
+        return symbol_string.strip().split(",")
 
     def get_equation_sets_from_prototype(
         self, prototype_label: str
@@ -1287,60 +1243,23 @@ class AFLOW:
                 - const_terms_list: A list of 3 x 1 columns of constant terms in the
                   coordinates.
         """
-        param_names = self.get_param_names_from_prototype(prototype_label)
-        MAX_ATTEMPTS = 20
-        ANGLE_NAMES = ["alpha", "beta", "gamma"]
-        for i in range(MAX_ATTEMPTS):
-            param_values = []
-            triclinic = False
-            if all([angle_name in param_names for angle_name in ANGLE_NAMES]):
-                triclinic = True
-                beta = 5 + random() * 165
-                gamma = 5 + random() * 165
-                beta_rad = radians(beta)
-                gamma_rad = radians(gamma)
-                max_cosalpha = abs(sin(beta_rad) * sin(gamma_rad)) + cos(
-                    beta_rad
-                ) * cos(gamma_rad)
-                min_cosalpha = -abs(sin(beta_rad) * sin(gamma_rad)) + cos(
-                    beta_rad
-                ) * cos(gamma_rad)
-                cosalpha = min_cosalpha + random() * (max_cosalpha - min_cosalpha)
-                alpha = degrees(acos(cosalpha))
-                angles_dict = {"alpha": alpha, "beta": beta, "gamma": gamma}
-
-            for pname in param_names:
-                if pname in ANGLE_NAMES:
-                    if triclinic:
-                        param_values.append(angles_dict[pname])
-                    else:
-                        param_values.append(180.0 * random())
-                else:
-                    param_values.append(random())
-
-            try:
-                equation_poscar = self.write_poscar_from_prototype(
-                    prototype_label,
-                    parameter_values=param_values,
-                    addtl_args="--equations_only",
-                )
-                break
-            except subprocess.CalledProcessError:
-                if i == MAX_ATTEMPTS - 1:
-                    raise RuntimeError(
-                        "Random parameters failed to pass "
-                        "AFLOW checks 20 times in a row"
-                    )
-                else:
-                    pass
+        equation_poscar = self.write_poscar_from_prototype(
+            prototype_label,
+            addtl_args="--equations_only",
+        )
 
         # get a string with one character per Wyckoff position
         # (with possible repeated letters for positions with free params)
         wyckoff_lists = get_wyckoff_lists_from_prototype(prototype_label)
         wyckoff_joined_list = "".join(wyckoff_lists)
 
-        coord_lines = equation_poscar.splitlines()[7:]
+        coord_lines = equation_poscar.splitlines()
         coord_iter = iter(coord_lines)
+        reading_coord = False
+        while not reading_coord:
+            line = next(coord_iter)
+            if line.startswith("BEGIN EQUATIONS WITH WYCKOFF"):
+                reading_coord = True
 
         space_group_number = get_space_group_number_from_prototype(prototype_label)
 
@@ -1358,8 +1277,8 @@ class AFLOW:
             ):
                 line_split = next(coord_iter).split()
                 if species is None:
-                    species = line_split[3]
-                elif line_split[3] != species:
+                    species = line_split[4]
+                elif line_split[4] != species:
                     raise InconsistentWyckoffException(
                         "Encountered different species within what I thought should be "
                         f"the lines corresponding to Wyckoff position {wyckoff_letter}"
@@ -1369,7 +1288,7 @@ class AFLOW:
                 # first, get the free parameters of this line
                 curr_line_free_params = set()  # sympy.Symbol
                 coordinate_expr_list = []
-                for expression_string in line_split[:3]:
+                for expression_string in line_split[1:4]:
                     coordinate_expr = parse_expr(expression_string)
                     curr_line_free_params.update(coordinate_expr.free_symbols)
                     coordinate_expr_list.append(coordinate_expr)
@@ -1439,7 +1358,7 @@ class AFLOW:
         cell_rtol: float = 0.01,
         rot_rtol: float = 0.01,
         rot_atol: float = 0.01,
-    ) -> 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
@@ -1478,8 +1397,10 @@ class AFLOW:
                 default distance tolerance of 0.01*(NN distance)
 
         Returns:
-            List of free parameters that will regenerate `atoms` (up to permutations,
-            rotations, and translations) when paired with `prototype_label`
+            * 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
 
         Raises:
             AFLOW.ChangedSymmetryException:
@@ -1526,6 +1447,10 @@ class AFLOW:
             "aflow_prototype_label"
         ]
 
+        library_prototype_label, short_name = (
+            self.get_library_prototype_label_and_shortname_from_atoms(atoms)
+        )
+
         if not prototype_labels_are_equivalent(
             prototype_label, prototype_label_detected
         ):
@@ -1544,6 +1469,7 @@ class AFLOW:
                 parameter_values=detected_prototype_designation[
                     "aflow_prototype_params_values"
                 ],
+                addtl_args="--webpage",
             )
         except self.ChangedSymmetryException as e:
             # re-raise, just indicating that this function knows about this exception
@@ -1707,7 +1633,11 @@ class AFLOW:
                         f"Found set of parameters for prototype {prototype_label} "
                         "that is unrotated"
                     )
-                    return candidate_prototype_param_values
+                    return (
+                        candidate_prototype_param_values,
+                        library_prototype_label,
+                        short_name,
+                    )
                 else:
                     logger.info(
                         f"Found set of parameters for prototype {prototype_label}, "
@@ -1859,6 +1789,7 @@ class AFLOW:
             prototype_label=prototype_label,
             species=species,
             parameter_values=parameter_values,
+            addtl_args="--webpage",
         )
 
         return self.confirm_atoms_unrotated_when_cells_aligned(

kim_tools/symmetry_util/core.py

@@ -16,6 +16,8 @@ from ase import Atoms
 from ase.cell import Cell
 from ase.geometry import get_distances, get_duplicate_atoms
 from matplotlib.backends.backend_pdf import PdfPages
+from pymatgen.core.operations import SymmOp
+from pymatgen.core.tensors import Tensor
 from scipy.stats import kstest
 from sklearn.decomposition import PCA
 from sympy import Matrix, cos, matrix2numpy, sin, sqrt, symbols
@@ -138,7 +140,7 @@ def cartesian_to_fractional_itc_rotation_from_ase_cell(
             "Either the rotation matrix or the cell provided were not 3x3 matrices"
         )
 
-    return np.transpose(cell_arr @ cart_rot_arr @ np.linalg.inv(cell_arr))
+    return np.transpose(cell_arr @ cart_rot_arr.T @ np.linalg.inv(cell_arr))
 
 
 def fractional_to_cartesian_itc_rotation_from_ase_cell(
@@ -174,7 +176,7 @@ def fractional_to_cartesian_itc_rotation_from_ase_cell(
             "Either the rotation matrix or the cell provided were not 3x3 matrices"
         )
 
-    return np.transpose(np.linalg.inv(cell_arr) @ frac_rot_arr @ cell_arr)
+    return np.transpose(np.linalg.inv(cell_arr) @ frac_rot_arr.T @ cell_arr)
 
 
 def cartesian_rotation_is_in_point_group(
@@ -614,7 +616,7 @@ def get_primitive_genpos_ops(sgnum: Union[int, str]) -> List[Dict]:
 
 def reduce_and_avg(
     atoms: Atoms, repeat: Tuple[int, int, int]
-) -> Tuple[Atoms, npt.NDArray]:
+) -> Tuple[Atoms, npt.ArrayLike]:
     """
     TODO: Upgrade :func:`change_of_basis_atoms` to provide the distances
     array, obviating this function
@@ -700,7 +702,7 @@ def reduce_and_avg(
 
 
 def kstest_reduced_distances(
-    reduced_distances: npt.NDArray,
+    reduced_distances: npt.ArrayLike,
     significance_level: float = 0.05,
     plot_filename: Optional[str] = None,
     number_bins: Optional[int] = None,
@@ -783,3 +785,47 @@ def kstest_reduced_distances(
             "Detected normal distribution or reduced atom positions around their "
             f"average (smallest p value {np.min(p_values)})."
         )
+
+
+def fit_voigt_tensor_to_cell_and_space_group(
+    voigt_input: npt.ArrayLike, cell: npt.ArrayLike, sgnum: Union[int, str]
+) -> npt.ArrayLike:
+    """
+    Given a Cartesian Tensor in voigt form, average it over all the operations in the
+    crystal's space group in order to remove violations of the material symmetry due to
+    numerical errors. Similar to :meth:`pymatgen.core.tensors.Tensor.fit_to_structure`,
+    except the input in output are Voigt, and the symmetry operations are tabulated
+    instead of being detected on the fly from a structure.
+
+    The provided tensor and cell must be in the standard primitive
+    setting and orientation w.r.t. Cartesian coordinates as defined in
+    https://doi.org/10.1016/j.commatsci.2017.01.017
+
+    Args:
+        voigt_input:
+            Tensor in Voigt form as understood by
+            :meth:`pymatgen.core.tensors.Tensor.from_voigt`
+        cell:
+            The cell of the crystal, with each row being a cartesian vector
+            representing a lattice vector
+        sgnum:
+            Space group number
+
+    Returns:
+        Tensor symmetrized w.r.t. operations of the space group
+    """
+    t = Tensor.from_voigt(voigt_input)
+
+    t_rotated_list = []
+
+    space_group_ops = get_primitive_genpos_ops(sgnum)
+
+    for op in space_group_ops:
+        frac_rot = op["W"]
+        cart_rot = fractional_to_cartesian_itc_rotation_from_ase_cell(frac_rot, cell)
+        cart_rot_op = SymmOp.from_rotation_and_translation(rotation_matrix=cart_rot)
+        t_rotated_list.append(t.transform(cart_rot_op))
+
+    t_symmetrized = sum(t_rotated_list) / len(t_rotated_list)
+
+    return t_symmetrized.voigt