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

kim_tools/__init__.py

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

kim_tools/aflow_util/core.py

@@ -392,6 +392,67 @@ def get_wyckoff_lists_from_prototype(prototype_label: str) -> List[str]:
     return expanded_wyckoff_letters
 
 
+def get_atom_indices_for_each_wyckoff_orb(prototype_label: str) -> List[Dict]:
+    """
+    Get a list of dictionaries containing the atom indices of each Wyckoff
+    orbit.
+
+    Returns:
+        The information is in this format -- ``[{"letter":"a", "indices":[0,1]}, ... ]``
+    """
+    return_list = []
+    wyck_lists = get_wyckoff_lists_from_prototype(prototype_label)
+    sgnum = get_space_group_number_from_prototype(prototype_label)
+    range_start = 0
+    for letter in "".join(wyck_lists):
+        multiplicity = get_primitive_wyckoff_multiplicity(sgnum, letter)
+        range_end = range_start + multiplicity
+        return_list.append(
+            {"letter": letter, "indices": list(range(range_start, range_end))}
+        )
+        range_start = range_end
+    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,
@@ -841,9 +902,8 @@ class AFLOW:
                 "that the AFLOW executable was not found."
             )
         # 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):
+        aflow_ver = Version.parse(ver_str)
+        if aflow_ver.replace(prerelease=None) < Version.parse(REQUIRED_AFLOW):
             raise self.AFLOWNotFoundException(
                 f"Your AFLOW version {ver_str} is less "
                 f"than the required {REQUIRED_AFLOW}"
@@ -1580,6 +1640,8 @@ class AFLOW:
             self.get_library_prototype_label_and_shortname_from_atoms(atoms)
         )
 
+        # 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
         ):
@@ -1642,7 +1704,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

kim_tools/symmetry_util/core.py

@@ -12,8 +12,10 @@ from typing import Dict, List, Optional, Tuple, Union
 import matplotlib.pyplot as plt
 import numpy as np
 import numpy.typing as npt
+import sympy as sp
 from ase import Atoms
 from ase.cell import Cell
+from ase.constraints import FixSymmetry
 from ase.geometry import get_distances, get_duplicate_atoms
 from matplotlib.backends.backend_pdf import PdfPages
 from pymatgen.core.operations import SymmOp
@@ -21,6 +23,7 @@ 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
+from sympy.tensor.array.expressions import ArrayContraction, ArrayTensorProduct
 
 logger = logging.getLogger(__name__)
 logging.basicConfig(filename="kim-tools.log", level=logging.INFO, force=True)
@@ -617,6 +620,20 @@ def get_primitive_genpos_ops(sgnum: Union[int, str]) -> List[Dict]:
         return np.asarray(json.load(f)[str(sgnum)])
 
 
+def transform_atoms(atoms: Atoms, op: Dict) -> Atoms:
+    """
+    Transform atoms by an operation defined by a dictionary containing a matrix 'W' and
+    translation 'w' defined as fractional operations in the unit cell. 'W' should be
+    oriented to operate on column vectors
+    """
+    frac_pos_columns = atoms.get_scaled_positions().T
+    frac_pos_cols_xform = op["W"] @ frac_pos_columns + np.reshape(op["w"], (3, 1))
+    atoms_transformed = atoms.copy()
+    atoms_transformed.set_scaled_positions(frac_pos_cols_xform.T)
+    atoms_transformed.wrap()
+    return atoms_transformed
+
+
 def reduce_and_avg(
     atoms: Atoms, repeat: Tuple[int, int, int]
 ) -> Tuple[Atoms, npt.ArrayLike]:
@@ -790,6 +807,224 @@ def kstest_reduced_distances(
         )
 
 
+def voigt_to_full_symb(voigt_input: sp.Array) -> sp.MutableDenseNDimArray:
+    """
+    Convert a 3-dimensional symbolic Voigt matrix to a full tensor. Order is
+    automatically detected. For now, only works with tensors that don't have special
+    scaling for the Voigt matrix (e.g. this doesn't work with the
+    compliance tensor)
+    """
+    order = sum(voigt_input.shape) // 3
+    this_voigt_map = Tensor.get_voigt_dict(order)
+    t = sp.MutableDenseNDimArray(np.zeros([3] * order))
+    for ind, v in this_voigt_map.items():
+        t[ind] = voigt_input[v]
+    return t
+
+
+def full_to_voigt_symb(full: sp.Array) -> sp.MutableDenseNDimArray:
+    """
+    Convert a 3-dimensional symbolic full tensor to a Voigt matrix. Order is
+    automatically detected. For now, only works with tensors that don't have special
+    scaling for the Voigt matrix (e.g. this doesn't work with the
+    compliance tensor). No error checking is done to see if the
+    full tensor has the required symmetries to be converted to Voigt.
+    """
+    order = len(full.shape)
+    vshape = tuple([3] * (order % 2) + [6] * (order // 2))
+    v_matrix = sp.MutableDenseNDimArray(np.zeros(vshape))
+    this_voigt_map = Tensor.get_voigt_dict(order)
+    for ind, v in this_voigt_map.items():
+        v_matrix[v] = full[ind]
+    return v_matrix
+
+
+def rotate_tensor_symb(t: sp.Array, r: sp.Array) -> sp.Array:
+    """
+    Rotate a 3-dimensional symbolic Cartesian tensor by a rotation matrix.
+
+    Args:
+        t: The tensor to rotate
+        r:
+            The rotation matrix, or a precomputed tensor product of rotation matrices
+            with the correct rank
+    """
+    order = len(t.shape)
+    if r.shape == (3, 3):
+        r_tenprod = [sp.Array(r)] * order
+    elif r.shape == tuple([3] * 2 * order):
+        r_tenprod = [sp.Array(r)]
+    else:
+        raise RuntimeError(
+            "r must be a 3x3 rotation matrix or a tensor product of n 3x3 rotation "
+            f"matrices, where n is the rank of t. Instead got shape f{r.shape}"
+        )
+    args = r_tenprod + [t]
+    fullproduct = ArrayTensorProduct(*args)
+    for i in range(order):
+        current_order = len(fullproduct.shape)
+        # Count back from end: one component of tensor,
+        # plus two components for each rotation matrix.
+        # Then, step forward by 2*i + 1 to land on the second
+        # component of the correct rotation matrix.
+        # but, step forward by i more, because we've knocked out
+        # that many components of the tensor already
+        # (the knocked out components of the rotation matrices
+        # are lower than the current component we are summing)
+        rotation_component = current_order - order * 3 + 3 * i + 1
+        tensor_component = current_order - order + i  # Count back from end
+        fullproduct = ArrayContraction(
+            fullproduct, (rotation_component, tensor_component)
+        )
+    return fullproduct.as_explicit()
+
+
+def fit_voigt_tensor_to_cell_and_space_group_symb(
+    symb_voigt_inp: sp.Array,
+    cell: npt.ArrayLike,
+    sgnum: Union[int, str],
+):
+    """
+    Given a Cartesian symbolic 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:
+        symb_voigt_inp:
+            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,
+        additionally the symmetrized error if `voigt_error`
+        is provided
+    """
+    t = voigt_to_full_symb(symb_voigt_inp)
+    order = len(t.shape)
+
+    # Precompute the average Q (x) Q (x) Q (x) Q for each
+    # Q in G, where (x) is tensor product. Better
+    # to do this with numpy, sympy is SLOW
+    r_tensprod_ave = np.zeros([3] * 2 * order, dtype=float)
+    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)
+        r_tensprod = 1
+        for _ in range(order):
+            # tensordot with axes=0 is tensor product
+            r_tensprod = np.tensordot(r_tensprod, cart_rot, axes=0)
+        r_tensprod_ave += r_tensprod
+    r_tensprod_ave /= len(space_group_ops)
+    t_symmetrized = rotate_tensor_symb(t, r_tensprod_ave)
+    return full_to_voigt_symb(t_symmetrized)
+
+
+def fit_voigt_tensor_and_error_to_cell_and_space_group(
+    voigt_input: npt.ArrayLike,
+    voigt_error: npt.ArrayLike,
+    cell: npt.ArrayLike,
+    sgnum: Union[int, str],
+    symmetric: bool = False,
+) -> Tuple[npt.ArrayLike, npt.ArrayLike]:
+    """
+    Given a Cartesian Tensor and its errors in Voigt form, average them 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.
+
+    Only use this function if you need the errors. If you do not,
+    use
+    :func:`fit_voigt_tensor_to_cell_and_space_group`, which is significantly faster.
+
+    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`
+        voigt_error:
+            The error corresponding to voigt_input
+        cell:
+            The cell of the crystal, with each row being a cartesian vector
+            representing a lattice vector
+        sgnum:
+            Space group number
+        symmetric:
+            Whether the provided matrix is symmetric. Currently
+            only supported for 6x6 Voigt matrices
+
+    Returns:
+        Tensor symmetrized w.r.t. operations of the space group,
+        and its symmetrized error
+    """
+    # First, get the symmetrized tensor as a symbolic
+    voigt_shape = voigt_input.shape
+    symb_voigt_inp = sp.symarray("t", voigt_shape)
+    if symmetric:
+        if voigt_shape != (6, 6):
+            raise NotImplementedError(
+                "Symmetric input only supported for 6x6 Voigt matrices"
+            )
+        for i in range(5):
+            for j in range(i + 1, 6):
+                symb_voigt_inp[j, i] = symb_voigt_inp[i, j]
+
+    sym_voigt_out = fit_voigt_tensor_to_cell_and_space_group_symb(
+        symb_voigt_inp=symb_voigt_inp, cell=cell, sgnum=sgnum
+    )
+
+    # OK, got the symbolic voigt output. Set up machinery for
+    # substitution
+    voigt_ranges = [range(n) for n in voigt_shape]
+    # Convert to list so can be reused
+    voigt_ranges_product = list(product(*voigt_ranges))
+
+    # Substitute result. Symmetry not an issue, keys will get overwritten
+    sub_dict = {}
+    for symb, num in zip(symb_voigt_inp.flatten(), voigt_input.flatten()):
+        sub_dict[symb] = num
+
+    sub_dict_err = {}
+    for symb, num in zip(symb_voigt_inp.flatten(), voigt_error.flatten()):
+        sub_dict_err[symb] = num
+
+    voigt_out = np.zeros(voigt_shape, dtype=float)
+    voigt_err_out = np.zeros(voigt_shape, dtype=float)
+    for indices in voigt_ranges_product:
+        compon_expr = sym_voigt_out[indices]
+        voigt_out[indices] = compon_expr.subs(sub_dict)
+        # For the error, consider the current component (indicated by ``indices``)
+        # as a random variable that is a linear combination of all the components
+        # of voigt_inp. The variance of the
+        # current component will be the sum of a_i^2 var_i, where a_i is the
+        # coefficient of the ith component of voigt_inp
+        voigt_out_var_compon = 0
+        for symb in sub_dict_err:
+            inp_compon_coeff = float(compon_expr.coeff(symb))
+            inp_compon_var = sub_dict_err[symb] ** 2
+            voigt_out_var_compon += inp_compon_coeff**2 * inp_compon_var
+        voigt_err_out[indices] = voigt_out_var_compon**0.5
+
+    return voigt_out, voigt_err_out
+
+
 def fit_voigt_tensor_to_cell_and_space_group(
     voigt_input: npt.ArrayLike, cell: npt.ArrayLike, sgnum: Union[int, str]
 ) -> npt.ArrayLike:
@@ -800,6 +1035,10 @@ def fit_voigt_tensor_to_cell_and_space_group(
     except the input in output are Voigt, and the symmetry operations are tabulated
     instead of being detected on the fly from a structure.
 
+    If you need to symmetrize the errors as well, use
+    :func:`fit_voigt_tensor_and_error_to_cell_and_space_group`, which properly
+    handles errors, but is much slower.
+
     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
@@ -832,3 +1071,78 @@ def fit_voigt_tensor_to_cell_and_space_group(
     t_symmetrized = sum(t_rotated_list) / len(t_rotated_list)
 
     return t_symmetrized.voigt
+
+
+class FixProvidedSymmetry(FixSymmetry):
+    """
+    A modification of :obj:`~ase.constraints.FixSymmetry` that takes
+    a prescribed symmetry instead of analyzing the atoms object on the fly
+    """
+
+    def __init__(
+        self,
+        atoms: Atoms,
+        symmetry: Union[str, int, List[Dict]],
+        adjust_positions=True,
+        adjust_cell=True,
+    ):
+        """
+        Args:
+            symmetry:
+                Either the space group number, or a list of operations
+                as dictionaries with keys "W": (fractional rotation matrix),
+                "w": (fractional translation). The space group number input
+                will not work correctly unless this contraint is applied to
+                a primitive unit cell as defined in
+                http://doi.org/10.1016/j.commatsci.2017.01.017
+        """
+        self.atoms = atoms.copy()
+        self.symmetry = symmetry
+
+        if isinstance(symmetry, str) or isinstance(symmetry, int):
+            primitive_genpos_ops = get_primitive_genpos_ops(symmetry)
+        else:
+            try:
+                for op in symmetry:
+                    assert np.asarray(op["W"]).shape == (3, 3)
+                    assert np.asarray(op["w"]).shape == (3,)
+                primitive_genpos_ops = symmetry
+            except Exception:
+                raise RuntimeError("Incorrect input provided to FixProvidedSymmetry")
+
+        self.rotations = []
+        self.translations = []
+        for op in primitive_genpos_ops:
+            self.rotations.append(np.asarray(op["W"]))
+            self.translations.append(np.asarray(op["w"]))
+        self.prep_symm_map()
+
+        self.do_adjust_positions = adjust_positions
+        self.do_adjust_cell = adjust_cell
+
+    def prep_symm_map(self) -> None:
+        """
+        Prepare self.symm_map using provided symmetries
+        """
+        self.symm_map = []
+        scaled_pos = self.atoms.get_scaled_positions()
+        for rot, trans in zip(self.rotations, self.translations):
+            this_op_map = [-1] * len(self.atoms)
+            for i_at in range(len(self.atoms)):
+                new_p = rot @ scaled_pos[i_at, :] + trans
+                dp = scaled_pos - new_p
+                dp -= np.round(dp)
+                i_at_map = np.argmin(np.linalg.norm(dp, axis=1))
+                this_op_map[i_at] = i_at_map
+            self.symm_map.append(this_op_map)
+
+    def todict(self):
+        return {
+            "name": "FixProvidedSymmetry",
+            "kwargs": {
+                "atoms": self.atoms,
+                "symmetry": self.symmetry,
+                "adjust_positions": self.do_adjust_positions,
+                "adjust_cell": self.do_adjust_cell,
+            },
+        }

kim_tools/symmetry_util/data/elast_cubic.svg

@@ -0,0 +1,105 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!-- This file was generated by dvisvgm 2.13.1 -->
+<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' width='350pt' height='350pt' viewBox='66.550958 63.999777 350 350'>
+<g id='page1'>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 10.1795 10.1795L 76.3702 76.3702L 142.561 142.561' fill='none' stroke='#000000' stroke-linecap='round' stroke-linejoin='round' stroke-miterlimit='10.0375' stroke-width='1.50562'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 76.3702 10.1795L 142.561 10.1795L 142.561 76.3702' fill='none' stroke='#000000' stroke-linecap='round' stroke-linejoin='round' stroke-miterlimit='10.0375' stroke-width='1.50562'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 208.752 208.752L 274.942 274.942L 341.133 341.133' fill='none' stroke='#000000' stroke-linecap='round' stroke-linejoin='round' stroke-miterlimit='10.0375' stroke-width='1.50562'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 20.1081 10.1795C 20.1081 4.69612 15.663 0.250938 10.1795 0.250937C 4.69612 0.250937 0.250937 4.69612 0.250937 10.1795C 0.250937 15.663 4.69612 20.1081 10.1795 20.1081C 15.663 20.1081 20.1081 15.663 20.1081 10.1795Z' fill='#000000'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 20.1081 10.1795C 20.1081 4.69612 15.663 0.250938 10.1795 0.250937C 4.69612 0.250937 0.250937 4.69612 0.250937 10.1795C 0.250937 15.663 4.69612 20.1081 10.1795 20.1081C 15.663 20.1081 20.1081 15.663 20.1081 10.1795Z' fill='none' stroke='#000000' stroke-linecap='round' stroke-linejoin='round' stroke-miterlimit='10.0375' stroke-width='0.501875'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 86.2988 10.1795C 86.2988 4.69612 81.8536 0.250938 76.3702 0.250937C 70.8868 0.250937 66.4416 4.69612 66.4416 10.1795C 66.4416 15.663 70.8868 20.1081 76.3702 20.1081C 81.8536 20.1081 86.2988 15.663 86.2988 10.1795Z' fill='#000000'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 86.2988 10.1795C 86.2988 4.69612 81.8536 0.250938 76.3702 0.250937C 70.8868 0.250937 66.4416 4.69612 66.4416 10.1795C 66.4416 15.663 70.8868 20.1081 76.3702 20.1081C 81.8536 20.1081 86.2988 15.663 86.2988 10.1795Z' fill='none' stroke='#000000' stroke-linecap='round' stroke-linejoin='round' stroke-miterlimit='10.0375' stroke-width='0.501875'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 152.49 10.1795C 152.49 4.69612 148.044 0.250938 142.561 0.250937C 137.077 0.250937 132.632 4.69612 132.632 10.1795C 132.632 15.663 137.077 20.1081 142.561 20.1081C 148.044 20.1081 152.49 15.663 152.49 10.1795Z' fill='#000000'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 152.49 10.1795C 152.49 4.69612 148.044 0.250938 142.561 0.250937C 137.077 0.250937 132.632 4.69612 132.632 10.1795C 132.632 15.663 137.077 20.1081 142.561 20.1081C 148.044 20.1081 152.49 15.663 152.49 10.1795Z' fill='none' stroke='#000000' stroke-linecap='round' stroke-linejoin='round' stroke-miterlimit='10.0375' stroke-width='0.501875'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<circle cx='208.752' cy='10.1795' fill='#000000' r='2.50937'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<circle cx='274.942' cy='10.1795' fill='#000000' r='2.50937'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<circle cx='341.133' cy='10.1795' fill='#000000' r='2.50937'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 86.2988 76.3702C 86.2988 70.8868 81.8536 66.4416 76.3702 66.4416C 70.8868 66.4416 66.4416 70.8868 66.4416 76.3702C 66.4416 81.8536 70.8868 86.2988 76.3702 86.2988C 81.8536 86.2988 86.2988 81.8536 86.2988 76.3702Z' fill='#000000'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 86.2988 76.3702C 86.2988 70.8868 81.8536 66.4416 76.3702 66.4416C 70.8868 66.4416 66.4416 70.8868 66.4416 76.3702C 66.4416 81.8536 70.8868 86.2988 76.3702 86.2988C 81.8536 86.2988 86.2988 81.8536 86.2988 76.3702Z' fill='none' stroke='#000000' stroke-linecap='round' stroke-linejoin='round' stroke-miterlimit='10.0375' stroke-width='0.501875'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 152.49 76.3702C 152.49 70.8868 148.044 66.4416 142.561 66.4416C 137.077 66.4416 132.632 70.8868 132.632 76.3702C 132.632 81.8536 137.077 86.2988 142.561 86.2988C 148.044 86.2988 152.49 81.8536 152.49 76.3702Z' fill='#000000'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 152.49 76.3702C 152.49 70.8868 148.044 66.4416 142.561 66.4416C 137.077 66.4416 132.632 70.8868 132.632 76.3702C 132.632 81.8536 137.077 86.2988 142.561 86.2988C 148.044 86.2988 152.49 81.8536 152.49 76.3702Z' fill='none' stroke='#000000' stroke-linecap='round' stroke-linejoin='round' stroke-miterlimit='10.0375' stroke-width='0.501875'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<circle cx='208.752' cy='76.3702' fill='#000000' r='2.50937'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<circle cx='274.942' cy='76.3702' fill='#000000' r='2.50937'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<circle cx='341.133' cy='76.3702' fill='#000000' r='2.50937'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 152.49 142.561C 152.49 137.077 148.044 132.632 142.561 132.632C 137.077 132.632 132.632 137.077 132.632 142.561C 132.632 148.044 137.077 152.49 142.561 152.49C 148.044 152.49 152.49 148.044 152.49 142.561Z' fill='#000000'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 152.49 142.561C 152.49 137.077 148.044 132.632 142.561 132.632C 137.077 132.632 132.632 137.077 132.632 142.561C 132.632 148.044 137.077 152.49 142.561 152.49C 148.044 152.49 152.49 148.044 152.49 142.561Z' fill='none' stroke='#000000' stroke-linecap='round' stroke-linejoin='round' stroke-miterlimit='10.0375' stroke-width='0.501875'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<circle cx='208.752' cy='142.561' fill='#000000' r='2.50937'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<circle cx='274.942' cy='142.561' fill='#000000' r='2.50937'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<circle cx='341.133' cy='142.561' fill='#000000' r='2.50937'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 218.68 208.752C 218.68 203.268 214.235 198.823 208.752 198.823C 203.268 198.823 198.823 203.268 198.823 208.752C 198.823 214.235 203.268 218.68 208.752 218.68C 214.235 218.68 218.68 214.235 218.68 208.752Z' fill='#000000'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 218.68 208.752C 218.68 203.268 214.235 198.823 208.752 198.823C 203.268 198.823 198.823 203.268 198.823 208.752C 198.823 214.235 203.268 218.68 208.752 218.68C 214.235 218.68 218.68 214.235 218.68 208.752Z' fill='none' stroke='#000000' stroke-linecap='round' stroke-linejoin='round' stroke-miterlimit='10.0375' stroke-width='0.501875'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<circle cx='274.942' cy='208.752' fill='#000000' r='2.50937'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<circle cx='341.133' cy='208.752' fill='#000000' r='2.50937'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 284.871 274.942C 284.871 269.459 280.426 265.014 274.942 265.014C 269.459 265.014 265.014 269.459 265.014 274.942C 265.014 280.426 269.459 284.871 274.942 284.871C 280.426 284.871 284.871 280.426 284.871 274.942Z' fill='#000000'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 284.871 274.942C 284.871 269.459 280.426 265.014 274.942 265.014C 269.459 265.014 265.014 269.459 265.014 274.942C 265.014 280.426 269.459 284.871 274.942 284.871C 280.426 284.871 284.871 280.426 284.871 274.942Z' fill='none' stroke='#000000' stroke-linecap='round' stroke-linejoin='round' stroke-miterlimit='10.0375' stroke-width='0.501875'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<circle cx='341.133' cy='274.942' fill='#000000' r='2.50937'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 351.062 341.133C 351.062 335.65 346.616 331.204 341.133 331.204C 335.65 331.204 331.204 335.65 331.204 341.133C 331.204 346.616 335.65 351.062 341.133 351.062C 346.616 351.062 351.062 346.616 351.062 341.133Z' fill='#000000'/>
+</g>
+<g transform='translate(66.551 63.9998)scale(.996264)'>
+<path d='M 351.062 341.133C 351.062 335.65 346.616 331.204 341.133 331.204C 335.65 331.204 331.204 335.65 331.204 341.133C 331.204 346.616 335.65 351.062 341.133 351.062C 346.616 351.062 351.062 346.616 351.062 341.133Z' fill='none' stroke='#000000' stroke-linecap='round' stroke-linejoin='round' stroke-miterlimit='10.0375' stroke-width='0.501875'/>
+</g>
+</g>
+</svg>