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

kim_tools/symmetry_util/core.py

@@ -9,19 +9,18 @@ from itertools import product
 from math import ceil
 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 ase.neighborlist import natural_cutoffs, neighbor_list
 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
+from sympy.tensor.array.expressions import ArrayContraction, ArrayTensorProduct
 
 logger = logging.getLogger(__name__)
 logging.basicConfig(filename="kim-tools.log", level=logging.INFO, force=True)
@@ -48,6 +47,7 @@ __all__ = [
     "change_of_basis_atoms",
     "get_possible_primitive_shifts",
     "get_primitive_genpos_ops",
+    "get_smallest_nn_dist",
 ]
 
 C_CENTERED_ORTHORHOMBIC_GROUPS = (20, 21, 35, 36, 37, 63, 64, 65, 66, 67, 68)
@@ -514,7 +514,9 @@ def get_change_of_basis_matrix_to_conventional_cell_from_formal_bravais_lattice(
     return np.round(change_of_basis_matrix)
 
 
-def change_of_basis_atoms(atoms: Atoms, change_of_basis: npt.ArrayLike) -> Atoms:
+def change_of_basis_atoms(
+    atoms: Atoms, change_of_basis: npt.ArrayLike, cutoff: Optional[float] = None
+) -> Atoms:
     """
     Perform an arbitrary basis change on an ``Atoms`` object, duplicating or cropping
     atoms as needed. A basic check is made that the determinant of ``change_of_basis``
@@ -522,7 +524,7 @@ def change_of_basis_atoms(atoms: Atoms, change_of_basis: npt.ArrayLike) -> Atoms
     that ``change_of_basis`` is appropriate for the particuar crystal described by
     ``atoms``, which is up to the user.
 
-    TODO: Incorporate :func:`kstest_reduced_distances` into this function
+    TODO: Incorporate period extension test into this function
 
     Args:
         atoms:
@@ -541,6 +543,9 @@ def change_of_basis_atoms(atoms: Atoms, change_of_basis: npt.ArrayLike) -> Atoms
 
             Relationship between fractional coordinates in each basis:
             **x** = **P** **x**'
+        cutoff:
+            The cutoff to use for deleting duplicate atoms. If not specified,
+            the AFLOW tolerance of 0.01*(smallest NN distance) is used.
 
     Returns:
         The transformed ``Atoms`` object, containing the original number of
@@ -575,7 +580,9 @@ def change_of_basis_atoms(atoms: Atoms, change_of_basis: npt.ArrayLike) -> Atoms
     new_atoms = atoms.repeat(repeat)
     new_atoms.set_cell(new_cell)
     new_atoms.wrap()
-    get_duplicate_atoms(new_atoms, delete=True)
+    if cutoff is None:
+        cutoff = get_smallest_nn_dist(atoms) * 0.01
+    get_duplicate_atoms(new_atoms, cutoff=cutoff, delete=True)
 
     volume_change = np.linalg.det(change_of_basis)
     if not np.isclose(len(atoms) * volume_change, len(new_atoms)):
@@ -632,14 +639,16 @@ def transform_atoms(atoms: Atoms, op: Dict) -> Atoms:
     return atoms_transformed
 
 
-def reduce_and_avg(
-    atoms: Atoms, repeat: Tuple[int, int, int]
-) -> Tuple[Atoms, npt.ArrayLike]:
+def reduce_and_avg(atoms: Atoms, repeat: Tuple[int, int, int]) -> Atoms:
     """
     TODO: Upgrade :func:`change_of_basis_atoms` to provide the distances
     array, obviating this function
 
-    Function to reduce all atoms to the original unit cell position.
+    Function to reduce all atoms to the original unit cell position,
+    assuming the supercell is built from contiguous repeats of the unit cell
+    (i.e. atoms 0 to N-1 in the supercell are the original unit cell, atoms N to
+    2*[N-1] are the original unit cell shifted by an integer multiple of
+    the lattice vectors, and so on)
 
     Args:
         atoms:
@@ -649,10 +658,13 @@ def reduce_and_avg(
             provided supercell
 
     Returns:
-        * The reduced unit cell
-        * An array of displacement vectors. First dimension: index of reference atom
-          in reduced cell. Second dimension: index of atom in provided supercell.
-          Third dimension: x, y, z
+        The reduced unit cell
+
+    Raises:
+        PeriodExtensionException:
+            If two atoms that should be identical by translational symmetry
+            are further than 0.01*(smallest NN distance) apart when
+            reduced to the unit cell
     """
     new_atoms = atoms.copy()
 
@@ -683,126 +695,267 @@ def reduce_and_avg(
     # Start from end of the atoms
     # because we will remove all atoms except the reference ones.
     for i in reversed(range(number_atoms)):
+        reference_atom_index = i % original_number_atoms
         if i >= original_number_atoms:
             # Get the distance to the reference atom in the original unit cell with the
             # minimum image convention.
             distance = new_atoms.get_distance(
-                i % original_number_atoms, i, mic=True, vector=True
+                reference_atom_index, i, mic=True, vector=True
             )
             # Get the position that has the closest distance to
             # the reference atom in the original unit cell.
-            position_i = positions[i % original_number_atoms] + distance
+            position_i = positions[reference_atom_index] + distance
             # Remove atom from atoms object.
             new_atoms.pop()
         else:
             # Atom was part of the original unit cell.
             position_i = positions[i]
         # Average
-        avg_positions_in_prim_cell[i % original_number_atoms] += position_i / M
+        avg_positions_in_prim_cell[reference_atom_index] += position_i / M
         positions_in_prim_cell[i] = position_i
 
     new_atoms.set_positions(avg_positions_in_prim_cell)
 
-    # Calculate the distances.
-    distances = np.empty((original_number_atoms, M, 3))
-    for i in range(number_atoms):
-        dr, _ = get_distances(
-            positions_in_prim_cell[i],
-            avg_positions_in_prim_cell[i % original_number_atoms],
+    # Check that all atoms are within tolerance of their translational images
+    cutoff = get_smallest_nn_dist(new_atoms) * 0.01
+    logger.info(f"Cutoff for period extension test is {cutoff}")
+    for i in range(original_number_atoms):
+        positions_of_all_images_of_atom_i = [
+            positions_in_prim_cell[j * original_number_atoms + i] for j in range(M)
+        ]
+        _, r = get_distances(
+            positions_of_all_images_of_atom_i,
             cell=new_atoms.get_cell(),
             pbc=True,
         )
-        # dr is a distance matrix, here we only have one distance
-        assert dr.shape == (1, 1, 3)
-        distances[i % original_number_atoms, i // original_number_atoms] = dr[0][0]
+        # Checking full MxM matrix, could probably speed up by
+        # checking upper triangle only. Could also save memory
+        # by looping over individual distances instead of
+        # checking the max of a giant matrix
+        assert r.shape == (M, M)
+        if r.max() > cutoff:
+            raise PeriodExtensionException(
+                f"At least one image of atom {i} is outside of tolerance"
+            )
+    return new_atoms
 
-    return new_atoms, 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 kstest_reduced_distances(
-    reduced_distances: npt.ArrayLike,
-    significance_level: float = 0.05,
-    plot_filename: Optional[str] = None,
-    number_bins: Optional[int] = None,
-) -> None:
+def full_to_voigt_symb(full: sp.Array) -> sp.MutableDenseNDimArray:
     """
-    TODO: Incorporate this into :func:`change_of_basis_atoms`
+    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
 
-    Function to test whether the reduced atom positions are normally distributed
-    around their average.
+
+def rotate_tensor_symb(t: sp.Array, r: sp.Array) -> sp.Array:
+    """
+    Rotate a 3-dimensional symbolic Cartesian tensor by a rotation matrix.
 
     Args:
-        reduced_distances:
-            Distance array provided by :func:`reduce_and_avg`
-        significance_level:
-            Significance level for Kolmogorov-Smirnov
-        plot_filename:
-        number_bins:
-            Number of bins for plot
+        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()
 
-    Raises:
-        PeriodExtensionException:
-            If a non-normal distribution is detected
+
+def fit_voigt_tensor_to_cell_and_space_group_symb(
+    symb_voigt_inp: sp.Array,
+    cell: npt.ArrayLike,
+    sgnum: Union[int, str],
+):
     """
-    assert len(reduced_distances.shape) == 3
-    assert reduced_distances.shape[2] == 3
+    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.
 
-    if plot_filename is not None:
-        if number_bins is None:
-            raise ValueError(
-                "number_bins must be specified if plot_filename is specified"
-            )
-        if not plot_filename.endswith(".pdf"):
-            raise ValueError(f"{plot_filename} is not a PDF file")
-        with PdfPages(plot_filename) as pdf:
-            for i in range(reduced_distances.shape[0]):
-                fig, axs = plt.subplots(1, 3, figsize=(10.0, 4.0))
-                for j in range(reduced_distances.shape[2]):
-                    axs[j].hist(reduced_distances[i, :, j], bins=number_bins)
-                    axs[j].set_xlabel(f"$x_{j}$")
-                axs[0].set_ylabel("Counts")
-                fig.suptitle(f"Atom {i}")
-                pdf.savefig()
-    else:
-        if number_bins is not None:
-            raise ValueError(
-                "number_bins must not be specified if plot_filename is not specified"
-            )
+    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
 
-    p_values = np.empty((reduced_distances.shape[0], reduced_distances.shape[2]))
-    for i in range(reduced_distances.shape[0]):
-        atom_distances = reduced_distances[i]
+    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
 
-        # Perform PCA on the xyz distribution.
-        pca = PCA(n_components=atom_distances.shape[1])
-        pca_components = pca.fit_transform(atom_distances)
-        assert (
-            pca_components.shape == atom_distances.shape == reduced_distances.shape[1:]
-        )
+    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)
 
-        # Test each component with a KS test.
-        for j in range(pca_components.shape[1]):
-            component = pca_components[:, j]
-            component_mean = np.mean(component)
-            assert abs(component_mean) < 1.0e-7
-            component_std = np.std(component)
-            # Normalize component
-            normalized_component = (component - component_mean) / component_std
-            assert abs(np.mean(normalized_component)) < 1.0e-7
-            assert abs(np.std(normalized_component) - 1.0) < 1.0e-7
-            res = kstest(normalized_component, "norm")
-            p_values[i, j] = res.pvalue
-
-    if np.any(p_values <= significance_level):
-        raise PeriodExtensionException(
-            "Detected non-normal distribution of reduced atom positions around their "
-            f"average (smallest p value {np.min(p_values)})."
-        )
-    else:
-        print(
-            "Detected normal distribution or reduced atom positions around their "
-            f"average (smallest p value {np.min(p_values)})."
-        )
+    # 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(
@@ -815,6 +968,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
@@ -849,6 +1006,23 @@ def fit_voigt_tensor_to_cell_and_space_group(
     return t_symmetrized.voigt
 
 
+def get_smallest_nn_dist(atoms: Atoms) -> float:
+    """
+    Get the smallest NN distance in an Atoms object
+    """
+    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
+    return nl.min()
+
+
 class FixProvidedSymmetry(FixSymmetry):
     """
     A modification of :obj:`~ase.constraints.FixSymmetry` that takes

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>