matid 2.0.0.dev1__tar.gz → 2.0.1__tar.gz

{matid-2.0.0.dev1 → matid-2.0.1}/MANIFEST.in

@@ -1,3 +1,4 @@
 include LICENSE
 include requirements.txt
+recursive-include matid/ext *.h
 recursive-exclude tests *

{matid-2.0.0.dev1/matid.egg-info → matid-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: matid
-Version: 2.0.0.dev1
+Version: 2.0.1
 Summary: MatID is a Python package for identifying and analyzing atomistic systems based on their structure.
 Author: Lauri Himanen
 License:                                  Apache License
@@ -214,10 +214,13 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
@@ -229,14 +232,15 @@ Requires-Dist: networkx>=2.4
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
-Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
 Requires-Dist: pydoc-markdown; extra == "dev"
+Requires-Dist: genbadge[coverage]; extra == "dev"
 
 <img src="https://raw.githubusercontent.com/nomad-coe/matid/main/docs/static/img/logo.png" width="300">
 
 ![Build status](https://github.com/nomad-coe/matid/actions/workflows/test.yml/badge.svg)
-[![Coverage Status](https://coveralls.io/repos/github/nomad-coe/matid/badge.svg?branch=main)](https://coveralls.io/github/nomad-coe/matid?branch=main)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+![Coverage Status](./reports/coverage/coverage-badge.svg)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 
 MatID is a Python package for identifying and analyzing atomistic systems based
 on their structure.

{matid-2.0.0.dev1 → matid-2.0.1}/README.md

@@ -1,8 +1,8 @@
 <img src="https://raw.githubusercontent.com/nomad-coe/matid/main/docs/static/img/logo.png" width="300">
 
 ![Build status](https://github.com/nomad-coe/matid/actions/workflows/test.yml/badge.svg)
-[![Coverage Status](https://coveralls.io/repos/github/nomad-coe/matid/badge.svg?branch=main)](https://coveralls.io/github/nomad-coe/matid?branch=main)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+![Coverage Status](./reports/coverage/coverage-badge.svg)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 
 MatID is a Python package for identifying and analyzing atomistic systems based
 on their structure.

{matid-2.0.0.dev1 → matid-2.0.1}/matid/classification/classifier.py

@@ -127,7 +127,7 @@ class Classifier:
         self.min_coverage = min_coverage
 
         # Check seed position
-        if type(seed_position) == str:
+        if isinstance(seed_position, str):
             if seed_position == "cm":
                 pass
             else:
@@ -251,7 +251,7 @@ class Classifier:
                     if len(elems) == 0:
                         break
             else:
-                if type(self.seed_position) == int:
+                if isinstance(self.seed_position, int):
                     seed_indices = [self.seed_position]
                 elif isinstance(self.seed_position, (tuple, list, np.ndarray)):
                     seed_indices = self.seed_position

{matid-2.0.0.dev1 → matid-2.0.1}/matid/clustering/sbc.py

@@ -19,13 +19,166 @@ class SBC:
     will be returned as isolated clusters.
     """
 
-    def __init__(self, seed=7):
+    def get_clusters(
+        self,
+        system,
+        angle_tol=20,
+        max_cell_size=6,
+        pos_tol=0.7,
+        merge_threshold=0.5,
+        merge_radius=1,
+        bond_threshold=0.65,
+        overlap_threshold=-0.1,
+        radii="covalent",
+        seed=7,
+    ):
         """
+        Used to detect and return structurally separate clusters within the
+        given system.
+
         Args:
+            system (ase.Atoms): The structure to partition.
+            angle_tol (float): angle_tol parameter for PeriodicFinder
+            max_cell_size (float): max_cell_size parameter for PeriodicFinder.get_region
+            pos_tol (float): pos_tol parameter for PeriodicFinder.get_region
+            merge_threshold (float): A threshold for merging two clusters
+                together. Give as a fraction of shared atoms. Value of 1 would
+                mean that clusters are never merged, value of 0 means that they
+                are merged always when at least one atom is shared.
+            merge_radius (float): Radius for finding nearby atoms when deciding
+                which cluster is closest. The atomic radii are subtracted from
+                distances. Given in angstroms.
+            bond_threshold(float): Used to control the connectivity threshold
+                for defining a chemical connection between atoms. Controls e.g.
+                what types of unit cells are accepted and how outliers are
+                removed from clusters.
+            overlap_threshold(float): Used to exclude non-physical cells by
+                checking overlap of atoms. Overlap between two atoms is
+                calculated by subtracting atomic radii from the distance between
+                the atoms.
+            radii(str|np.ndarray): The radii to use for atoms. Use either a preset
+                or a custom list of atomic radii for each atom. The available presets are:
+
+                    - covalent: Covalent radii from DOI:10.1039/B801115J
+                    - vdw: van Der Waals radii from DOI:10.1039/C3DT50599E
+                    - vdw_covalent: preferably van Der Waals radii, covalent if vdw
+                    not defined.
             seed(int): The seed that is used for random number generation.
+
+        Returns:
+            A list of Clusters.
         """
+        # Create a random number gen with custom seed
         self.rng = np.random.default_rng(seed)
 
+        # Copy the system to avoid mutating the original
+        system_copy = system.copy()
+
+        # Here we ensure that the system has three valid basis vectors which
+        # when forming a unit cell contain all of the atoms in the system. This
+        # is to ensure that the code that requires scaled positions works
+        # correctly.
+        pbc = system_copy.get_pbc()
+        basis = system_copy.get_cell()
+        requires_completion = False
+        for i in range(3):
+            if not basis[i, :].any():
+                if not pbc[i]:
+                    requires_completion = True
+                else:
+                    raise ValueError(
+                        "Cannot process system with zero-volume cell and periodic boundaries."
+                    )
+        if requires_completion:
+            system_copy.set_cell(ase.geometry.complete_cell(basis))
+        if not all(pbc):
+            scaled_positions = system_copy.get_scaled_positions()
+            new_cell = system_copy.get_cell()
+            scale_cell = False
+            for i in range(3):
+                if not pbc[i]:
+                    i_pos = scaled_positions[:, i]
+                    max_pos = i_pos.max()
+                    min_pos = i_pos.min()
+                    if max_pos > 1 or min_pos < 0:
+                        scale_cell = True
+                        new_cell[i, :] *= (max_pos - min_pos) + 1
+            if scale_cell:
+                system_copy.set_cell(new_cell)
+                system_copy.center()
+
+        # Positions are wrapped
+        system_copy.wrap()
+
+        atomic_numbers = system.get_atomic_numbers()
+        radii = matid.geometry.get_radii(radii, atomic_numbers)
+
+        # Calculate the distances here once if they have not been provided.
+        distances = matid.geometry.get_distances(system_copy, radii)
+
+        # Iteratively search for new clusters until whole system is covered
+        periodic_finder = PeriodicFinder(
+            angle_tol=angle_tol, chem_similarity_threshold=0
+        )
+        indices = set(list(range(len(system_copy))))
+        clusters = []
+        while len(indices) != 0:
+            i_seed = self.rng.choice(list(indices), 1)[0]
+            i_grain, mask = periodic_finder.get_region(
+                system_copy,
+                seed_index=i_seed,
+                max_cell_size=max_cell_size,
+                pos_tol=pos_tol,
+                bond_threshold=bond_threshold,
+                overlap_threshold=overlap_threshold,
+                distances=distances,
+                return_mask=True,
+            )
+
+            # All neighbours that the periodic finder has tested are removed
+            # from the search. This significantly helps with the scaling of the
+            # clustering.
+            tested_indices = set(np.arange(len(mask))[mask])
+            indices -= tested_indices
+
+            # If a grain is found, it is added as a single cluster and removed
+            # from the search
+            if i_grain is not None:
+                i_indices = {i_seed}
+                i_indices.update(i_grain.get_basis_indices())
+                i_species = set(atomic_numbers[list(i_indices)])
+                clusters.append(
+                    Cluster(
+                        i_indices,
+                        i_species,
+                        i_grain,
+                        system=system_copy,
+                        distances=distances,
+                        radii=radii,
+                        bond_threshold=bond_threshold,
+                    )
+                )
+                indices -= i_indices
+
+        # Check overlaps of the regions. For large overlaps the grains are
+        # merged (the real region was probably cut into pieces by unfortunate
+        # selection of the seed atom)
+        clusters = self._merge_clusters(
+            system_copy, clusters, merge_threshold, distances, bond_threshold
+        )
+
+        # Any remaining overlaps are resolved by assigning atoms to the
+        # "nearest" cluster
+        clusters = self._localize_clusters(
+            system_copy, clusters, merge_radius, distances
+        )
+
+        # Any atoms that are not chemically connected to the region will be
+        # excluded.
+        clusters = self._clean_clusters(clusters, bond_threshold)
+
+        return clusters
+
     def _merge_clusters(
         self, system, clusters, merge_threshold, distances, bond_threshold
     ):
@@ -181,158 +334,3 @@ class SBC:
             largest_indices = max(dbscan_clusters, key=lambda x: len(x))
             cluster.indices = np.array(cluster.indices)[largest_indices].tolist()
         return clusters
-
-    def get_clusters(
-        self,
-        system,
-        angle_tol=20,
-        max_cell_size=6,
-        pos_tol=0.7,
-        merge_threshold=0.5,
-        merge_radius=1,
-        bond_threshold=0.65,
-        overlap_threshold=-0.1,
-        radii="covalent",
-    ):
-        """
-        Used to detect and return structurally separate clusters within the
-        given system.
-
-        Args:
-            system (ase.Atoms): The structure to partition.
-            angle_tol (float): angle_tol parameter for PeriodicFinder
-            max_cell_size (float): max_cell_size parameter for PeriodicFinder.get_region
-            pos_tol (float): pos_tol parameter for PeriodicFinder.get_region
-            merge_threshold (float): A threshold for merging two clusters
-                together. Give as a fraction of shared atoms. Value of 1 would
-                mean that clusters are never merged, value of 0 means that they
-                are merged always when at least one atom is shared.
-            merge_radius (float): Radius for finding nearby atoms when deciding
-                which cluster is closest. The atomic radii are subtracted from
-                distances. Given in angstroms.
-            bond_threshold(float): Used to control the connectivity threshold
-                for defining a chemical connection between atoms. Controls e.g.
-                what types of unit cells are accepted and how outliers are
-                removed from clusters.
-            overlap_threshold(float): Used to exclude non-physical cells by
-                checking overlap of atoms. Overlap between two atoms is
-                calculated by subtracting atomic radii from the distance between
-                the atoms.
-            radii(str|np.ndarray): The radii to use for atoms. Use either a preset
-                or a custom list of atomic radii for each atom. The available presets are:
-
-                    - covalent: Covalent radii from DOI:10.1039/B801115J
-                    - vdw: van Der Waals radii from DOI:10.1039/C3DT50599E
-                    - vdw_covalent: preferably van Der Waals radii, covalent if vdw
-                    not defined.
-
-        Returns:
-            A list of Clusters.
-        """
-        # Copy the system to avoid mutating the original
-        system_copy = system.copy()
-
-        # Here we ensure that the system has three valid basis vectors which
-        # when forming a unit cell contain all of the atoms in the system. This
-        # is to ensure that the code that requires scaled positions works
-        # correctly.
-        pbc = system_copy.get_pbc()
-        basis = system_copy.get_cell()
-        requires_completion = False
-        for i in range(3):
-            if not basis[i, :].any():
-                if not pbc[i]:
-                    requires_completion = True
-                else:
-                    raise ValueError(
-                        "Cannot process system with zero-volume cell and periodic boundaries."
-                    )
-        if requires_completion:
-            system_copy.set_cell(ase.geometry.complete_cell(basis))
-        if not all(pbc):
-            scaled_positions = system_copy.get_scaled_positions()
-            new_cell = system_copy.get_cell()
-            scale_cell = False
-            for i in range(3):
-                if not pbc[i]:
-                    i_pos = scaled_positions[:, i]
-                    max_pos = i_pos.max()
-                    min_pos = i_pos.min()
-                    if max_pos > 1 or min_pos < 0:
-                        scale_cell = True
-                        new_cell[i, :] *= (max_pos - min_pos) + 1
-            if scale_cell:
-                system_copy.set_cell(new_cell)
-                system_copy.center()
-
-        # Positions are wrapped
-        system_copy.wrap()
-
-        atomic_numbers = system.get_atomic_numbers()
-        radii = matid.geometry.get_radii(radii, atomic_numbers)
-
-        # Calculate the distances here once if they have not been provided.
-        distances = matid.geometry.get_distances(system_copy, radii)
-
-        # Iteratively search for new clusters until whole system is covered
-        periodic_finder = PeriodicFinder(
-            angle_tol=angle_tol, chem_similarity_threshold=0
-        )
-        indices = set(list(range(len(system_copy))))
-        clusters = []
-        while len(indices) != 0:
-            i_seed = self.rng.choice(list(indices), 1)[0]
-            i_grain, mask = periodic_finder.get_region(
-                system_copy,
-                seed_index=i_seed,
-                max_cell_size=max_cell_size,
-                pos_tol=pos_tol,
-                bond_threshold=bond_threshold,
-                overlap_threshold=overlap_threshold,
-                distances=distances,
-                return_mask=True,
-            )
-
-            # All neighbours that the periodic finder has tested are removed
-            # from the search. This significantly helps with the scaling of the
-            # clustering.
-            tested_indices = set(np.arange(len(mask))[mask])
-            indices -= tested_indices
-
-            # If a grain is found, it is added as a single cluster and removed
-            # from the search
-            if i_grain is not None:
-                i_indices = {i_seed}
-                i_indices.update(i_grain.get_basis_indices())
-                i_species = set(atomic_numbers[list(i_indices)])
-                clusters.append(
-                    Cluster(
-                        i_indices,
-                        i_species,
-                        i_grain,
-                        system=system_copy,
-                        distances=distances,
-                        radii=radii,
-                        bond_threshold=bond_threshold,
-                    )
-                )
-                indices -= i_indices
-
-        # Check overlaps of the regions. For large overlaps the grains are
-        # merged (the real region was probably cut into pieces by unfortunate
-        # selection of the seed atom)
-        clusters = self._merge_clusters(
-            system_copy, clusters, merge_threshold, distances, bond_threshold
-        )
-
-        # Any remaining overlaps are resolved by assigning atoms to the
-        # "nearest" cluster
-        clusters = self._localize_clusters(
-            system_copy, clusters, merge_radius, distances
-        )
-
-        # Any atoms that are not chemically connected to the region will be
-        # excluded.
-        clusters = self._clean_clusters(clusters, bond_threshold)
-
-        return clusters

{matid-2.0.0.dev1 → matid-2.0.1}/matid/core/linkedunits.py

@@ -69,7 +69,7 @@ class LinkedUnitCollection(dict):
         # Transform key to tuple, check length
         try:
             key = tuple(key)
-        except:
+        except Exception:
             raise TypeError(
                 "Could not transform the given key '{}' into tuple.".format(key)
             )
@@ -311,7 +311,6 @@ class LinkedUnitCollection(dict):
         if self._adsorbates is None:
             _, outside_indices = self.get_inside_and_outside_indices()
             basis_elements = set(self.cell.get_atomic_numbers())
-            outside_indices = outside_indices
 
             # The substitutions have to be removed explicitly from the ouside
             # atoms because sometimes they are outside the tesselation.

{matid-2.0.0.dev1 → matid-2.0.1}/matid/core/periodicfinder.py

@@ -219,6 +219,14 @@ class PeriodicFinder:
         generate a periodic region in the structure.
 
         Args:
+            system(ase.Atoms):
+            seed_index(int):
+            possible_spans(np.ndarray):
+            neighbour_mask(np.ndarray):
+            neighbour_factors(np.ndarray):
+            bond_threshold(float):
+            overlap_threshold(float):
+            pos_tol(float):
 
         Returns:
             ase.Atoms: A system representing the best cell that was found
@@ -288,9 +296,9 @@ class PeriodicFinder:
             adjacency_lists_add.append(i_adj_list_add)
             adjacency_lists_sub.append(i_adj_list_sub)
 
-        # Get the spans that come from the original cell basis if they are
-        # smaller than the maximum cell size.
-        periodic_spans = system.get_cell()
+        # The lattice vectors are added as possible spans if they are set as
+        # periodic and they are shorter than the maximum cell size
+        periodic_spans = system.get_cell()[system.get_pbc()]
         periodic_span_lengths = np.linalg.norm(periodic_spans, axis=1)
         periodic_filter = periodic_span_lengths <= self.max_cell_size
         n_periodic_spans = periodic_filter.sum()
@@ -330,12 +338,19 @@ class PeriodicFinder:
                     adjacency_lists_add.append(per_adjacency_list_add)
                     adjacency_lists_sub.append(per_adjacency_list_sub)
 
-        # Find the directions that repeat the neighbours above some preset
-        # threshold. This is used to eliminate directions that are caused by
-        # pure chance. The maximum score that a direction can get is
-        # 2*n_neighbours. We specify that the score must be above 75% percent
-        # of this maximum score to be considered a valid direction.
-        valid_span_indices = np.where(metric >= 0.75 * n_neighbours)[0]
+        # Filter the spans based on how well they explain the repeated patterns
+        # around the neighbourhood of the seed atom. Spans are accepted if they
+        # produce more than 0.75 % of the possible repetitions in the seed
+        # neighbourhood OR they explain at least 50% of the maximum repetition
+        # that was found. These criteria are important to eliminate directions
+        # that are caused by pure chance, or represent directions where there is
+        # a periodic substructure that can only explain the structure partially.
+        # OLD: valid_span_indices = np.where(metric >= 0.75 * n_neighbours)[0]
+        valid_span_indices = np.where(
+            (metric >= 0.4 * (0 if len(metric) == 0 else metric.max()))
+            | (metric >= 0.75 * n_neighbours)
+        )[0]
+
         if len(valid_span_indices) == 0:
             return None, None, None
 
@@ -369,9 +384,7 @@ class PeriodicFinder:
         seed_nodes, seed_group_index, group_data_pbc = self._find_graphs(
             seed_index,
             numbers,
-            dim,
             best_adjacency_lists,
-            neighbour_nodes,
             neighbour_indices,
             neighbour_factors,
         )
@@ -525,9 +538,7 @@ class PeriodicFinder:
         self,
         seed_index,
         numbers,
-        dim,
         best_adjacency_lists,
-        neighbour_nodes,
         neighbour_indices,
         neighbour_factors,
     ):
@@ -836,7 +847,7 @@ class PeriodicFinder:
                 min_dist_pos = scaled_pos[min_dist_index]
 
                 # All the other copies are moved periodically to be near the
-                # position that is closest to origin.
+                # position that is closest to origin
                 distances = scaled_pos - min_dist_pos
                 displacement = np.rint(distances)
                 final_pos = scaled_pos - displacement
@@ -862,6 +873,7 @@ class PeriodicFinder:
             cell=best_spans,
             pbc=[True, True, True],
         )
+
         offset = proto_cell.get_positions()[seed_group_index]
 
         return proto_cell, offset, seed_group_index
@@ -1052,6 +1064,7 @@ class PeriodicFinder:
             symbols=averaged_rel_num,
             pbc=[True, True, False],
         )
+
         offset = proto_cell.get_positions()[seed_group_index]
 
         return proto_cell, offset, seed_group_index
@@ -1275,7 +1288,6 @@ class PeriodicFinder:
 
         searched_cell_indices = set()
         used_indices = set()
-        used_seed_indices = set()
         searched_vacancy_positions = []
         queue = deque()
         collection = LinkedUnitCollection(
@@ -1294,8 +1306,6 @@ class PeriodicFinder:
         self._find_region_rec(
             system,
             collection,
-            number_to_index_map,
-            number_to_pos_map,
             seed_index,
             seed_pos,
             seed_number,
@@ -1305,10 +1315,8 @@ class PeriodicFinder:
             (0, 0, 0),
             used_indices,
             searched_vacancy_positions,
-            periodic_indices,
             queue,
             multipliers,
-            used_seed_indices,
         )
 
         # Keep searching while new cells are found
@@ -1327,8 +1335,6 @@ class PeriodicFinder:
                 self._find_region_rec(
                     system,
                     collection,
-                    number_to_index_map,
-                    number_to_pos_map,
                     queue_seed_index,
                     queue_seed_pos,
                     seed_number,
@@ -1338,10 +1344,8 @@ class PeriodicFinder:
                     queue_index,
                     used_indices,
                     searched_vacancy_positions,
-                    periodic_indices,
                     queue,
                     multipliers,
-                    used_seed_indices,
                 )
 
         return collection
@@ -1363,8 +1367,6 @@ class PeriodicFinder:
         self,
         system,
         collection,
-        number_to_index_map,
-        number_to_pos_map,
         seed_index,
         seed_pos,
         seed_atomic_number,
@@ -1374,10 +1376,8 @@ class PeriodicFinder:
         cell_index,
         used_indices,
         searched_vacancy_positions,
-        periodic_indices,
         queue,
         multipliers,
-        used_seed_indices,
     ):
         """
         Args:

{matid-2.0.0.dev1 → matid-2.0.1}/matid/data/element_data.py

@@ -1,6 +1,7 @@
 """Used to store data related to atomic elements. Also has some conversion
 utilities related to the data.
 """
+
 import numpy as np
 from ase.data import covalent_radii
 

matid-2.0.1/matid/ext/celllist.h

@@ -0,0 +1,106 @@
+/*Copyright 2019 DScribe developers
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#ifndef CELLLIST_H
+#define CELLLIST_H
+
+#include <pybind11/numpy.h>
+#include <vector>
+
+namespace py = pybind11;
+using namespace std;
+
+struct CellListResult {
+    vector<int> indices;
+    vector<double> distances;
+    vector<double> distances_squared;
+    vector<vector<double>> displacements;
+    vector<int> indices_original;
+    vector<vector<double>> factors;
+};
+
+/**
+ * For calculating pairwise distances using a cell list.
+ */
+class CellList {
+    public:
+        /**
+         * Constructor
+         *
+         * @param positions Atomic positions in cartesian coordinates.
+         * @param atomicNumbers Atomic numbers.
+         */
+        CellList(py::array_t<double> positions, py::array_t<int> indices, py::array_t<double> factors, double cutoff);
+        /**
+         * Get the indices of atoms within the radial cutoff distance from the
+         * given position.
+         *
+         * @param x Cartesian x-coordinate.
+         * @param y Cartesian y-coordinate.
+         * @param z Cartesian z-coordinate.
+         */
+        CellListResult get_neighbours_for_position(const double x, const double y, const double z);
+        /**
+         * Get the indices of atoms within the radial cutoff distance from the
+         * given atomic index. The given index is not included in the returned
+         * values.
+         *
+         * @param i Index of the atom for which neighbours are queried for.
+         */
+        CellListResult get_neighbours_for_index(const int i);
+        /**
+         * Used to calculate the full displacement tensor in an efficient
+         * manner.
+         */
+        void get_displacement_tensor(
+            py::array_t<double> displacements,
+            py::array_t<double> distances,
+            py::array_t<double> factors,
+            py::array_t<int> original_indices,
+            int n_atoms
+        );
+        py::array_t<int> indices_py;
+
+    private:
+        /**
+         * Used to initialize the cell list. Querying for distances is only
+         * possible after this initialization.
+         */
+        void init();
+
+        // const py::detail::unchecked_reference<double, 2> positions;
+        // const py::detail::unchecked_reference<int, 1> indices;
+        // const py::detail::unchecked_reference<double, 2> factors;
+        vector<vector<double>> positions;
+        vector<int> indices;
+        vector<vector<double>> factors;
+        const double cutoff;
+        const double cutoffSquared;
+        double xmin;
+        double xmax;
+        double ymin;
+        double ymax;
+        double zmin;
+        double zmax;
+        double dx;
+        double dy;
+        double dz;
+        int nx;
+        int ny;
+        int nz;
+        vector<vector<vector<vector<int>>>> bins;
+};
+
+#endif

matid-2.0.1/matid/ext/geometry.h

@@ -0,0 +1,89 @@
+/*Copyright 2019 DScribe developers
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#ifndef GEOMETRY_H
+#define GEOMETRY_H
+
+#include <vector>
+#include <stdexcept>
+#include <pybind11/numpy.h>
+#include "celllist.h"
+
+namespace py = pybind11;
+using namespace std;
+
+struct ExtendedSystem {
+    py::array_t<double> positions;
+    py::array_t<int> atomic_numbers;
+    py::array_t<int> indices;
+    py::array_t<double> factors;
+};
+
+inline vector<double> cross(const vector<double>& a, const vector<double>& b);
+inline double dot(const vector<double>& a, const vector<double>& b);
+inline double norm(const vector<double>& a);
+
+/**
+ * Used to periodically extend an atomic system in order to take into account
+ * periodic copies beyond the given unit cell.
+ *
+ * @param positions Cartesian positions of the original system.
+ * @param atomic_numbers Atomic numbers of the original system.
+ * @param cell Unit cell of the original system.
+ * @param pbc Periodic boundary conditions (array of three booleans) of the original system.
+ * @param cutoff Radial cutoff value for determining extension size.
+ *
+ * @return Instance of ExtendedSystem.
+ */
+ExtendedSystem extend_system(
+    py::array_t<double> positions,
+    py::array_t<int> atomic_numbers,
+    py::array_t<double> cell,
+    py::array_t<bool> pbc,
+    double cutoff
+);
+
+/**
+ * Returns a CellList instance for the given atomic system.
+ *
+ * Note that you should control how large extension should be performed to take
+ * into account the periodic boundary conditions, as the CellList internally
+ * works with plain cartesian coordinates.
+ */
+CellList get_cell_list(
+    py::array_t<double> positions,
+    py::array_t<double> cell,
+    py::array_t<bool> pbc,
+    double extension,
+    double cutoff
+);
+
+/**
+ * Calculates a pairwise displacement tensor (distance vectors) with a given
+ * cutoff.
+ */
+void get_displacement_tensor(
+    py::array_t<double> displacements,
+    py::array_t<double> distances,
+    py::array_t<double> factors,
+    py::array_t<double> positions,
+    py::array_t<double> cell,
+    py::array_t<bool> pbc,
+    double cutoff,
+    bool return_factors,
+    bool return_distances
+);
+
+#endif

{matid-2.0.0.dev1 → matid-2.0.1}/matid/geometry/geometry.py

@@ -1,6 +1,7 @@
 """This module defines functions for deriving geometry related quantities from
 a atomic system.
 """
+
 import math
 import itertools
 from collections import defaultdict
@@ -291,9 +292,9 @@ def get_moments_of_inertia(system, weight=True):
     I13 = np.sum(-weights * x * z)
     I23 = np.sum(-weights * y * z)
 
-    I = np.array([[I11, I12, I13], [I12, I22, I23], [I13, I23, I33]])
+    inertia_tensor = np.array([[I11, I12, I13], [I12, I22, I23], [I13, I23, I33]])
 
-    evals, evecs = np.linalg.eigh(I)
+    evals, evecs = np.linalg.eigh(inertia_tensor)
 
     return evals, evecs
 

{matid-2.0.0.dev1 → matid-2.0.1}/matid/symmetry/symmetryanalyzer.py

@@ -58,7 +58,7 @@ class SymmetryAnalyzer(object):
             self._analyzed_system = system
         elif n_pbc == 2:
             # Get the index of the non-periodic axis
-            i_pbc = np.argwhere(pbc == False)[0]
+            i_pbc = np.argwhere(pbc == False)[0]  # noqa: E712
 
             # Before calculating the conventional system, make sure that there
             # is enough vacuum in the periodic direction to remove any
@@ -355,7 +355,7 @@ class SymmetryAnalyzer(object):
             return ideal_sys
         # 2D materials get a special treatment
         elif n_pbc == 2:
-            i_pbc = np.argwhere(pbc == False)[0]
+            i_pbc = np.argwhere(pbc == False)[0]  # noqa: E712
 
             # Get the full 3D conventional system and it's symmetries. It will
             # include some symmetries that have a translational component
@@ -1357,7 +1357,7 @@ class SymmetryAnalyzer(object):
                         for trans in translations:
                             test_positions[
                                 i_trans * n_expr : (i_trans + 1) * n_expr, :
-                            ] = (first_test_pos + trans)
+                            ] = first_test_pos + trans
                             i_trans += 1
 
                         # Test if each test positions can be matched to an atom

{matid-2.0.0.dev1 → matid-2.0.1}/matid/utils/segfault_protect.py

@@ -1,4 +1,5 @@
 """Utility functions to protect main process against segfaults"""
+
 import signal
 
 

{matid-2.0.0.dev1 → matid-2.0.1}/matid/utils/symmetry_info_generation/generate_symmetry_info.py

@@ -2,6 +2,7 @@
 This script combines multiple pickle files into one python source file
 containing the symmetry information.
 """
+
 import os
 import pickle
 import pprint

{matid-2.0.0.dev1 → matid-2.0.1}/matid/utils/symmetry_info_generation/query_continuous_translations.py

@@ -2,6 +2,7 @@
 For each spacegroup returns the lattice directions in which all the atoms can
 be moved without breaking the symmetry.
 """
+
 import re
 import json
 import urllib.request

{matid-2.0.0.dev1 → matid-2.0.1}/matid/utils/symmetry_info_generation/query_conventional_transform_info.py

@@ -7,6 +7,7 @@ This information is needed because the normalizers and Wyckoff positions in
 Bilbao Crystallographic Server are given in the conventional setttings only by
 default.
 """
+
 import spglib
 from collections import defaultdict
 

{matid-2.0.0.dev1 → matid-2.0.1}/matid/utils/symmetry_info_generation/query_normalizers.py

@@ -8,6 +8,7 @@ Note that there can be connections problems with the server and it is
 recommeneded to do the scraping with some delays and by storing intermediate
 results.
 """
+
 import re
 import pickle
 import numpy as np

{matid-2.0.0.dev1 → matid-2.0.1}/matid/utils/symmetry_info_generation/query_space_group_info.py

@@ -3,6 +3,7 @@ Goes through the spglib database for different Hall numbers and extracts space
 group specific intormation. The results are then written to a python file for
 later use.
 """
+
 import spglib
 import pickle
 

{matid-2.0.0.dev1 → matid-2.0.1}/matid/utils/symmetry_info_generation/query_wyckoff_sets.py

@@ -16,6 +16,7 @@ correponding ITA setting in Bilbao to fetch the Wyckoff positions.
 The mathematical expression for the Wyckoff positions is stored along with the
 necessary matrices for solving the variables from a particular system.
 """
+
 import re
 import parser
 import numpy as np

{matid-2.0.0.dev1 → matid-2.0.1/matid.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: matid
-Version: 2.0.0.dev1
+Version: 2.0.1
 Summary: MatID is a Python package for identifying and analyzing atomistic systems based on their structure.
 Author: Lauri Himanen
 License:                                  Apache License
@@ -214,10 +214,13 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
@@ -229,14 +232,15 @@ Requires-Dist: networkx>=2.4
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
-Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
 Requires-Dist: pydoc-markdown; extra == "dev"
+Requires-Dist: genbadge[coverage]; extra == "dev"
 
 <img src="https://raw.githubusercontent.com/nomad-coe/matid/main/docs/static/img/logo.png" width="300">
 
 ![Build status](https://github.com/nomad-coe/matid/actions/workflows/test.yml/badge.svg)
-[![Coverage Status](https://coveralls.io/repos/github/nomad-coe/matid/badge.svg?branch=main)](https://coveralls.io/github/nomad-coe/matid?branch=main)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+![Coverage Status](./reports/coverage/coverage-badge.svg)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 
 MatID is a Python package for identifying and analyzing atomistic systems based
 on their structure.

{matid-2.0.0.dev1 → matid-2.0.1}/matid.egg-info/SOURCES.txt

@@ -28,8 +28,10 @@ matid/data/constants.py
 matid/data/element_data.py
 matid/data/symmetry_data.py
 matid/ext/celllist.cpp
+matid/ext/celllist.h
 matid/ext/ext.cpp
 matid/ext/geometry.cpp
+matid/ext/geometry.h
 matid/geometry/__init__.py
 matid/geometry/geometry.py
 matid/symmetry/__init__.py

{matid-2.0.0.dev1 → matid-2.0.1}/matid.egg-info/requires.txt

@@ -8,5 +8,6 @@ networkx>=2.4
 [dev]
 coverage
 pytest
-black
+ruff
 pydoc-markdown
+genbadge[coverage]

matid-2.0.1/pyproject.toml

@@ -0,0 +1,93 @@
+[build-system]
+requires = ["setuptools", "wheel", "pybind11~=2.11.1"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = 'matid'
+version = '2.0.1'
+description = 'MatID is a Python package for identifying and analyzing atomistic systems based on their structure.'
+readme = "README.md"
+authors = [{ name = "Lauri Himanen" }]
+license = { file = "LICENSE" }
+requires-python = ">=3.8"
+dependencies = [
+    "numpy",
+    "ase",
+    "scipy",
+    "spglib>=1.15.0",
+    "scikit-learn",
+    "networkx>=2.4",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Topic :: Scientific/Engineering :: Physics",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+keywords = ['atoms', 'structure', 'materials', 'science', 'crystal', 'symmetry']
+
+[project.urls]
+Documentation = 'https://nomad-coe.github.io/matid/'
+Source = "https://github.com/nomad-coe/matid"
+
+[project.optional-dependencies]
+dev = [
+    "coverage",
+    "pytest",
+    "ruff",
+    "pydoc-markdown",
+    "genbadge[coverage]",
+]
+
+[tool.setuptools.packages.find]
+include = ["matid*"]
+exclude = ["tests*"]
+
+[tool.ruff]
+include = ["matid/*.py", "tests/*.py"]
+
+# Same as Black.
+line-length = 88
+indent-width = 4
+
+[tool.ruff.lint]
+select = [
+    "E", # pycodestyle
+    "W", # pycodestyle
+    "PL", # pylint
+]
+ignore = [
+    "E501", # Line too long ({width} > {limit} characters)
+    "E701", # Multiple statements on one line (colon)
+    "E731", # Do not assign a lambda expression, use a def
+    "E402", # Module level import not at top of file
+    "W605", # Invalid escape sequence
+    "PLR0911", # Too many return statements
+    "PLR0912", # Too many branches
+    "PLR0913", # Too many arguments in function definition
+    "PLR0915", # Too many statements
+    "PLR2004", # Magic value used instead of constant
+    "PLW0603", # Using the global statement
+    "PLW2901", # redefined-loop-name
+    "PLR1714", # consider-using-in
+    "PLR5501", # else-if-used
+]
+fixable = ["ALL"]
+
+[tool.ruff.format]
+# indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"

matid-2.0.0.dev1/pyproject.toml

@@ -1,48 +0,0 @@
-[build-system]
-requires = ["setuptools", "wheel", "pybind11~=2.11.1"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = 'matid'
-version = '2.0.0.dev1'
-description = 'MatID is a Python package for identifying and analyzing atomistic systems based on their structure.'
-readme = "README.md"
-authors = [{ name = "Lauri Himanen" }]
-license = { file = "LICENSE" }
-requires-python = ">=3.7"
-dependencies = [
-    "numpy",
-    "ase",
-    "scipy",
-    "spglib>=1.15.0",
-    "scikit-learn",
-    "networkx>=2.4",
-]
-classifiers = [
-    "Development Status :: 5 - Production/Stable",
-    "Intended Audience :: Developers",
-    "Topic :: Scientific/Engineering :: Physics",
-    "License :: OSI Approved :: Apache Software License",
-    "Programming Language :: Python",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.7",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3 :: Only",
-]
-keywords = ['atoms', 'structure', 'materials', 'science', 'crystal', 'symmetry']
-
-[project.urls]
-Documentation = 'https://nomad-coe.github.io/matid/'
-Source = "https://github.com/nomad-coe/matid"
-
-[project.optional-dependencies]
-dev = [
-    "coverage",
-    "pytest",
-    "black",
-    "pydoc-markdown"
-]
-
-[tool.setuptools.packages.find]
-include = ["matid*"]
-exclude = ["tests*"]