Remove need for constraints and specific compositions (#143) (#144)

* initial implementation of constraint input



* improve code



* added CHANGELOG and formatted it



* remove need for fixed composition and exact number of atoms



---------

Signed-off-by: Marcel Mueller <marcel.mueller@thch.uni-bonn.de>

Author: marcelmbn

src/mindlessgen/prog/config.py

@@ -1694,17 +1694,10 @@ def _check_distance_constraint_requirements(self) -> None:
         if not constraints:
             return
 
-        if not self.generate.fixed_composition:
-            raise ValueError(
-                "Distance constraints require 'generate.fixed_composition = true' "
-                + "so individual atoms can be uniquely addressed."
-            )
-
         element_composition = self.generate.element_composition
-        if not element_composition:
-            raise ValueError(
-                "Distance constraints require explicit element composition entries."
-            )
+        # When composition is not fixed, defer feasibility checks until runtime.
+        if not self.generate.fixed_composition or not element_composition:
+            return
 
         for constraint in constraints:
             counts = constraint.required_counts()
@@ -1726,8 +1719,8 @@ def _check_distance_constraint_requirements(self) -> None:
                     )
 
                 actual = min_count
-                if actual != expected:
+                if actual < expected:
                     raise ValueError(
-                        f"Distance constraint {constraint} requires exactly "
+                        f"Distance constraint {constraint} requires at least "
                         + f"{expected} {element_symbol} atom(s) but the composition fixes {actual}."
                     )

src/mindlessgen/qm/xtb.py

@@ -82,11 +82,12 @@ def optimize(
                 arguments += ["--uhf", str(molecule.uhf)]
             if max_cycles is not None:
                 arguments += ["--cycles", str(max_cycles)]
-            print(self.cfg.distance_constraints)
             if self.cfg.distance_constraints:
-                print("Preparing distance constraint file...")
+                if verbosity > 1:
+                    print("Preparing distance constraint file...")
                 if self._prepare_distance_constraint_file(molecule, temp_path):
-                    print("Distance constraint file prepared.")
+                    if verbosity > 1:
+                        print("Distance constraint file prepared.")
                     arguments += ["--input", "xtb.inp"]
 
             if verbosity > 2:
@@ -232,6 +233,7 @@ def _prepare_distance_constraint_file(
 
         constraint_lines: list[str] = []
         for constraint in self.cfg.distance_constraints:
+            self._ensure_constraint_atoms_present(element_map, constraint)
             pairs = self._generate_constraint_pairs(element_map, constraint)
             if not pairs:
                 raise RuntimeError(
@@ -260,33 +262,46 @@ def _generate_constraint_pairs(
         element_map: dict[int, list[int]], constraint: DistanceConstraint
     ) -> list[tuple[int, int]]:
         """
-        Generate all index pairs for the provided constraint.
+        Generate the index pair for the provided constraint.
         """
         atom_a, atom_b = constraint.atomic_numbers
         atom_a_idx = atom_a - 1
         atom_b_idx = atom_b - 1
         indices_a = element_map.get(atom_a_idx, [])
         indices_b = element_map.get(atom_b_idx, [])
 
-        pairs: set[tuple[int, int]] = set()
         if atom_a == atom_b:
-            for idx, first in enumerate(indices_a):
-                for second in indices_a[idx + 1 :]:
-                    if first < second:
-                        pairs.add((first, second))
-                    else:
-                        pairs.add((second, first))
-        else:
-            for first in indices_a:
-                for second in indices_b:
-                    if first == second:
-                        continue
-                    if first < second:
-                        pairs.add((first, second))
-                    else:
-                        pairs.add((second, first))
-
-        return sorted(pairs)
+            if len(indices_a) < 2:
+                return []
+            first, second = sorted(indices_a[:2])
+            return [(first, second)]
+
+        if not indices_a or not indices_b:
+            return []
+
+        first, second = indices_a[0], indices_b[0]
+        if first == second:
+            return []
+        if first > second:
+            first, second = second, first
+        return [(first, second)]
+
+    @staticmethod
+    def _ensure_constraint_atoms_present(
+        element_map: dict[int, list[int]], constraint: DistanceConstraint
+    ) -> None:
+        """
+        Validate that the molecule contains enough atoms for the constraint.
+        """
+        for atomic_number, required in constraint.required_counts().items():
+            idx = atomic_number - 1
+            available = len(element_map.get(idx, []))
+            if available < required:
+                symbol = constraint.symbol_for(atomic_number)
+                raise RuntimeError(
+                    f"Distance constraint {constraint} requires at least "
+                    f"{required} atom(s) of {symbol}, but only {available} present."
+                )
 
     def _run(self, temp_path: Path, arguments: list[str]) -> tuple[str, str, int]:
         """

test/test_prog/test_distance_constraints.py

@@ -36,25 +36,25 @@ def test_force_constant_validation():
         cfg.distance_constraint_force_constant = 0
 
 
-def test_check_config_requires_fixed_composition():
+def test_check_config_allows_non_fixed_composition():
     config = ConfigManager()
     config.general.parallel = 1
     config.refine.ncores = 1
     config.xtb.distance_constraints = [DistanceConstraint.from_cli_string("He,He,2.0")]
     config.generate.fixed_composition = False
+    config.generate.element_composition = "He:2-*"
     config.refine.engine = "xtb"
 
-    with pytest.raises(ValueError):
-        config.check_config()
+    config.check_config()
 
 
-def test_check_config_requires_matching_counts():
+def test_check_config_requires_matching_counts_when_fixed():
     config = ConfigManager()
     config.general.parallel = 1
     config.refine.ncores = 1
     config.xtb.distance_constraints = [DistanceConstraint.from_cli_string("He,He,2.0")]
     config.generate.fixed_composition = True
-    config.generate.element_composition = "He:1-3"
+    config.generate.element_composition = "He:1-1"
     config.refine.engine = "xtb"
 
     with pytest.raises(ValueError):

test/test_qm/test_xtb.py

@@ -176,6 +176,25 @@ def test_prepare_distance_constraint_file_missing_atoms(tmp_path):
         xtb._prepare_distance_constraint_file(mol, tmp_path)
 
 
+def test_distance_constraint_applies_only_first_atoms(tmp_path):
+    cfg = XTBConfig()
+    cfg.distance_constraints = [
+        DistanceConstraint.from_mapping({"pair": ["Fe", "Fe"], "distance": 2.5})
+    ]
+    xtb = XTB("/path/to/xtb", cfg)
+    mol = Molecule("Fe3")
+    mol.ati = np.array([25, 25, 25])
+
+    assert xtb._prepare_distance_constraint_file(mol, tmp_path) is True
+
+    contents = (tmp_path / "xtb.inp").read_text(encoding="utf8").splitlines()
+    distance_lines = [line for line in contents if "distance:" in line]
+
+    assert len(distance_lines) == 1
+    assert "1, 2" in distance_lines[0]
+    assert ", 3," not in distance_lines[0]
+
+
 @pytest.mark.optional
 def test_xtb_distance_constraint_enforced(tmp_path):
     """