matid 2.0.0.dev0__tar.gz → 2.0.0.dev1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: matid
-Version: 2.0.0.dev0
+Version: 2.0.0.dev1
 Summary: MatID is a Python package for identifying and analyzing atomistic systems based on their structure.
 Author: Lauri Himanen
 License:                                  Apache License

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

@@ -1,6 +1,7 @@
 from collections import defaultdict
 
 import numpy as np
+import ase.geometry
 
 import matid.geometry
 from matid.clustering.cluster import Cluster
@@ -231,25 +232,41 @@ class SBC:
         # Copy the system to avoid mutating the original
         system_copy = system.copy()
 
-        # If cell has not been set, or it has zero volume AND periodic boundary
-        # conditions are not used, a dummy cell is created so that the rest of
-        # the code that uses scaled positions works correctly.
-        cell = system_copy.get_cell()
-        if (not cell or cell.volume == 0) and not any(system_copy.get_pbc()):
-            positions = system_copy.get_positions()
-            max_pos = positions.max(axis=0) + 1
-            min_pos = positions.min(axis=0) - 1
-            dummy_cell = max_pos - min_pos
-            system_copy.set_cell(dummy_cell)
-            system_copy.center()
+        # 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
-        else:
-            try:
-                system_copy.wrap()
-            except Exception:
-                raise ValueError(
-                    "Cannot process system with zero-volume cell and periodic boundaries."
-                )
+        system_copy.wrap()
 
         atomic_numbers = system.get_atomic_numbers()
         radii = matid.geometry.get_radii(radii, atomic_numbers)

{matid-2.0.0.dev0 → matid-2.0.0.dev1}/matid/ext/geometry.cpp

@@ -58,45 +58,67 @@ ExtendedSystem extend_system(
     vector<double> a = {cell_u(0, 0), cell_u(0, 1), cell_u(0, 2)};
     vector<double> b = {cell_u(1, 0), cell_u(1, 1), cell_u(1, 2)};
     vector<double> c = {cell_u(2, 0), cell_u(2, 1), cell_u(2, 2)};
+    vector<double> lengths = {norm(a), norm(b), norm(c)};
+    int n_empty = int(lengths[0] == 0) + int(lengths[1] == 0) + int(lengths[2] == 0);
+    vector<int> n_copies_axis(3, 0);
+
+    // If one basis vectors is missing, we need to create a dummy third vector
+    if (n_empty <= 1) {
+        if (lengths[0] == 0 && lengths[1] != 0 && lengths[2] != 0) {
+            a = cross(b, c);
+        } else if (lengths[1] == 0 && lengths[0] != 0 && lengths[2] != 0) {
+            b = cross(a, c);
+        } else if (lengths[2] == 0 && lengths[0] != 0 && lengths[1] != 0) {
+            c = cross(a, b);
+        }
+        vector<double> p1 = cross(b, c);
+        vector<double> p2 = cross(c, a);
+        vector<double> p3 = cross(a, b);
+
+        // Projections of basis vectors onto perpendicular vectors.
+        double p1_coeff = dot(a, p1) / dot(p1, p1);
+        double p2_coeff = dot(b, p2) / dot(p2, p2);
+        double p3_coeff = dot(c, p3) / dot(p3, p3);
+        for(double &x : p1) { x *= p1_coeff; }
+        for(double &x : p2) { x *= p2_coeff; }
+        for(double &x : p3) { x *= p3_coeff; }
+        vector<vector<double>> vectors = {p1, p2, p3};
+
+        // Figure out how many copies to take per basis vector. Determined by how
+        // many perpendicular projections fit into the cutoff distance.
+        for (int i=0; i < 3; ++i) {
+            if (pbc_u(i) && lengths[i]) {
+                double length = norm(vectors[i]);
+                double factor = cutoff/length;
+                int multiplier = (int)ceil(factor);
+                n_copies_axis[i] = multiplier;
+            }
+        }
+    // When two basis vectors are missing, only the remaining non-zero direction
+    // needs to be extended.
+    } else if (n_empty == 2) {
+        for (int i=0; i < 3; ++i) {
+            if (pbc_u(i) && lengths[i]) {
+                double factor = cutoff / lengths[i];
+                int multiplier = (int)ceil(factor);
+                n_copies_axis[i] = multiplier;
+            }
+        }
+    }
 
-    vector<double> p1 = cross(b, c);
-    vector<double> p2 = cross(c, a);
-    vector<double> p3 = cross(a, b);
-
-    // Projections of basis vectors onto perpendicular vectors.
-    double p1_coeff = dot(a, p1) / dot(p1, p1);
-    double p2_coeff = dot(b, p2) / dot(p2, p2);
-    double p3_coeff = dot(c, p3) / dot(p3, p3);
-    for(double &x : p1) { x *= p1_coeff; }
-    for(double &x : p2) { x *= p2_coeff; }
-    for(double &x : p3) { x *= p3_coeff; }
-    vector<vector<double>> vectors = {p1, p2, p3};
-
-    // Figure out how many copies to take per basis vector. Determined by how
-    // many perpendicular projections fit into the cutoff distance.
-    vector<int> n_copies_axis(3);
+    // Store multipliers explicitly into a list in an order that keeps the
+    // original system in the same place both in space and in index.
     vector<vector<int>> multipliers;
     for (int i=0; i < 3; ++i) {
-        if (pbc_u(i)) {
-            double length = norm(vectors[i]);
-            double factor = cutoff/length;
-            int multiplier = (int)ceil(factor);
-            n_copies_axis[i] = multiplier;
-
-            // Store multipliers explicitly into a list in an order that keeps the
-            // original system in the same place both in space and in index.
-            vector<int> multiples;
-            for (int j=0; j < multiplier + 1; ++j) {
-                multiples.push_back(j);
-            }
-            for (int j=-multiplier; j < 0; ++j) {
-                multiples.push_back(j);
-            }
-            multipliers.push_back(multiples);
-        } else {
-            n_copies_axis[i] = 0;
-            multipliers.push_back(vector<int>{0});
+        int multiplier = n_copies_axis[i];
+        vector<int> multiples;
+        for (int j=0; j < multiplier + 1; ++j) {
+            multiples.push_back(j);
+        }
+        for (int j=-multiplier; j < 0; ++j) {
+            multiples.push_back(j);
         }
+        multipliers.push_back(multiples);
     }
 
     // Calculate the extended system positions.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: matid
-Version: 2.0.0.dev0
+Version: 2.0.0.dev1
 Summary: MatID is a Python package for identifying and analyzing atomistic systems based on their structure.
 Author: Lauri Himanen
 License:                                  Apache License

{matid-2.0.0.dev0 → matid-2.0.0.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = 'matid'
-version = '2.0.0.dev0'
+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" }]