check for unique positions within probe

Author: h-mayorquin

src/probeinterface/probe.py

@@ -279,6 +279,27 @@ def set_contacts(
         if positions.shape[1] != self.ndim:
             raise ValueError(f"positions.shape[1]: {positions.shape[1]} and ndim: {self.ndim} do not match!")
 
+        # Check for duplicate positions
+        unique_positions = np.unique(positions, axis=0)
+        if len(unique_positions) != len(positions):
+            # Find and report duplicates
+            duplicates = {}
+            for index, pos in enumerate(positions):
+                pos_key = tuple(pos)
+                if pos_key in duplicates:
+                    duplicates[pos_key].append(index)
+                else:
+                    duplicates[pos_key] = [index]
+            
+            duplicate_groups = {pos: indices for pos, indices in duplicates.items() if len(indices) > 1}
+            duplicate_info = []
+            for pos, indices in duplicate_groups.items():
+                pos_str = f"({', '.join(map(str, pos))})"
+                indices_str = f"[{', '.join(map(str, indices))}]"
+                duplicate_info.append(f"Position {pos_str} appears at indices {indices_str}")
+            
+            raise ValueError(f"Contact positions must be unique within a probe. Found {len(duplicate_groups)} duplicate(s): {'; '.join(duplicate_info)}")
+
         self._contact_positions = positions
         n = positions.shape[0]
 

tests/test_probe.py

@@ -182,6 +182,71 @@ def test_save_to_zarr(tmp_path):
     assert probe == reloaded_probe, "Reloaded Probe object does not match the original"
 
 
+def test_position_uniqueness_validation():
+    """Test that the probe validates position uniqueness correctly."""
+    # Case 1: Unique positions (should pass)
+    unique_positions = np.array([[0, 0], [10, 10], [20, 20], [30, 30]])
+    probe = Probe(ndim=2, si_units="um")
+    probe.set_contacts(positions=unique_positions, shapes="circle", shape_params={"radius": 5})
+    assert probe.get_contact_count() == 4
+
+    # Case 2: Duplicate positions (should fail)
+    duplicate_positions = np.array([[0, 0], [10, 10], [0, 0], [30, 30]])
+    probe_dup = Probe(ndim=2, si_units="um")
+    with pytest.raises(ValueError, match="Contact positions must be unique within a probe"):
+        probe_dup.set_contacts(positions=duplicate_positions, shapes="circle", shape_params={"radius": 5})
+
+    # Case 3: Multiple duplicate positions
+    multiple_dup_positions = np.array([[0, 0], [10, 10], [0, 0], [10, 10]])
+    probe_multi_dup = Probe(ndim=2, si_units="um")
+    with pytest.raises(ValueError, match="Contact positions must be unique within a probe"):
+        probe_multi_dup.set_contacts(positions=multiple_dup_positions, shapes="circle", shape_params={"radius": 5})
+
+    # Case 4: 3D positions uniqueness
+    unique_3d_positions = np.array([[0, 0, 0], [10, 10, 10], [20, 20, 20]])
+    probe_3d = Probe(ndim=3, si_units="um")
+    plane_axes = np.zeros((3, 2, 3))
+    plane_axes[:, 0, 0] = 1  # x-axis
+    plane_axes[:, 1, 1] = 1  # y-axis
+    probe_3d.set_contacts(positions=unique_3d_positions, shapes="circle", shape_params={"radius": 5}, plane_axes=plane_axes)
+    assert probe_3d.get_contact_count() == 3
+
+    # Case 5: 3D duplicate positions (should fail)
+    duplicate_3d_positions = np.array([[0, 0, 0], [10, 10, 10], [0, 0, 0]])
+    probe_3d_dup = Probe(ndim=3, si_units="um")
+    plane_axes_dup = np.zeros((3, 2, 3))
+    plane_axes_dup[:, 0, 0] = 1
+    plane_axes_dup[:, 1, 1] = 1
+    with pytest.raises(ValueError, match="Contact positions must be unique within a probe"):
+        probe_3d_dup.set_contacts(positions=duplicate_3d_positions, shapes="circle", shape_params={"radius": 5}, plane_axes=plane_axes_dup)
+
+    # Case 6: Very close positions that are actually different (should pass)
+    close_positions = np.array([[0.0, 0.0], [0.001, 0.0], [0.0, 0.001], [0.001, 0.001]])
+    probe_close = Probe(ndim=2, si_units="um")
+    probe_close.set_contacts(positions=close_positions, shapes="circle", shape_params={"radius": 5})
+    assert probe_close.get_contact_count() == 4
+
+    # Case 7: Exactly same positions due to floating point precision (should fail)
+    exact_same_positions = np.array([[0.1, 0.1], [0.2, 0.2], [0.1, 0.1]])
+    probe_exact = Probe(ndim=2, si_units="um")
+    with pytest.raises(ValueError, match="Contact positions must be unique within a probe"):
+        probe_exact.set_contacts(positions=exact_same_positions, shapes="circle", shape_params={"radius": 5})
+
+
+def test_position_uniqueness_error_message():
+    """Test that the error message matches the full expected string for three duplicates using pytest's match regex."""
+    import re
+    positions_with_dups = np.array([[0, 0], [10, 10], [0, 0], [20, 20], [0, 0], [10, 10]])
+    probe = Probe(ndim=2, si_units="um")
+    expected_error = (
+        "Contact positions must be unique within a probe. "
+        "Found 2 duplicate(s): Position (0, 0) appears at indices [0, 2, 4]; Position (10, 10) appears at indices [1, 5]"
+    )
+
+    with pytest.raises(ValueError, match=re.escape(expected_error)):
+        probe.set_contacts(positions=positions_with_dups, shapes="circle", shape_params={"radius": 5})
+
+
 if __name__ == "__main__":
     test_probe()
 

tests/test_probegroup.py

@@ -67,6 +67,31 @@ def test_probegroup_3d():
     assert probegroup.ndim == 3
 
 
+def test_probegroup_allows_duplicate_positions_across_probes():
+    """Test that ProbeGroup allows duplicate contact positions if they are in different probes."""
+    from probeinterface import ProbeGroup, Probe
+    import numpy as np
+
+    # Probes have the same internal relative positions 
+    positions = np.array([[0, 0], [10, 10]])
+    probe1 = Probe(ndim=2, si_units="um")
+    probe1.set_contacts(positions=positions, shapes="circle", shape_params={"radius": 5})
+    probe2 = Probe(ndim=2, si_units="um")
+    probe2.set_contacts(positions=positions, shapes="circle", shape_params={"radius": 5})
+
+    group = ProbeGroup()
+    group.add_probe(probe1)
+    group.add_probe(probe2)
+
+    # Should not raise any error
+    all_positions = np.vstack([p.contact_positions for p in group.probes])
+    # There are duplicates across probes, but this is allowed
+    assert (all_positions == [0, 0]).any()
+    assert (all_positions == [10, 10]).any()
+    # The group should have both probes
+    assert len(group.probes) == 2
+
+
 if __name__ == "__main__":
     test_probegroup()
     # ~ test_probegroup_3d()