finalcif 172__tar.gz → 175__tar.gz

{finalcif-172 → finalcif-175}/.gitignore

@@ -243,3 +243,4 @@ finalcif_keys_order.cif
 /work/dicts/ddl.dic
 /test-data/4060314-finalcif.zip
 /test-data/report_4060314-finalcif.html
+Z-value_examples

{finalcif-172 → finalcif-175}/.ruff.toml

@@ -51,7 +51,9 @@ select = ["E", "F", "B", "UP", "ANN", "A", "C4", "DTZ", "NPY", "PL", "FURB", "RU
 ignore = ["E501", "F401", "E401", "B904", "E402", "C901",
     "PLR0912", "PLR0915", "PLR0913", "ANN201", "ANN201", "ANN204", "ANN001", "ANN002",
     "D102", "D103", "D205", "D212", "PLR2004", "PLW2901", "DTZ005", "DTZ006", "UP015",
-    "RUF012", "DTZ001",
+    "RUF012",
+    "DTZ001",
+    "PLR0911",
 ]
 
 # Avoid trying to fix flake8-bugbear (`B`) violations.

{finalcif-172 → finalcif-175}/.run/compile_ui_files.run.xml

@@ -14,7 +14,7 @@
     <option name="ADD_SOURCE_ROOTS" value="true" />
     <option name="DEBUG_JUST_MY_CODE" value="true" />
     <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
-    <option name="RUN_TOOL" value="true" />
+    <option name="RUN_TOOL" value="false" />
     <option name="SCRIPT_NAME" value="scripts/compile_ui_files.py" />
     <option name="PARAMETERS" value="" />
     <option name="SHOW_COMMAND_LINE" value="false" />

{finalcif-172 → finalcif-175}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: finalcif
-Version: 172
+Version: 175
 Summary: CIF file editor
 Project-URL: Homepage, https://dkratzert.de/finalcif.html
 Project-URL: Bug Tracker, https://github.com/dkratzert/FinalCif/issues
@@ -15,14 +15,14 @@ Requires-Python: >=3.12
 Requires-Dist: certifi==2026.6.17
 Requires-Dist: chardet
 Requires-Dist: charset-normalizer
-Requires-Dist: docxcompose==2.2.0
+Requires-Dist: docxcompose>=2.2.0
 Requires-Dist: docxtpl[subdoc]>=0.20.2
-Requires-Dist: fastmolwidget>=1.0.0
+Requires-Dist: fastmolwidget>=1.2.0
 Requires-Dist: gemmi>=0.7.5
 Requires-Dist: html2text
 Requires-Dist: lxml>=6.1.1
 Requires-Dist: numpy==2.4.6
-Requires-Dist: packaging==26.2
+Requires-Dist: packaging==26.3
 Requires-Dist: pefile
 Requires-Dist: pybind11>=3
 Requires-Dist: pyenchant
@@ -31,7 +31,7 @@ Requires-Dist: python-docx
 Requires-Dist: qtawesome
 Requires-Dist: qtpy
 Requires-Dist: requests
-Requires-Dist: shelxfile==24
+Requires-Dist: shelxfile>=24
 Requires-Dist: urllib3==2.7.0
 Requires-Dist: wheel==0.47.0
 Description-Content-Type: text/markdown

finalcif-175/finalcif/__init__.py

@@ -0,0 +1,3 @@
+
+VERSION = 175
+__version__ = VERSION

{finalcif-172 → finalcif-175}/finalcif/appwindow.py

@@ -26,6 +26,8 @@ if TYPE_CHECKING:
     from finalcif.cif.checkcif.checkcif import MyHTMLParser
 
 from fastmolwidget import Atomtuple
+from fastmolwidget.density_controls import ResidualDensityControls
+from fastmolwidget.hkl_io import find_reflection_file, has_reflections
 from fastmolwidget.part_combo import PartFilterWidget
 
 from finalcif.gui.shelx_navigation import find_shelx_line_for_atom, scroll_and_highlight_shelx_atom
@@ -86,10 +88,12 @@ from finalcif.tools.platon import PlatonRunner
 from finalcif.tools.settings import FinalCifSettings
 from finalcif.tools.shred import ShredCIF
 from finalcif.tools.space_groups import SpaceGroups
+from finalcif.tools.squeeze import append_unknown_solvent, has_unassigned_solvent
 from finalcif.tools.z_from_packing import count_z_and_zprime, ZResult
 from finalcif.tools.spgr_format import spgrps
 from finalcif.tools.statusbar import StatusBar
-from finalcif.tools.sumformula import formula_str_to_dict, formula_to_html, sum_formula_to_html
+from finalcif.tools.sumformula import (formula_str_to_dict, formula_to_html, sum_formula_to_html,
+                                       with_solvent_marker)
 
 DEBUG = False
 app = QApplication.instance()
@@ -194,6 +198,14 @@ class AppWindow(QMainWindow):
         self.parts_combo = PartFilterWidget(parent=self.ui.molGroupBox, label=' ', min_combo_width=90)
         self.parts_combo.setObjectName('partsFilterWidget')
         self.ui.horizontalLayout_7.insertWidget(3, self.parts_combo)
+        # Residual density button and level spin box, next to the parts selector.
+        # The file dialog is switched off: without reflection data the structure
+        # is simply shown without density.
+        self.density_controls = ResidualDensityControls(render_widget=self.ui.render_widget,
+                                                        parent=self.ui.molGroupBox,
+                                                        allow_reflection_dialog=False)
+        self.density_controls.setObjectName('residualDensityControls')
+        self.ui.horizontalLayout_7.insertWidget(4, self.density_controls)
         # Inject the Author Editor tab (defined in the .ui file) into LoopsPage
         self.ui.loops_page.set_author_editor_tab(self.ui.author_editor_widget)
         self.fixfont = QtGui.QFontDatabase.systemFont(QtGui.QFontDatabase.SystemFont.FixedFont)
@@ -1305,8 +1317,9 @@ class AppWindow(QMainWindow):
             self.ui.CheckCifLogPlainTextEdit.appendHtml(
                 f'<br><b>{n} validation response forms {form_noun} added to the main table.</b>')
         else:
+            levels = 'A, B or C' if self.ui.explainCandGAlertsCheckBox.isChecked() else 'A or B'
             self.ui.CheckCifLogPlainTextEdit.appendHtml(
-                '<br><b>No level A, B or C alerts require a response.</b>')
+                f'<br><b>No level {levels} alerts require a response.</b>')
 
     def _vrf_insert_position(self) -> int:
         """Return the row index just after the last existing ``_vrf_*`` row in the main table.
@@ -1358,7 +1371,8 @@ class AppWindow(QMainWindow):
                             hkl_upload=(not self.ui.structfactCheckBox.isChecked()), pdf=False,
                             url=self.options.checkcif_url,
                             full_iucr=self.ui.fullIucrCheckBox.isChecked(),
-                            check_duplicates=self.ui.checkDuplicatesCheckBox.isChecked())
+                            check_duplicates=self.ui.checkDuplicatesCheckBox.isChecked(),
+                            explain_c=self.ui.explainCAlertsCheckBox.isChecked())
         self.ckf.progress.connect(self._ckf_progress)
         self.ckf.failed.connect(self._checkcif_failed)
         self.ckf.finished.connect(self._checkcif_finished)
@@ -1506,6 +1520,50 @@ class AppWindow(QMainWindow):
             self.ui.cif_main_table.setText(key='_chemical_formula_moiety', txt=formula_moiety, column=Column.EDIT)
         self.show_moiety_formula_tooltip(moiety if moiety not in ['', '?'] else formula_moiety)
 
+    def _with_squeezed_solvent(self, formula_moiety: str) -> str:
+        """Mark a generated moiety formula with ``[+ solvent]`` for squeezed structures.
+
+        The unmodelled solvent of a PLATON SQUEEZE / Olex2-SMTBX structure is
+        missing from the atom model, so the moiety derived from the bond graph
+        is incomplete unless the void content was assigned a formula.
+        """
+        try:
+            if has_unassigned_solvent(self.cif):
+                return append_unknown_solvent(formula_moiety)
+        except Exception:
+            pass
+        return formula_moiety
+
+    def mark_squeezed_solvent_in_formulas(self) -> None:
+        """Append ``[+ solvent]`` to the sum and moiety formula of a squeezed structure.
+
+        PLATON marks both ``_chemical_formula_sum`` and
+        ``_chemical_formula_moiety`` this way whenever solvent was removed by
+        SQUEEZE or an Olex2/SMTBX mask, because the formulas then describe less
+        than the real content of the unit cell.  Nothing is marked when the void
+        content was assigned a formula, or for multi-CIF files.
+        """
+        try:
+            if self.cif.is_multi_cif or not has_unassigned_solvent(self.cif):
+                return
+        except Exception:
+            return
+        for key in ('_chemical_formula_sum', '_chemical_formula_moiety'):
+            self._append_solvent_marker_to(key)
+
+    def _append_solvent_marker_to(self, key: str) -> None:
+        """Write *key* back with the unknown-solvent marker unless it is empty.
+
+        ``append_unknown_solvent`` normalises a marker that a previous save
+        wrapped across two CIF lines, so the comparison has to be made against
+        the normalised value to avoid writing the row over and over.
+        """
+        current = (self.ui.cif_main_table.getTextFromKey(key=key, col=Column.EDIT)
+                   or self.ui.cif_main_table.getTextFromKey(key=key, col=Column.CIF))
+        marked = append_unknown_solvent(current)
+        if marked and marked != current.strip():
+            self.ui.cif_main_table.setText(key=key, txt=marked, column=Column.EDIT)
+
     def append_to_ciflog_without_newline(self, text: str = '') -> None:
         self.ui.CheckCifLogPlainTextEdit.moveCursor(QtGui.QTextCursor.MoveOperation.End)
         self.ui.CheckCifLogPlainTextEdit.insertPlainText(text)
@@ -2046,6 +2104,7 @@ class AppWindow(QMainWindow):
             self.enable_buttons()
             self.fill_space_group_lineedit()
             self.fill_sum_formula_lineedit()
+            self.mark_squeezed_solvent_in_formulas()
             self.ui.CCDCNumLineEdit.setText(self.cif['_database_code_depnum_ccdc_archive'])
             self.ui.CheckcifPlaintextEdit.clear()
             self.ui.TemplatesStackedWidget.setCurrentIndex(0)
@@ -2084,11 +2143,12 @@ class AppWindow(QMainWindow):
             return False
 
     def fill_sum_formula_lineedit(self) -> None:
+        formula = self.cif['_chemical_formula_sum'].strip(" '")
         try:
-            self.ui.SumFormMainLineEdit.setText(sum_formula_to_html(formula_str_to_dict(
-                self.cif['_chemical_formula_sum'].strip(" '"))))
+            html = sum_formula_to_html(formula_str_to_dict(formula))
+            self.ui.SumFormMainLineEdit.setText(with_solvent_marker(html, formula))
         except Exception:
-            self.ui.SumFormMainLineEdit.setText(self.cif['_chemical_formula_sum'].strip(" '"))
+            self.ui.SumFormMainLineEdit.setText(formula)
         self.show_moiety_formula_tooltip()
 
     def show_moiety_formula_tooltip(self, formula_moiety: str = '') -> None:
@@ -2255,6 +2315,7 @@ class AppWindow(QMainWindow):
         if peak:
             self.ui.peakLineEdit.setText("{} / {}".format(peak, self.cif['_refine_diff_density_min']))
         self._show_shelx_file()
+        self._update_residual_density_source()
         try:
             single_shot(self, 0, lambda: self.view_molecule(reset_view=True))
         except Exception:
@@ -2316,6 +2377,29 @@ class AppWindow(QMainWindow):
                 self.ui.render_widget.grow_molecule(atom_tuples,
                                                     cell=self.cif.cell[:6])
 
+    def _update_residual_density_source(self) -> None:
+        """Tell the viewer which model and reflections the shown atoms come from.
+
+        The block in memory is used, not the file on disk, so that the density
+        follows unsaved edits and the block the user selected in a multi-block
+        CIF.  Without any reflection data the density button stays disabled and
+        the structure is simply displayed without density.
+        """
+        with suppress(Exception):
+            self.ui.render_widget.set_model_source(self.cif.block,
+                                                   reflections=self._reflection_source())
+            self.density_controls.update_density_availability()
+
+    def _reflection_source(self) -> gemmi.cif.Block | Path | None:
+        """Where the reflections of the current structure are, if anywhere.
+
+        Self-contained SHELXL CIFs carry the whole ``.hkl`` in the block itself;
+        otherwise a sibling ``.hkl``/``.fcf`` of the CIF on disk is used.
+        """
+        if has_reflections(self.cif.block):
+            return self.cif.block
+        return find_reflection_file(self.cif.fileobj)
+
     def _update_z_label(self) -> None:
         """Start a background computation of Z and Z′ and show a placeholder.
 
@@ -2371,7 +2455,7 @@ class AppWindow(QMainWindow):
             return
         # Propagate moiety formula to the CIF table if not already filled.
         if result.moiety_formula:
-            self.add_moiety_furmula(result.moiety_formula)
+            self.add_moiety_furmula(self._with_squeezed_solvent(result.moiety_formula))
         confidence_icon = {'high': '✓', 'medium': '~', 'formula': '≡', 'low': '?'}[result.confidence]
         self.ui.zEstimateLabel.setText(f"Z = {result.z}  Z′ = {result.z_prime:.3g}  {confidence_icon}")
         self.ui.zEstimateLabel2.setText(f"Z = {result.z}  Z′ = {result.z_prime:.3g}  {confidence_icon}")
@@ -2499,7 +2583,8 @@ class AppWindow(QMainWindow):
         Tries to determine the sources of missing data in the cif file, e.g. Tmin/Tmax from SADABS.
         """
         self.check_Z()
-        self.sources = BrukerData(self, self.cif).sources
+        bruker_data = BrukerData(self, self.cif)
+        self.sources = bruker_data.sources
         squeeze_dialog_shown = False
         if self.sources:
             # Add the CCDC number in case we have a deposition mail lying around:
@@ -2540,6 +2625,32 @@ class AppWindow(QMainWindow):
                 # TypeError my originate from incomplete self.missing_data list!
                 # print(e, '##', miss_key)
                 pass
+        self._apply_source_overrides(bruker_data.overrides)
+        self._add_source_tooltips()
+
+    def _add_source_tooltips(self) -> None:
+        """
+        Shows the file a value of the data source column came from as a tooltip.
+        """
+        for key, source in self.sources.items():
+            if not source or not source[1] or not self.ui.cif_main_table.has_key(key):
+                continue
+            widget = self.ui.cif_main_table.widget_from_key(key, Column.DATA)
+            if widget:
+                widget.setToolTip(f'Source: {source[1]}')
+
+    def _apply_source_overrides(self, overrides: set[str]) -> None:
+        """
+        Replaces values that are known to be wrong in the CIF (SHELXL writes for example
+        wrong reflection numbers for twins) by the value of the corresponding data source.
+        """
+        for key in overrides:
+            source = self.sources.get(key)
+            if not source or not source[0] or key in self.missing_data:
+                continue
+            if not self.ui.cif_main_table.has_key(key):
+                continue
+            self.ui.cif_main_table.setText(key=key, column=Column.DATA, txt=str(source[0]), color=light_green)
 
     def add_ccdc_number(self):
         ccdc = CCDCMail(self.cif)
@@ -2550,7 +2661,7 @@ class AppWindow(QMainWindow):
                 self.add_row('_database_code_depnum_ccdc_archive', '', at_start=True)
             txt = self.ui.cif_main_table.getTextFromKey('_database_code_depnum_ccdc_archive', Column.EDIT).strip()
             if not txt or (txt == '?'):
-                self.sources['_database_code_depnum_ccdc_archive'] = (str(ccdc.depnum), str(ccdc.emlfile.name))
+                self.sources['_database_code_depnum_ccdc_archive'] = (str(ccdc.depnum), str(ccdc.emlfile))
                 self.missing_data.add('_database_code_depnum_ccdc_archive')
 
     def refresh_combo_boxes(self) -> None:

{finalcif-172 → finalcif-175}/finalcif/cif/checkcif/checkcif.py

@@ -215,7 +215,8 @@ class CheckCif(QThread):
     failed = Signal(str)
 
     def __init__(self, parent, cif: CifContainer, outfile: Path, hkl_upload: bool = True,
-                 pdf: bool = False, url: str = '', full_iucr: bool = False, check_duplicates: bool = True):
+                 pdf: bool = False, url: str = '', full_iucr: bool = False, check_duplicates: bool = True,
+                 explain_c: bool = False):
         # hkl == False means no hkl upload
         super().__init__(parent=parent)
         self.hkl_upload = hkl_upload
@@ -225,6 +226,7 @@ class CheckCif(QThread):
         self.checkcif_url = url
         self.full_iucr = full_iucr
         self.check_duplicates = check_duplicates
+        self.explain_c = explain_c
 
     def _html_check(self) -> None:
         if self.hkl_upload:
@@ -232,12 +234,12 @@ class CheckCif(QThread):
         else:
             self.progress.emit('Running Checkcif with no hkl data')
 
-    def get_vrf(self):
+    def get_vrf(self) -> str:
+        """The 'valout' request value defining which alert levels get a response form."""
         if self.pdf:
             return 'vrfno'
-        else:
-            # Currently, the vrfabc option misses some validation response forms. Only vrfab gives correct results.
-            return 'vrfabc'
+        # The IUCr server offers no response forms for level G alerts.
+        return 'vrfabc' if self.explain_c else 'vrfab'
 
     def run(self) -> None:
         """

finalcif-175/finalcif/cif/hkl.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+import re
+from collections import namedtuple
+from collections.abc import Sequence
+from pathlib import Path
+
+import gemmi
+import numpy as np
+from gemmi.cif import Loop, Document, Style
+from packaging import version
+
+Limit = namedtuple('Limit', 'h_max, h_min, k_max, k_min, l_max, l_min')
+
+
+class HKL:
+    """
+    loop_
+      _refln_index_h
+      _refln_index_k
+      _refln_index_l
+      _refln_F_squared_meas
+      _refln_F_squared_sigma
+      _refln_scale_group_code
+    """
+
+    def __init__(self, hkl_file: str, block_name: str, hklf_type: int = 4):
+        self._hkl_file = hkl_file
+        self.hklf_type = hklf_type
+        self._doc: Document = gemmi.cif.Document()
+        self._doc.add_new_block(block_name)
+        self.block = self._doc.sole_block()
+        self._add_hkl_as_loop()
+
+    @property
+    def hkl_as_cif(self) -> str:
+        if version.parse(gemmi.__version__) < version.parse('0.5.1'):
+            return self._doc.as_string(style=Style.Simple)
+        else:
+            return self._doc.as_string(options=gemmi.cif.WriteOptions(Style.Simple))
+
+    def _add_hkl_as_loop(self) -> None:
+        """
+        Adds the hkl data from a SHELX hkl file as local loop.
+        """
+        hkl_width = self._get_hkl_width()
+        loop_header = ['index_h',
+                       'index_k',
+                       'index_l',
+                       'F_squared_meas' if self.hklf_type != 3 else 'F_meas',
+                       'F_squared_sigma' if self.hklf_type != 3 else 'F_sigma',
+                       'scale_group_code']
+        loop: Loop = self.block.init_loop('_refln_', self._trim_header_to_hkl_width(loop_header))
+        zero_reflection_pattern = re.compile(r'^\s+0\s+0\s+0\s+0.*')
+        for line in self._hkl_file.splitlines(keepends=False):
+            splitline = line.split()
+            if not splitline:
+                continue
+            # Do not use data after the 0 0 0 reflection
+            if zero_reflection_pattern.match(line):
+                # Need to truncate, because some programs add the scale group even if
+                # there is no scale group in other reflections
+                loop.add_row(splitline[:hkl_width])
+                break
+            try:
+                loop.add_row(splitline[:len(loop_header)])
+            # RuntimeError ist from gemmi.cif.add_row:
+            except (IndexError, RuntimeError):
+                continue
+
+    def __repr__(self) -> str:
+        return self.hkl_as_cif[:250]
+
+    def _trim_header_to_hkl_width(self, loop_header: list[str]) -> list[str]:
+        hkl_with = self._get_hkl_width()
+        trimmed_header = loop_header[:hkl_with]
+        return trimmed_header
+
+    def _get_hkl_width(self) -> int:
+        first_lines = self._hkl_file[:150].strip().splitlines(keepends=False)
+        if len(first_lines) > 1:
+            return len(first_lines[1].split())
+        return len(first_lines[0].split())
+
+    def get_hkl_min_max(self) -> Limit:
+        hkl: gemmi.ReflnBlock = gemmi.hkl_cif_as_refln_block(self.block)
+        miller = hkl.make_miller_array()
+        h_max, k_max, l_max = np.max(miller, axis=0)
+        h_min, k_min, l_min = np.min(miller, axis=0)
+        return Limit(h_max=h_max, h_min=h_min, k_max=k_max, k_min=k_min, l_max=l_max, l_min=l_min)
+
+
+def calculate_rint(hkl_file: str, space_group: str, *, cell: Sequence[float] | None = None,
+                   resolution: tuple[float, float] | None = None, hklf: int = 4,
+                   twst: int | None = None) -> float | None:
+    """
+    R(int) of an unmerged SHELX hkl file, calculated the way SHELXL and Olex2 do it:
+
+        R(int) = sum|Fo^2 - Fo^2(mean)| / sum[Fo^2]
+
+    Systematically absent reflections are rejected and Friedel opposites are only merged in
+    centrosymmetric space groups. Fo^2(mean) is the mean weighted with 1/sigma^2.
+
+    For HKLF 5 data only the singly indexed reflections of the reference domain are used,
+    because composite (overlapped) reflections have no symmetry equivalents to compare with.
+
+    SADABS writes no overall R(int) into its listing file, only the wR2(int) of the parameter
+    refinement and the R(int) values of the individual runs. The R(int) of a TWINABS listing
+    file describes a data treatment that a HKLF 5 refinement does not use.
+
+    Args:
+        hkl_file: Content of a SHELX hkl file.
+        space_group: Space group name, e.g. 'P n a 21'.
+        cell: Unit cell parameters, needed to apply a resolution limit.
+        resolution: Lowest and highest resolution in Angstrom (a SHELX SHEL instruction).
+        hklf: The SHELX HKLF file type. Data with negative batch numbers are always treated as
+            HKLF 5 data.
+        twst: The domain of a SHELX TWST instruction, only used for HKLF 5 data.
+    """
+    miller, intensities, sigmas, batches = _reflections_from_shelx_hkl(hkl_file)
+    if not len(miller) or not space_group:
+        return None
+    if hklf >= 5 or bool((batches < 0).any()):
+        # Only an HKLF 5 file has negative batch numbers:
+        singles = _singles_of_reference_domain(batches, twst)
+        miller, intensities, sigmas = miller[singles], intensities[singles], sigmas[singles]
+        if not len(miller):
+            return None
+    try:
+        operations = gemmi.SpaceGroup(space_group).operations()
+    except (RuntimeError, ValueError):
+        return None
+    used = ~_systematically_absent(miller, operations)
+    used &= _within_resolution(miller, cell, resolution)
+    miller, intensities, sigmas = miller[used], intensities[used], sigmas[used]
+    if not len(miller):
+        return None
+    groups, counts = _group_equivalents(miller, operations)
+    if len(counts) >= len(miller):
+        # Merged data have no equivalent reflections to compare:
+        return None
+    return _rint_of_groups(groups, counts, intensities, sigmas)
+
+
+def reference_domain(hkl_file: str, twst: int | None = None) -> int | None:
+    """
+    The twin domain whose singly indexed reflections are used for the R(int) of HKLF 5 data.
+    """
+    *_, batches = _reflections_from_shelx_hkl(hkl_file)
+    if not len(batches):
+        return None
+    return _largest_domain(batches[_singles(batches)]) or None
+
+
+def _singles_of_reference_domain(batches: np.ndarray, twst: int | None) -> np.ndarray:
+    """
+    The singly indexed reflections of the reference domain of an HKLF 5 file.
+
+    The reference domain is the domain of a SHELX TWST instruction or, like in Olex2, the
+    domain with the most singly indexed reflections.
+    """
+    singles = _singles(batches)
+    domain = twst if twst and twst > 0 else _largest_domain(batches[singles])
+    return singles & (batches == domain)
+
+
+def _singles(batches: np.ndarray) -> np.ndarray:
+    """
+    In an HKLF 5 file all members of a composite reflection except the last one have a negative
+    batch number, thus a reflection is a single if its own batch number and that of its
+    predecessor are positive.
+    """
+    previous = np.concatenate(([1], batches[:-1]))
+    return (batches > 0) & (previous > 0)
+
+
+def _largest_domain(domains: np.ndarray) -> int:
+    if not len(domains):
+        return 0
+    values, counts = np.unique(domains, return_counts=True)
+    return int(values[np.argmax(counts)])
+
+
+def _within_resolution(miller: np.ndarray, cell: Sequence[float] | None,
+                       resolution: tuple[float, float] | None) -> np.ndarray:
+    """
+    Applies the resolution limits of a SHELX SHEL instruction.
+    """
+    if not resolution or not cell:
+        return np.ones(len(miller), dtype=bool)
+    lowest, highest = max(resolution), min(resolution)
+    try:
+        spacing = gemmi.UnitCell(*cell[:6]).calculate_d_array(miller)
+    except (RuntimeError, TypeError, ValueError):
+        return np.ones(len(miller), dtype=bool)
+    return (spacing <= lowest) & (spacing >= highest)
+
+
+def _rint_of_groups(groups: np.ndarray, counts: np.ndarray, intensities: np.ndarray,
+                    sigmas: np.ndarray) -> float | None:
+    weights = np.where(sigmas > 0.0, 1.0 / np.square(np.where(sigmas > 0.0, sigmas, 1.0)), 1.0)
+    weight_sum = np.bincount(groups, weights=weights, minlength=len(counts))
+    mean = np.bincount(groups, weights=weights * intensities, minlength=len(counts)) / weight_sum
+    with_equivalents = counts[groups] > 1
+    numerator = np.abs(intensities - mean[groups])[with_equivalents].sum()
+    denominator = intensities[with_equivalents].sum()
+    if not denominator:
+        return None
+    return round(float(numerator / denominator), 4)
+
+
+def _group_equivalents(miller: np.ndarray, operations: gemmi.GroupOps) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Assigns a group number to every reflection that is symmetry equivalent to another one.
+    """
+    equivalents = [_encode(miller @ _rotation(op)) for op in operations.sym_ops]
+    if operations.is_centrosymmetric():
+        equivalents += [_encode(-(miller @ _rotation(op))) for op in operations.sym_ops]
+    representative = np.max(np.stack(equivalents), axis=0)
+    _, groups, counts = np.unique(representative, return_inverse=True, return_counts=True)
+    return groups, counts
+
+
+def _systematically_absent(miller: np.ndarray, operations: gemmi.GroupOps) -> np.ndarray:
+    absent = np.zeros(len(miller), dtype=bool)
+    for op in operations.sym_ops:
+        translation = np.array(op.tran, dtype=np.float64) / op.DEN
+        if not translation.any():
+            continue
+        unchanged = (miller @ _rotation(op) == miller).all(axis=1)
+        phase = miller @ translation
+        absent |= unchanged & (np.abs(phase - np.round(phase)) > 1e-6)
+    for centering in operations.cen_ops:
+        translation = np.array(centering, dtype=np.float64) / gemmi.Op.DEN
+        if not translation.any():
+            continue
+        phase = miller @ translation
+        absent |= np.abs(phase - np.round(phase)) > 1e-6
+    return absent
+
+
+def _rotation(op: gemmi.Op) -> np.ndarray:
+    """The rotation part of a symmetry operation, applicable as ``miller @ rotation``."""
+    return np.array(op.rot, dtype=np.int64) // op.DEN
+
+
+def _encode(miller: np.ndarray) -> np.ndarray:
+    """Packs Miller indices into single numbers that keep their lexicographic order."""
+    shifted = miller.astype(np.int64) + 2 ** 20
+    return (shifted[:, 0] << 42) | (shifted[:, 1] << 21) | shifted[:, 2]
+
+
+def _reflections_from_shelx_hkl(hkl_file: str) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    miller, intensities, sigmas, batches = [], [], [], []
+    for line in hkl_file.splitlines(keepends=False):
+        if len(line) < 28:
+            continue
+        try:
+            index = (int(line[0:4]), int(line[4:8]), int(line[8:12]))
+            if not any(index):
+                break
+            intensity, sigma = float(line[12:20]), float(line[20:28])
+        except ValueError:
+            continue
+        miller.append(index)
+        intensities.append(intensity)
+        sigmas.append(sigma)
+        batches.append(_batch_number(line))
+    return (np.array(miller, dtype=np.int32).reshape(-1, 3),
+            np.array(intensities, dtype=np.float64),
+            np.array(sigmas, dtype=np.float64),
+            np.array(batches, dtype=np.int32))
+
+
+def _batch_number(line: str) -> int:
+    """The batch number of an HKLF 5 reflection, negative for all but the last member of a
+    composite reflection."""
+    try:
+        return int(line[28:32])
+    except ValueError:
+        return 1
+
+
+if __name__ == '__main__':
+    h = HKL(Path('tests/examples/work/test_hkl_file.txt').read_text(), '123234')
+    # print(h.hkl_as_cif[:250])
+    m = h.get_hkl_min_max()
+    print(m)