dials.index: support arbitrary P1 unit cells

algorithms/indexing/indexer.py

@@ -472,6 +472,7 @@ def _setup_symmetry(self):
             target_space_group = target_space_group.group()
         else:
             target_space_group = sgtbx.space_group()
+            self.params.known_symmetry.space_group = target_space_group.info()
         self._symmetry_handler = SymmetryHandler(
             unit_cell=target_unit_cell,
             space_group=target_space_group,

algorithms/indexing/symmetry.py

@@ -145,20 +145,24 @@ def __init__(self, unit_cell=None, space_group=None, max_delta=5):
                 space_group
             ), "space_group must be provided in combination with unit_cell"
 
-            if target_space_group:
-                self.target_symmetry_inp = crystal.symmetry(
-                    unit_cell=unit_cell, space_group=target_space_group
+            self.target_symmetry_inp = crystal.symmetry(
+                unit_cell=unit_cell, space_group=target_space_group
+            )
+            if str(bravais_lattice(group=target_space_group)) == "aP":
+                self.cb_op_inp_ref = (
+                    self.target_symmetry_inp.change_of_basis_op_to_minimum_cell()
                 )
+            else:
                 self.cb_op_inp_ref = (
                     self.target_symmetry_inp.change_of_basis_op_to_reference_setting()
                 )
-                self.target_symmetry_reference_setting = (
-                    self.target_symmetry_inp.change_basis(self.cb_op_inp_ref)
-                )
-                self.cb_op_inp_best = (
-                    self.target_symmetry_reference_setting.change_of_basis_op_to_best_cell()
-                    * self.cb_op_inp_ref
-                )
+            self.target_symmetry_reference_setting = (
+                self.target_symmetry_inp.change_basis(self.cb_op_inp_ref)
+            )
+            self.cb_op_inp_best = (
+                self.target_symmetry_reference_setting.change_of_basis_op_to_best_cell()
+                * self.cb_op_inp_ref
+            )
 
         elif target_space_group is not None:
             self.target_symmetry_inp = crystal.symmetry(space_group=target_space_group)

newsfragments/1880.bugfix

@@ -0,0 +1 @@
+``dials.import``: Support arbitrary P1 known unit cells

tests/algorithms/indexing/test_index.py

@@ -733,6 +733,43 @@ def test_index_ED_still_low_res_spot_match(dials_data, tmpdir, indexer_type, fix
     )
 
 
+@pytest.mark.parametrize(
+    "cell_params",
+    [
+        (44.47, 52.85, 62.23, 115.14, 101.72, 90.01),
+        (52.85, 62.23, 44.47, 101.72, 90.01, 115.14),
+    ],
+)
+def test_unconventional_P1_cell(dials_data, tmpdir, cell_params):
+    """
+    Indexing in P1 should succeed even if the cell parameters are provided in
+    a non-conventional setting
+    """
+    data_dir = dials_data("mpro_x0305_processed", pathlib=True)
+    experiment = data_dir / "imported.expt"
+    reflections = data_dir / "strong.refl"
+
+    cell_params_str = ",".join([str(x) for x in cell_params])
+    extra_args = [
+        "indexing.method=fft3d",
+        "known_symmetry.space_group=P1",
+        "known_symmetry.unit_cell=" + cell_params_str,
+    ]
+    expected_unit_cell = uctbx.unit_cell(cell_params)
+    expected_rmsds = (1, 1, 1)
+    expected_hall_symbol = " P 1"
+
+    run_indexing(
+        reflections,
+        experiment,
+        tmpdir,
+        extra_args,
+        expected_unit_cell,
+        expected_rmsds,
+        expected_hall_symbol,
+    )
+
+
 def test_real_space_grid_search_no_unit_cell(dials_regression, tmpdir):
     data_dir = os.path.join(dials_regression, "indexing_test_data", "i04_weak_data")
     experiments_json = os.path.join(data_dir, "experiments_import.json")

tests/algorithms/indexing/test_symmetry.py

@@ -67,16 +67,16 @@ def test_SymmetryHandler(space_group_symbol):
     crystal_new.get_crystal_symmetry(assert_is_compatible_unit_cell=True)
 
     handler = symmetry.SymmetryHandler(
-        unit_cell=cs.minimum_cell().unit_cell(),
+        unit_cell=cs_min_cell.unit_cell(),
         space_group=sgtbx.space_group(),
     )
-    assert handler.target_symmetry_primitive.unit_cell().parameters() == pytest.approx(
-        cs.minimum_cell().unit_cell().parameters()
+    assert handler.target_symmetry_primitive.unit_cell().volume() == pytest.approx(
+        cs_min_cell.unit_cell().volume()
     )
     assert handler.target_symmetry_primitive.space_group() == sgtbx.space_group("P-1")
     assert (
-        handler.target_symmetry_reference_setting.unit_cell().parameters()
-        == pytest.approx(cs.minimum_cell().unit_cell().parameters())
+        handler.target_symmetry_reference_setting.unit_cell().volume()
+        == pytest.approx(cs_min_cell.unit_cell().volume())
     )
     assert handler.target_symmetry_reference_setting.space_group() == sgtbx.space_group(
         "P-1"