kim-tools 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

kim_tools/__init__.py

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

kim_tools/aflow_util/core.py

@@ -18,6 +18,7 @@ import ase
 import numpy as np
 from ase import Atoms
 from ase.cell import Cell
+from ase.neighborlist import natural_cutoffs, neighbor_list
 from numpy.typing import ArrayLike
 from sympy import Symbol, linear_eq_to_matrix, matrix2numpy, parse_expr
 
@@ -1116,9 +1117,7 @@ class AFLOW:
                 misfit_min_overall = struct["misfit"]
                 library_proto_overall = struct["name"]
                 found_overall = True
-            if struct["misfit"] < misfit_min_inlist and any(
-                proto in struct["name"] for proto in shortnames
-            ):
+            if struct["misfit"] < misfit_min_inlist and struct["name"] in shortnames:
                 misfit_min_inlist = struct["misfit"]
                 library_proto_inlist = struct["name"]
                 found_inlist = True
@@ -1429,8 +1428,10 @@ class AFLOW:
         self,
         atoms: Atoms,
         prototype_label: str,
-        max_resid: float = 1e-5,
+        max_resid: Optional[float] = None,
         cell_rtol: float = 0.01,
+        rot_rtol: float = 0.01,
+        rot_atol: float = 0.01,
     ) -> List[float]:
         """
         Given an Atoms object that is a primitive cell of its Bravais lattice as
@@ -1455,8 +1456,19 @@ class AFLOW:
             max_resid:
                 Maximum residual allowed when attempting to match the fractional
                 positions of the atoms to the crystallographic equations
+                If not provided, this is automatically set to 0.01*(minimum NN distance)
             cell_rtol:
                 Relative tolerance on cell lengths and angles
+                Justification for default value: AFLOW uses 0.01*(minimum NN distance)
+                as default tolerance.
+            rot_rtol:
+                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)
+            rot_atol:
+                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)
 
         Returns:
             List of free parameters that will regenerate `atoms` (up to permutations,
@@ -1469,6 +1481,25 @@ class AFLOW:
                 if AFLOW fails to match the re-generated crystal to the input crystal
 
         """
+        # 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
+            max_resid = nl.min() * 0.01
+            logger.info(
+                "Automatically set max residual for solving position "
+                f"equations to {max_resid}"
+            )
+
         # solve for cell parameters
         cell_params = solve_for_aflow_cell_params_from_primitive_ase_cell_params(
             atoms.cell.cellpar(), prototype_label
@@ -1655,11 +1686,13 @@ class AFLOW:
                 # The internal shift may have taken us to an internal parameter
                 # solution that represents a rotation, so we need to check
                 if self.confirm_unrotated_prototype_designation(
-                    atoms,
-                    species,
-                    prototype_label,
-                    candidate_prototype_param_values,
-                    cell_rtol,
+                    reference_atoms=atoms,
+                    species=species,
+                    prototype_label=prototype_label,
+                    parameter_values=candidate_prototype_param_values,
+                    cell_rtol=cell_rtol,
+                    rot_rtol=rot_rtol,
+                    rot_atol=rot_atol,
                 ):
                     logger.info(
                         f"Found set of parameters for prototype {prototype_label} "
@@ -1689,7 +1722,9 @@ class AFLOW:
         test_atoms: Atoms,
         ref_atoms: Atoms,
         sgnum: Union[int, str],
-        rtol: float = 0.01,
+        cell_rtol: float = 0.01,
+        rot_rtol: float = 0.01,
+        rot_atol: float = 0.01,
     ) -> bool:
         """
         Check whether `test_atoms` and `reference_atoms` are unrotated as follows:
@@ -1711,11 +1746,21 @@ class AFLOW:
                 Primitive cell of a crystal
             sgnum:
                 Space group number
-            rtol:
+            cell_rtol:
                 Parameter to pass to :func:`numpy.allclose` for comparing cell params.
+                Justification for default value: AFLOW uses 0.01*(minimum NN distance)
+                as default tolerance.
+            rot_rtol:
+                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)
+            rot_atol:
+                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)
         """
         if not np.allclose(
-            ref_atoms.cell.cellpar(), test_atoms.cell.cellpar(), rtol=rtol
+            ref_atoms.cell.cellpar(), test_atoms.cell.cellpar(), rtol=cell_rtol
         ):
             logger.info(
                 "Cell lengths and angles do not match.\n"
@@ -1748,7 +1793,11 @@ class AFLOW:
             return False
 
         return cartesian_rotation_is_in_point_group(
-            cart_rot, sgnum, test_atoms_copy.cell
+            cart_rot=cart_rot,
+            sgnum=sgnum,
+            cell=test_atoms_copy.cell,
+            rtol=rot_rtol,
+            atol=rot_atol,
         )
 
     def confirm_unrotated_prototype_designation(
@@ -1757,7 +1806,9 @@ class AFLOW:
         species: List[str],
         prototype_label: str,
         parameter_values: List[float],
-        rtol: float = 0.01,
+        cell_rtol: float = 0.01,
+        rot_rtol: float = 0.01,
+        rot_atol: float = 0.01,
     ) -> bool:
         """
         Check whether the provided prototype designation recreates ``reference_atoms``
@@ -1779,8 +1830,18 @@ class AFLOW:
                 without specified atomic species
             parameter_values:
                 The free parameters of the AFLOW prototype designation
-            rtol:
+            cell_rtol:
                 Parameter to pass to :func:`numpy.allclose` for comparing cell params
+                Justification for default value: AFLOW uses 0.01*(minimum NN distance)
+                as default tolerance.
+            rot_rtol:
+                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)
+            rot_atol:
+                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)
 
         Returns:
             Whether or not the crystals match
@@ -1792,8 +1853,10 @@ class AFLOW:
         )
 
         return self.confirm_atoms_unrotated_when_cells_aligned(
-            test_atoms,
-            reference_atoms,
-            get_space_group_number_from_prototype(prototype_label),
-            rtol,
+            test_atoms=test_atoms,
+            ref_atoms=reference_atoms,
+            sgnum=get_space_group_number_from_prototype(prototype_label),
+            cell_rtol=cell_rtol,
+            rot_rtol=rot_rtol,
+            rot_atol=rot_atol,
         )

kim_tools/symmetry_util/core.py

@@ -168,7 +168,11 @@ def fractional_to_cartesian_itc_rotation_from_ase_cell(
 
 
 def cartesian_rotation_is_in_point_group(
-    cart_rot: ArrayLike, sgnum: Union[int, str], cell: ArrayLike
+    cart_rot: ArrayLike,
+    sgnum: Union[int, str],
+    cell: ArrayLike,
+    rtol: float = 1e-2,
+    atol: float = 1e-2,
 ) -> bool:
     """
     Check that a Cartesian rotation is in the point group of a crystal given by its
@@ -184,6 +188,14 @@ def cartesian_rotation_is_in_point_group(
             http://doi.org/10.1016/j.commatsci.2017.01.017, with each row being a
             cartesian vector representing a lattice vector. This is
             consistent with most simulation packages, but transposed from the ITC
+        rtol:
+            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)
+        atol:
+            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)
     """
     # we don't care about properly transposing (i.e. worrying whether it's operating on
     # row or column vectors) the input cart_rot because that one is orthogonal, and
@@ -192,9 +204,11 @@ def cartesian_rotation_is_in_point_group(
 
     space_group_ops = get_primitive_genpos_ops(sgnum)
 
+    logger.info(f"Attempting to match fractional rotation:\n{frac_rot}")
+
     for op in space_group_ops:
-        if np.allclose(frac_rot, op["W"], atol=1e-4):
-            logger.info("Found matching rotation")
+        if np.allclose(frac_rot, op["W"], rtol=rtol, atol=atol):
+            logger.info(f"Found matching rotation with point group op:\n{op['W']}")
             return True
 
     logger.info("No matching rotation found")

kim_tools/test_driver/core.py

@@ -1219,7 +1219,12 @@ class SingleCrystalTestDriver(KIMTestDriver):
                 logger.info(msg)
 
     def _update_nominal_parameter_values(
-        self, atoms: Atoms, max_resid: float = 1e-5, cell_rtol: float = 0.01
+        self,
+        atoms: Atoms,
+        max_resid: Optional[float] = None,
+        cell_rtol: float = 0.01,
+        rot_rtol: float = 0.01,
+        rot_atol: float = 0.01,
     ) -> None:
         """
         Update the nominal parameter values of the nominal crystal structure from the
@@ -1250,9 +1255,20 @@ class SingleCrystalTestDriver(KIMTestDriver):
             atoms: Structure to analyze to get the new parameter values
             max_resid:
                 Maximum residual allowed when attempting to match the fractional
-                positions of the atoms to the crystallographic equations
+                positions of the atoms to the crystallographic equations.
+                If not provided, this is automatically set to 0.01*(minimum NN distance)
             cell_rtol:
-                Relative tolerance on cell lengths and angles
+                Relative tolerance on cell lengths and angles.
+                Justification for default value: AFLOW uses 0.01*(minimum NN distance)
+                as default tolerance.
+            rot_rtol:
+                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)
+            rot_atol:
+                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)
 
         Raises:
             AFLOW.FailedToMatchException:
@@ -1272,6 +1288,8 @@ class SingleCrystalTestDriver(KIMTestDriver):
                 ],
                 max_resid=max_resid,
                 cell_rtol=cell_rtol,
+                rot_rtol=rot_rtol,
+                rot_atol=rot_atol,
             )
         except (AFLOW.FailedToMatchException, AFLOW.ChangedSymmetryException) as e:
             raise type(e)(
@@ -1516,7 +1534,10 @@ class SingleCrystalTestDriver(KIMTestDriver):
     def deduplicate_property_instances(
         self,
         properties_to_deduplicate: Optional[List[str]] = None,
-        allow_rotation: bool = True,
+        allow_rotation: bool = False,
+        aflow_np: int = 4,
+        rot_rtol: float = 0.01,
+        rot_atol: float = 0.01,
     ) -> None:
         """
         In the internally stored property instances,
@@ -1537,9 +1558,26 @@ class SingleCrystalTestDriver(KIMTestDriver):
             allow_rotation:
                 Whether or not structures that are rotated by a rotation that is not in
                 the crystal's point group are considered identical
+            aflow_np:
+                Number of processors to use to run the AFLOW executable
+            rot_rtol:
+                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). Used only if
+                `allow_rotation` is False
+            rot_atol:
+                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). Used only if
+                `allow_rotation` is False
         """
         deduplicated_property_instances = get_deduplicated_property_instances(
-            self.property_instances, properties_to_deduplicate, allow_rotation
+            property_instances=self.property_instances,
+            properties_to_deduplicate=properties_to_deduplicate,
+            allow_rotation=allow_rotation,
+            aflow_np=aflow_np,
+            rot_rtol=rot_rtol,
+            rot_atol=rot_atol,
         )
         logger.info(
             f"Deduplicated {len(self.property_instances)} Property Instances "
@@ -1743,8 +1781,10 @@ def query_crystal_structures(
 
 def detect_unique_crystal_structures(
     crystal_structures: Union[List[Dict], Dict],
-    allow_rotation: bool = True,
+    allow_rotation: bool = False,
     aflow_np: int = 4,
+    rot_rtol: float = 0.01,
+    rot_atol: float = 0.01,
 ) -> Dict:
     """
     Detect which of the provided crystal structures is unique
@@ -1761,6 +1801,18 @@ def detect_unique_crystal_structures(
         allow_rotation:
             Whether or not structures that are rotated by a rotation that is not in the
             crystal's point group are considered identical
+        aflow_np:
+            Number of processors to use to run the AFLOW executable
+        rot_rtol:
+            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). Used only if
+            `allow_rotation` is False
+        rot_atol:
+            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). Used only if
+            `allow_rotation` is False
     Returns:
         Dictionary with keys corresponding to indices of unique structures and values
         being lists of indices of their duplicates
@@ -1813,7 +1865,13 @@ def detect_unique_crystal_structures(
                     "structures_duplicate"
                 ]:
                     cart_rot = potential_rotated_duplicate["rotation"]
-                    if not cartesian_rotation_is_in_point_group(cart_rot, sgnum, cell):
+                    if not cartesian_rotation_is_in_point_group(
+                        cart_rot=cart_rot,
+                        sgnum=sgnum,
+                        cell=cell,
+                        rtol=rot_rtol,
+                        atol=rot_atol,
+                    ):
                         i_rot_dup = int(
                             potential_rotated_duplicate["name"].split("/")[-1]
                         )
@@ -1825,7 +1883,11 @@ def detect_unique_crystal_structures(
 
                 unique_materials.update(
                     detect_unique_crystal_structures(
-                        rotated_structures, False, aflow_np
+                        crystal_structures=rotated_structures,
+                        allow_rotation=False,
+                        aflow_np=aflow_np,
+                        rot_rtol=rot_rtol,
+                        rot_atol=rot_atol,
                     )
                 )
 
@@ -1835,7 +1897,10 @@ def detect_unique_crystal_structures(
 def get_deduplicated_property_instances(
     property_instances: List[Dict],
     properties_to_deduplicate: Optional[List[str]] = None,
-    allow_rotation: bool = True,
+    allow_rotation: bool = False,
+    aflow_np: int = 4,
+    rot_rtol: float = 0.01,
+    rot_atol: float = 0.01,
 ) -> List[Dict]:
     """
     Given a list of dictionaries constituting KIM Property instances,
@@ -1858,6 +1923,18 @@ def get_deduplicated_property_instances(
         allow_rotation:
             Whether or not structures that are rotated by a rotation that is not in the
             crystal's point group are considered identical
+        aflow_np:
+            Number of processors to use to run the AFLOW executable
+        rot_rtol:
+            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). Used only if
+            `allow_rotation` is False
+        rot_atol:
+            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). Used only if
+            `allow_rotation` is False
 
     Returns:
         The deduplicated property instances
@@ -1887,7 +1964,11 @@ def get_deduplicated_property_instances(
 
         # Get unique-duplicate dictionary
         unique_crystal_structures = detect_unique_crystal_structures(
-            property_instances_curr_name, allow_rotation
+            crystal_structures=property_instances_curr_name,
+            allow_rotation=allow_rotation,
+            aflow_np=aflow_np,
+            rot_rtol=rot_rtol,
+            rot_atol=rot_atol,
         )
 
         # Put together the list of unique instances for the current

{kim_tools-0.2.2.dist-info → kim_tools-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kim-tools
-Version: 0.2.2
+Version: 0.2.3
 Summary: Base classes and helper routines for writing KIM Tests
 Author-email: ilia Nikiforov <nikif002@umn.edu>, Ellad Tadmor <tadmor@umn.edu>, Claire Waters <bwaters@umn.edu>, "Daniel S. Karls" <karl0100umn@gmail.com>, Matt Bierbaum <matt.bierbaum@gmail.com>, Eric Fuemmeler <efuemmel@umn.edu>
 Maintainer-email: ilia Nikiforov <nikif002@umn.edu>

{kim_tools-0.2.2.dist-info → kim_tools-0.2.3.dist-info}/RECORD

@@ -1,12 +1,12 @@
-kim_tools/__init__.py,sha256=gGt0sG7foY9MROLXGAYUkxV8GdwEulr_PS5wMm06mcM,433
+kim_tools/__init__.py,sha256=KCoi0Z7lrEF8Q2naGttDB6JIrnlSoBPfubmh0QePzPY,433
 kim_tools/kimunits.py,sha256=jOxBv9gRVhxPE6ygAIUxOzCAfPI6tT6sBaF_FNl9m-M,5387
 kim_tools/aflow_util/__init__.py,sha256=lJnQ8fZCma80QVRQeKvY4MQ87oCWu-9KATV3dKJfpDc,80
-kim_tools/aflow_util/core.py,sha256=57K2G1jGgJhUA312RkWnhb3MOmlo9B5DdenNb_dIkzc,72206
+kim_tools/aflow_util/core.py,sha256=1oHweHfm1m_7hVD1ziyrWpe9IbkbxFXAj7FKtav8FiI,75538
 kim_tools/aflow_util/data/README_PROTO.TXT,sha256=bTpcd8GHOkpcQn6YUZzqKhiTytwSDpkgu4boeoogT38,447851
 kim_tools/ase/__init__.py,sha256=1i6ko5tNr0VZC3T7hoEzq4fnSU0DdxNpxXcSaWMcJWc,76
 kim_tools/ase/core.py,sha256=d6eOu_HSxVr-ae0TSEbY4HKdePxhNu3yv8NN9VDl-BA,30256
 kim_tools/symmetry_util/__init__.py,sha256=uu-ZSUDUTe2P81rkAS3tXverx31s_uZ3wL4SD_dn5aI,86
-kim_tools/symmetry_util/core.py,sha256=VTYH1MRADraJVc6SBfFHZweWI_WZgCViSKM4MazF7KY,21634
+kim_tools/symmetry_util/core.py,sha256=EED_LYfgwf6mmFwTJlzIwTvf8RUiM29bkzEIQrOqwUw,22271
 kim_tools/symmetry_util/data/possible_primitive_shifts.json,sha256=4OVNgn3NnykgGlYiAcecERmVWiIZFrmP2LZI3ml_Sh0,25010
 kim_tools/symmetry_util/data/primitive_GENPOS_ops.json,sha256=FDu4H4PosOpK9yKwOPy3SxbH7xLMOmZfKZ4ItKPMjoQ,224498
 kim_tools/symmetry_util/data/space_groups_for_each_bravais_lattice.json,sha256=wSNu6d5pH72lJ6Zj5MZ64qzwS_6Fn5WOs0ts7E9uPC4,2507
@@ -14,11 +14,11 @@ kim_tools/symmetry_util/data/wyck_pos_xform_under_normalizer.json,sha256=6g1YuYh
 kim_tools/symmetry_util/data/wyckoff_multiplicities.json,sha256=qG2RPBd_-ejDIfz-E4ZhkHyRpIboxRy7oiXkdDf5Eg8,32270
 kim_tools/symmetry_util/data/wyckoff_sets.json,sha256=f5ZpHKDHo6_JWki1b7KUGoYLlhU-44Qikw_-PtbLssw,9248
 kim_tools/test_driver/__init__.py,sha256=KOiceeZNqkfrgZ66CiRiUdniceDrCmmDXQkOw0wXaCQ,92
-kim_tools/test_driver/core.py,sha256=bA1tZPM3dES5PZSanN_xPC-SApSB1usO10EvoIq8EgY,78685
+kim_tools/test_driver/core.py,sha256=N0xnJzF_yF5tav3nqeUyX1NSrJUDigYV6n7Ym4wtzLA,82518
 kim_tools/vc/__init__.py,sha256=zXjhxXCKVMLBMXXWYG3if7VOpBnsFrn_RjVpnohDm5c,74
 kim_tools/vc/core.py,sha256=BIjzEExnQAL2S90a_npptRm3ACqAo4fZBtvTDBMWMdw,13963
-kim_tools-0.2.2.dist-info/licenses/LICENSE.CDDL,sha256=I2luEED_SHjuZ01B4rYG-AF_135amL24JpHvZ1Jhqe8,16373
-kim_tools-0.2.2.dist-info/METADATA,sha256=3OJoiiqV0-dLI_4hq--8wWF5BcedispUTMgZ1Z4ieR8,1460
-kim_tools-0.2.2.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-kim_tools-0.2.2.dist-info/top_level.txt,sha256=w_YCpJ5ERigj9te74ln7k64tqj1VumOzM_s9dsalIWY,10
-kim_tools-0.2.2.dist-info/RECORD,,
+kim_tools-0.2.3.dist-info/licenses/LICENSE.CDDL,sha256=I2luEED_SHjuZ01B4rYG-AF_135amL24JpHvZ1Jhqe8,16373
+kim_tools-0.2.3.dist-info/METADATA,sha256=Z_rs3Y3nRmX-11yJo8MuGK-GHUXvdhPWdpUPwLQmmFc,1460
+kim_tools-0.2.3.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+kim_tools-0.2.3.dist-info/top_level.txt,sha256=w_YCpJ5ERigj9te74ln7k64tqj1VumOzM_s9dsalIWY,10
+kim_tools-0.2.3.dist-info/RECORD,,