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

kim_tools/symmetry_util/elasticity.py

@@ -0,0 +1,390 @@
+import logging
+import math
+import os
+import shutil
+from typing import Dict, List, Tuple, Union
+
+import numpy as np
+import numpy.typing as npt
+
+from .core import DATA_DIR, _check_space_group
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(filename="kim-tools.log", level=logging.INFO, force=True)
+
+
+def voigt_elast_class(sgnum: Union[int, str]) -> str:
+    """
+    Get the name of the class of the structure of the elasticity tensor, out of
+    the following possibilities:
+    "cubic", "hexagonal", "trigonal_3bar_m_2nd_pos", "trigonal_3bar_m_3rd_pos",
+    "trigonal_3bar", "tetragonal_class_4_slash_mmm", "tetragonal_class_4_slash_m",
+    "orthorhombic", "monoclinic", "triclinic". The names that don't
+    correspond to a crystal system are taken from
+    https://dictionary.iucr.org/Laue_class
+
+    Note that this is a novel classification as far as the authors are aware.
+    Most crystallography texts on the subject will show 9 classes. This function
+    returns 10 possibilities, because the structure of the components of
+    the elasticity tensor for Laue class -3m depends on whether the twofold
+    axis is aligned along the Cartesian x or y axis. Assuming one adopts a
+    standard orientation of the hexagonal unit cell w.r.t. the Cartesian coordinate
+    system, as we do, different space groups in this Laue class have different
+    forms.
+
+    See https://doi.org/10.1017/CBO9781139017657.008 pg 232 for a review
+    of the subject.
+    """
+    _check_space_group(sgnum)
+    sgnum = int(sgnum)
+
+    if sgnum < 3:
+        return "triclinic"
+    elif sgnum < 16:
+        return "monoclinic"
+    elif sgnum < 75:
+        return "orthorhombic"
+    elif sgnum < 89:
+        return "tetragonal_4_slash_m"
+    elif sgnum < 143:
+        return "tetragonal_4_slash_mmm"
+    elif sgnum < 149:
+        return "trigonal_3bar"
+    elif sgnum < 168:
+        # Determine if this is one of the groups with the 2-fold operation in the
+        # third position (e.g. 149:P312), which has different equations
+        if sgnum in (149, 151, 153, 157, 159, 162, 163):
+            return "trigonal_3bar_m_3rd_pos"
+        else:
+            return "trigonal_3bar_m_2nd_pos"
+    elif sgnum < 195:
+        return "hexagonal"
+    else:
+        return "cubic"
+
+
+def voigt_elast_compon_eqn(sgnum: Union[int, str]) -> Dict:
+    """
+    Get the algebraic equations describing the symmetry restrictions
+    on the elasticity matrix in Voigt form given a space group number.
+    The unit cell
+    must be in the orientation defined in doi.org/10.1016/j.commatsci.2017.01.017
+    for these equations to be correct.
+
+    Returns:
+        Encoding of symmetry restrictions on elasticity matrices.
+        The keys are the Voigt indices of non-independent components.
+        The values are a pair of lists representing the linear combination
+        of the unique compoonents that is used to determine the non-unique component
+        specified in the key. The first list is the coefficients, the second
+        is the indices. If a non-independent component is zero, this is indicated
+        by a value of None. Any components not listed as a key are assumed to
+        be independent. Only the upper triangle (i<j) is listed. Indices are
+        one-based.
+    """
+    ELASTICITY_MATRIX_EQNS = {
+        "cubic": {
+            (1, 3): ([1], [(1, 2)]),
+            (1, 4): None,
+            (1, 5): None,
+            (1, 6): None,
+            (2, 2): ([1], [(1, 1)]),
+            (2, 3): ([1], [(1, 2)]),
+            (2, 4): None,
+            (2, 5): None,
+            (2, 6): None,
+            (3, 3): ([1], [(1, 1)]),
+            (3, 4): None,
+            (3, 5): None,
+            (3, 6): None,
+            (4, 5): None,
+            (4, 6): None,
+            (5, 5): ([1], [(4, 4)]),
+            (5, 6): None,
+            (6, 6): ([1], [(4, 4)]),
+        },
+        "hexagonal": {
+            (1, 4): None,
+            (1, 5): None,
+            (1, 6): None,
+            (2, 2): ([1], [(1, 1)]),
+            (2, 3): ([1], [(1, 3)]),
+            (2, 4): None,
+            (2, 5): None,
+            (2, 6): None,
+            (3, 4): None,
+            (3, 5): None,
+            (3, 6): None,
+            (4, 5): None,
+            (4, 6): None,
+            (5, 5): ([1], [(4, 4)]),
+            (5, 6): None,
+            (6, 6): ([0.5, -0.5], [(1, 1), (1, 2)]),
+        },
+        "trigonal_3bar_m_2nd_pos": {
+            (1, 5): None,
+            (1, 6): None,
+            (2, 2): ([1], [(1, 1)]),
+            (2, 3): ([1], [(1, 3)]),
+            (2, 4): ([-1], [(1, 4)]),
+            (2, 5): None,
+            (2, 6): None,
+            (3, 4): None,
+            (3, 5): None,
+            (3, 6): None,
+            (4, 5): None,
+            (4, 6): None,
+            (5, 5): ([1], [(4, 4)]),
+            (5, 6): ([1], [(1, 4)]),
+            (6, 6): ([0.5, -0.5], [(1, 1), (1, 2)]),
+        },
+        "trigonal_3bar_m_3rd_pos": {
+            (1, 4): None,
+            (1, 6): None,
+            (2, 2): ([1], [(1, 1)]),
+            (2, 3): ([1], [(1, 3)]),
+            (2, 4): None,
+            (2, 5): ([-1], [(1, 5)]),
+            (2, 6): None,
+            (3, 4): None,
+            (3, 5): None,
+            (3, 6): None,
+            (4, 5): None,
+            (4, 6): ([-1], [(1, 5)]),
+            (5, 5): ([1], [(4, 4)]),
+            (5, 6): None,
+            (6, 6): ([0.5, -0.5], [(1, 1), (1, 2)]),
+        },
+        "trigonal_3bar": {
+            (1, 6): None,
+            (2, 2): ([1], [(1, 1)]),
+            (2, 3): ([1], [(1, 3)]),
+            (2, 4): ([-1], [(1, 4)]),
+            (2, 5): ([-1], [(1, 5)]),
+            (2, 6): None,
+            (3, 4): None,
+            (3, 5): None,
+            (3, 6): None,
+            (4, 5): None,
+            (4, 6): ([-1], [(1, 5)]),
+            (5, 5): ([1], [(4, 4)]),
+            (5, 6): ([1], [(1, 4)]),
+            (6, 6): ([0.5, -0.5], [(1, 1), (1, 2)]),
+        },
+        "tetragonal_4_slash_mmm": {
+            (1, 4): None,
+            (1, 5): None,
+            (1, 6): None,
+            (2, 2): ([1], [(1, 1)]),
+            (2, 3): ([1], [(1, 3)]),
+            (2, 4): None,
+            (2, 5): None,
+            (2, 6): None,
+            (3, 4): None,
+            (3, 5): None,
+            (3, 6): None,
+            (4, 5): None,
+            (4, 6): None,
+            (5, 5): ([1], [(4, 4)]),
+            (5, 6): None,
+        },
+        "tetragonal_4_slash_m": {
+            (1, 4): None,
+            (1, 5): None,
+            (2, 2): ([1], [(1, 1)]),
+            (2, 3): ([1], [(1, 3)]),
+            (2, 4): None,
+            (2, 5): None,
+            (2, 6): ([-1], [(1, 6)]),
+            (3, 4): None,
+            (3, 5): None,
+            (3, 6): None,
+            (4, 5): None,
+            (4, 6): None,
+            (5, 5): ([1], [(4, 4)]),
+            (5, 6): None,
+        },
+        "orthorhombic": {
+            (1, 4): None,
+            (1, 5): None,
+            (1, 6): None,
+            (2, 4): None,
+            (2, 5): None,
+            (2, 6): None,
+            (3, 4): None,
+            (3, 5): None,
+            (3, 6): None,
+            (4, 5): None,
+            (4, 6): None,
+            (5, 6): None,
+        },
+        "monoclinic": {
+            (1, 4): None,
+            (1, 6): None,
+            (2, 4): None,
+            (2, 6): None,
+            (3, 4): None,
+            (3, 6): None,
+            (4, 5): None,
+            (5, 6): None,
+        },
+        "triclinic": {},
+    }
+
+    # error check typing in the above dicts
+    for eqn in ELASTICITY_MATRIX_EQNS.values():
+        # only unique keys
+        assert sorted(list(set(eqn.keys()))) == sorted(list(eqn.keys()))
+        # check that all components appearing in RHS of relations are independent, i.e.
+        # they don't appear as a key
+        for dependent_component in eqn:
+            if eqn[dependent_component] is not None:
+                for independent_component in eqn[dependent_component][1]:
+                    assert not (independent_component in eqn)
+
+    return ELASTICITY_MATRIX_EQNS[voigt_elast_class(sgnum)]
+
+
+def voigt_elast_struct_svg(sgnum: Union[int, str], dest_filename: str) -> None:
+    """
+    Write a copy of the image showing the structure of the Voigt elasticity matrix for
+    the specified space group
+    """
+    src_filename = os.path.join(DATA_DIR, "elast_" + voigt_elast_class(sgnum) + ".svg")
+    shutil.copyfile(src_filename, dest_filename)
+
+
+def indep_elast_compon_names_and_values_from_voigt(
+    voigt: npt.ArrayLike, sgnum: Union[int, str]
+) -> Tuple[List[str], List[float]]:
+    """
+    From an elasticity matrix in Voigt order and a space group number,
+    extract the elastic constants that should be unique (cij where first i is as low as
+    possible, then j)
+    """
+    eqn = voigt_elast_compon_eqn(sgnum)
+
+    elastic_constants_names = []
+    elastic_constants_values = []
+
+    # first, figure out which constants are unique and extract them
+    for i in range(1, 7):
+        for j in range(i, 7):
+            if (i, j) not in eqn:
+                elastic_constants_names.append("c" + str(i) + str(j))
+                elastic_constants_values.append(voigt[i - 1, j - 1])
+
+    return elastic_constants_names, elastic_constants_values
+
+
+def calc_bulk(elastic_constants):
+    """
+    Compute the bulk modulus given the elastic constants matrix in
+    Voigt ordering.
+
+    Parameters:
+        elastic_constants : float
+            A 6x6 numpy array containing the elastic constants in
+            Voigt ordering. The material can have arbitrary anisotropy.
+
+    Returns:
+        bulk : float
+            The bulk modulus, defined as the ratio between the hydrostatic
+            stress (negative of the pressure p) in hydrostatic loading and
+            the diltation e (trace of the strain tensor), i.e. B = -p/e
+    """
+    # Compute bulk modulus, based on exercise 6.14 in Tadmor, Miller, Elliott,
+    # Continuum Mechanics and Thermodynamics, Cambridge University Press, 2012.
+    rank_elastic_constants = np.linalg.matrix_rank(elastic_constants)
+    elastic_constants_aug = np.concatenate(
+        (elastic_constants, np.transpose([[1, 1, 1, 0, 0, 0]])), 1
+    )
+    rank_elastic_constants_aug = np.linalg.matrix_rank(elastic_constants_aug)
+    if rank_elastic_constants_aug > rank_elastic_constants:
+        assert rank_elastic_constants_aug == rank_elastic_constants + 1
+        logger.info(
+            "Information: Hydrostatic pressure not in the image of the elasticity "
+            "matrix, zero bulk modulus!"
+        )
+        return 0.0
+    else:
+        # if a solution exists for a stress state of [1,1,1,0,0,0],
+        # you can always use the pseudoinverse
+        compliance = np.linalg.pinv(elastic_constants)
+        bulk = 1 / np.sum(compliance[0:3, 0:3])
+    return bulk
+
+
+def map_to_Kelvin(C: npt.ArrayLike) -> npt.ArrayLike:
+    """
+    Compute the Kelvin form of the input 6x6 Voigt matrix
+    """
+    Ch = C.copy()
+    Ch[0:3, 3:6] *= math.sqrt(2.0)
+    Ch[3:6, 0:3] *= math.sqrt(2.0)
+    Ch[3:6, 3:6] *= 2.0
+    return Ch
+
+
+def function_of_matrix(A, f):
+    """Compute the function of a matrix"""
+    ev, R = np.linalg.eigh(A)
+    Dtilde = np.diag([f(e) for e in ev])
+    return np.matmul(np.matmul(R, Dtilde), np.transpose(R))
+
+
+def find_nearest_isotropy(elastic_constants):
+    """
+    Compute the distance between the provided matrix of elastic constants
+    in Voigt notation, to the nearest matrix of elastic constants for an
+    isotropic material. Return this distance, and the isotropic bulk and
+    shear modulus.
+
+    Ref: Morin, L; Gilormini, P and Derrien, K,
+         "Generalized Euclidean Distances for Elasticity Tensors",
+         Journal of Elasticity, Vol 138, pp. 221-232 (2020).
+
+    Parameters:
+        elastic_constants : float
+            A 6x6 numpy array containing the elastic constants in
+            Voigt ordering. The material can have arbitrary anisotropy.
+
+    Returns:
+        d : float
+            Distance to the nearest elastic constants.
+            log Euclidean metric.
+        kappa : float
+            Isotropic bulk modulus
+        mu : float
+            Isotropic shear modulus
+    """
+    E0 = 1.0  # arbitrary scaling constant (result unaffected by it)
+
+    JJ = np.zeros(shape=(6, 6))
+    KK = np.zeros(shape=(6, 6))
+    v = {0: [0, 0], 1: [1, 1], 2: [2, 2], 3: [1, 2], 4: [0, 2], 5: [0, 1]}
+    for ii in range(6):
+        for jj in range(6):
+            # i j k l = v[ii][0] v[ii][1] v[jj][0] v[jj][1]
+            JJ[ii][jj] = (1.0 / 3.0) * (v[ii][0] == v[ii][1]) * (v[jj][0] == v[jj][1])
+            KK[ii][jj] = (1.0 / 2.0) * (
+                (v[ii][0] == v[jj][0]) * (v[ii][1] == v[jj][1])
+                + (v[ii][0] == v[jj][1]) * (v[ii][1] == v[jj][0])
+            ) - JJ[ii][jj]
+    Chat = map_to_Kelvin(elastic_constants)
+    JJhat = map_to_Kelvin(JJ)
+    KKhat = map_to_Kelvin(KK)
+
+    # Eqn (49) in Morin et al.
+    fCoverE0 = function_of_matrix(Chat / E0, math.log)
+    kappa = (E0 / 3.0) * math.exp(np.einsum("ij,ij", fCoverE0, JJhat))
+    mu = (E0 / 2.0) * math.exp(0.2 * np.einsum("ij,ij", fCoverE0, KKhat))
+
+    # Eqn (47) in Morin et al.
+    dmat = (
+        fCoverE0 - math.log(3.0 * kappa / E0) * JJhat - math.log(2.0 * mu / E0) * KKhat
+    )
+    d = math.sqrt(np.einsum("ij,ij", dmat, dmat))
+
+    # Return results
+    return d, kappa, mu

kim_tools/test_driver/core.py

@@ -30,6 +30,7 @@
 Helper classes for KIM Test Drivers
 
 """
+import json
 import logging
 import os
 import shutil
@@ -91,6 +92,7 @@ __all__ = [
     "detect_unique_crystal_structures",
     "get_deduplicated_property_instances",
     "minimize_wrapper",
+    "crystal_input_from_test_generator_line",
 ]
 
 # Force tolerance for the optional initial relaxation of the provided cell
@@ -509,11 +511,15 @@ class KIMTestDriver(ABC):
         requires a KIM model (e.g. a LAMMPS TD) with a non-KIM Calculator
         """
 
-    def __init__(self, model: Union[str, Calculator]) -> None:
+    def __init__(
+        self, model: Union[str, Calculator], suppr_sm_lmp_log: bool = False
+    ) -> None:
         """
         Args:
             model:
                 ASE calculator or KIM model name to use
+            suppr_sm_lmp_log:
+                Suppress writing a lammps.log
         """
         if isinstance(model, Calculator):
             self.__calc = model
@@ -523,6 +529,9 @@ class KIMTestDriver(ABC):
 
             self.__kim_model_name = model
             self.__calc = KIM(self.__kim_model_name)
+            if suppr_sm_lmp_log:
+                if hasattr(self.__calc.parameters, "log_file"):
+                    self.__calc.parameters.log_file = None
 
         self.__output_property_instances = "[]"
 
@@ -560,6 +569,8 @@ class KIMTestDriver(ABC):
         # count how many instances we had before we started
         previous_properties_end = len(kim_edn.loads(self.__output_property_instances))
 
+        os.makedirs("output", exist_ok=True)
+
         # _setup is likely overridden by an derived class
         self._setup(material, **kwargs)
 
@@ -1193,17 +1204,22 @@ class SingleCrystalTestDriver(KIMTestDriver):
     """
 
     def __init__(
-        self, model: Union[str, Calculator], aflow_executable: str = AFLOW_EXECUTABLE
+        self,
+        model: Union[str, Calculator],
+        suppr_sm_lmp_log: bool = False,
+        aflow_executable: str = AFLOW_EXECUTABLE,
     ) -> None:
         """
         Args:
             model:
                 ASE calculator or KIM model name to use
+            suppr_sm_lmp_log:
+                Suppress writing a lammps.log
             aflow_executable:
                 Path to AFLOW executable
         """
         self.aflow_executable = aflow_executable
-        super().__init__(model)
+        super().__init__(model, suppr_sm_lmp_log=suppr_sm_lmp_log)
 
     def _setup(
         self,
@@ -1878,9 +1894,8 @@ class SingleCrystalTestDriver(KIMTestDriver):
         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 get_atom_indices_for_each_wyckoff_orb(self.get_nominal_prototype_label())
 
@@ -2236,3 +2251,42 @@ def get_deduplicated_property_instances(
     property_instances_deduplicated.sort(key=lambda a: a["instance-id"])
 
     return property_instances_deduplicated
+
+
+def crystal_input_from_test_generator_line(
+    test_generator_line: str, kim_model_name: str
+) -> List[Dict]:
+    """
+    Produce a list of dictionaries of kwargs for a Crystal Genome Test Driver invocation
+    from a line in its ``test_generator.json``
+    """
+    test_generator_dict = json.loads(test_generator_line)
+    stoichiometric_species = test_generator_dict["stoichiometric_species"]
+    prototype_label = test_generator_dict["prototype_label"]
+    cell_cauchy_stress_eV_angstrom3 = test_generator_dict.get(
+        "cell_cauchy_stress_eV_angstrom3"
+    )
+    temperature_K = test_generator_dict.get("temperature_K")
+    crystal_genome_test_args = test_generator_dict.get("crystal_genome_test_args")
+    equilibria = query_crystal_structures(
+        stoichiometric_species=stoichiometric_species,
+        prototype_label=prototype_label,
+        kim_model_name=kim_model_name,
+    )
+    inputs = []
+    for equilibrium in equilibria:
+        inputs.append(
+            {
+                "material": equilibrium,
+            }
+        )
+        if cell_cauchy_stress_eV_angstrom3 is not None:
+            inputs[-1][
+                "cell_cauchy_stress_eV_angstrom3"
+            ] = cell_cauchy_stress_eV_angstrom3
+        if temperature_K is not None:
+            inputs[-1]["temperature_K"] = temperature_K
+        if crystal_genome_test_args is not None:
+            inputs[-1].update(crystal_genome_test_args)
+
+    return inputs

{kim_tools-0.3.6.dist-info → kim_tools-0.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kim-tools
-Version: 0.3.6
+Version: 0.3.7
 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>, Philipp Hoellmer <ph2484@nyu.edu>, Guanming Zhang <gz2241@nyu.edu>, Tom Egg <tje3676@nyu.edu>
 Maintainer-email: ilia Nikiforov <nikif002@umn.edu>

{kim_tools-0.3.6.dist-info → kim_tools-0.3.7.dist-info}/RECORD

@@ -1,7 +1,7 @@
-kim_tools/__init__.py,sha256=kYbIfF9bmWajsk_oLkaGok3kpnHeo1rlLBUAranse8o,433
+kim_tools/__init__.py,sha256=AZO0kIOJrYHA6ai-MX9cxxAzz4wsN21eGn9cAX7LRoc,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=YH1KCMQjXiKMqhT1TAuoafpsGqPlybsykRRMaa8wWqc,78219
+kim_tools/aflow_util/core.py,sha256=9qlQQwhcFKJ8HwcHdEPgoEKRK_viQAFlZUqCV9nlcE0,80301
 kim_tools/aflow_util/aflow_prototype_encyclopedia/data/A108B24C11D24_cP334_222_h4i_i_bf_i-001/info.json,sha256=IsFiO9X2Ko7yoq2QkDurUVP7k1BE4WFgblu7oxl6iZs,2013
 kim_tools/aflow_util/aflow_prototype_encyclopedia/data/A10B11_tI84_139_dehim_eh2n-001/info.json,sha256=f1EdtouuSL2y9NNw40Rvz2J9ZZcsqQBcyEmlHj6XoW8,1186
 kim_tools/aflow_util/aflow_prototype_encyclopedia/data/A10B2C_hP39_171_5c_c_a-001/info.json,sha256=vD1xjZKWShL0E6XNsSlmIhilGcGNefl56oQDLQlHO1M,1596
@@ -2004,7 +2004,18 @@ kim_tools/aflow_util/aflow_prototype_encyclopedia/data/A_tP50_134_a2m2n-001/info
 kim_tools/ase/__init__.py,sha256=1i6ko5tNr0VZC3T7hoEzq4fnSU0DdxNpxXcSaWMcJWc,76
 kim_tools/ase/core.py,sha256=odRuHQGZl-pcRtkdYvG31_3kW6nt3qwHdKvAOJ-ifwM,31207
 kim_tools/symmetry_util/__init__.py,sha256=uu-ZSUDUTe2P81rkAS3tXverx31s_uZ3wL4SD_dn5aI,86
-kim_tools/symmetry_util/core.py,sha256=aDaeYmtwfkNlNDcYQ3mAkez7e9_Lk84xQxwQ24cir38,34231
+kim_tools/symmetry_util/core.py,sha256=eMGgVt9MPcaLi_8jVMJ5UyQHvYbiiAFQ4HdJotnp8dk,43277
+kim_tools/symmetry_util/elasticity.py,sha256=VxJ8wUcsSOPyJ8id6OpKmVlRAbIUIWxtzYJtkvVJIVs,13328
+kim_tools/symmetry_util/data/elast_cubic.svg,sha256=UpN4XcoLoOwv8a7KE0WyINkSH5AU2DPVZ08eGQf-Cds,8953
+kim_tools/symmetry_util/data/elast_hexagonal.svg,sha256=wOkw5IO3fZy039tLHhvtwrkatVYs5XzigUormLKtRlw,8705
+kim_tools/symmetry_util/data/elast_monoclinic.svg,sha256=71zWo1ClStyVbM8KHLU-bEU1m7itJScFnsqIY7tHTuw,10555
+kim_tools/symmetry_util/data/elast_orthorhombic.svg,sha256=J-1rLi0JpBpHo0sD6gQcdO7CPZaYbuA6DUY6hMRqEcE,8197
+kim_tools/symmetry_util/data/elast_tetragonal_4_slash_m.svg,sha256=sBdXu0e0uqnglAyBJNoA-B7bllfp7_c9MiT7aCPNh0I,10321
+kim_tools/symmetry_util/data/elast_tetragonal_4_slash_mmm.svg,sha256=1oXCrWYqVhQetgcCNoGp-ypDgCyyugZ2023Evk417vI,8902
+kim_tools/symmetry_util/data/elast_triclinic.svg,sha256=9LGE6FLvYJ-4-M3c1BciasVkEu4eXo9jjeggJ8FJSIo,15269
+kim_tools/symmetry_util/data/elast_trigonal_3bar.svg,sha256=3gVsl_bRryw6hJRG7H_UTRDCWprcDhKfMXr7uQ5LDV4,12771
+kim_tools/symmetry_util/data/elast_trigonal_3bar_m_2nd_pos.svg,sha256=2kzOIKZPbQbGMwDzmlBs5pMg9EfrNZ7EV4ihnTiExz0,10738
+kim_tools/symmetry_util/data/elast_trigonal_3bar_m_3rd_pos.svg,sha256=pN8ov9-AQ2jYGoMZj5BrhLlYW2G-O6d5woz93H4K5Hc,10738
 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
@@ -2012,11 +2023,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=DseMkfdb-b116rRQQR0N7HKhsMsZGq8ZxtKoCBlw8X8,91307
+kim_tools/test_driver/core.py,sha256=sSdDBr99Y4NvKV_BKvz-T8Sp1p_pzk2teZoHv0IjpSo,93309
 kim_tools/vc/__init__.py,sha256=zXjhxXCKVMLBMXXWYG3if7VOpBnsFrn_RjVpnohDm5c,74
 kim_tools/vc/core.py,sha256=BIjzEExnQAL2S90a_npptRm3ACqAo4fZBtvTDBMWMdw,13963
-kim_tools-0.3.6.dist-info/licenses/LICENSE.CDDL,sha256=I2luEED_SHjuZ01B4rYG-AF_135amL24JpHvZ1Jhqe8,16373
-kim_tools-0.3.6.dist-info/METADATA,sha256=Q_aemQPU34z7rSPK04WnMP6WzUnS845Frlr3YWofcjw,2032
-kim_tools-0.3.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kim_tools-0.3.6.dist-info/top_level.txt,sha256=w_YCpJ5ERigj9te74ln7k64tqj1VumOzM_s9dsalIWY,10
-kim_tools-0.3.6.dist-info/RECORD,,
+kim_tools-0.3.7.dist-info/licenses/LICENSE.CDDL,sha256=I2luEED_SHjuZ01B4rYG-AF_135amL24JpHvZ1Jhqe8,16373
+kim_tools-0.3.7.dist-info/METADATA,sha256=xewZHVokzllXvhRCAbMMQ7JO5RNe8R2sB0VXEV7QyBM,2032
+kim_tools-0.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kim_tools-0.3.7.dist-info/top_level.txt,sha256=w_YCpJ5ERigj9te74ln7k64tqj1VumOzM_s9dsalIWY,10
+kim_tools-0.3.7.dist-info/RECORD,,