finalcif 173__tar.gz → 175__tar.gz

{finalcif-173 → 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-173 → 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-173 → 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-173 → finalcif-175}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: finalcif
-Version: 173
+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-173 → 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)
@@ -1072,7 +1084,6 @@ class AppWindow(QMainWindow):
             source_item = MyTableWidgetItem(s)
             source_item.setUneditable()
             data_item = MyTableWidgetItem(self.sources[s][1])
-            data_item.setToolTip(str(self.sources[s][1]))
             data_item.setUneditable()
             table.setItem(rownum, COL_key, source_item)
             table.setItem(rownum, COL_source_data, data_item)
@@ -1306,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.
@@ -1359,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)
@@ -1507,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)
@@ -2047,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)
@@ -2085,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:
@@ -2256,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:
@@ -2317,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.
 
@@ -2372,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}")
@@ -2543,6 +2626,18 @@ class AppWindow(QMainWindow):
                 # 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:
         """

{finalcif-173 → 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-173 → finalcif-175}/finalcif/cif/hkl.py

@@ -90,28 +90,42 @@ class HKL:
         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) -> float | None:
+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 HKLF 4 file, calculated the way SHELXL does it:
+    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.
+    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 HKLF 4 file.
+        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 = _reflections_from_shelx_hkl(hkl_file)
+    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):
@@ -128,6 +142,45 @@ def calculate_rint(hkl_file: str, space_group: str, cell: Sequence[float] | 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:
     """
@@ -197,8 +250,8 @@ def _encode(miller: np.ndarray) -> np.ndarray:
     return (shifted[:, 0] << 42) | (shifted[:, 1] << 21) | shifted[:, 2]
 
 
-def _reflections_from_shelx_hkl(hkl_file: str) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-    miller, intensities, sigmas = [], [], []
+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
@@ -212,9 +265,20 @@ def _reflections_from_shelx_hkl(hkl_file: str) -> tuple[np.ndarray, np.ndarray,
         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(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__':

{finalcif-173 → finalcif-175}/finalcif/datafiles/bruker_data.py

@@ -5,6 +5,8 @@
 #  and you think this stuff is worth it, you can buy me a beer in return.
 #  Dr. Daniel Kratzert
 #  ----------------------------------------------------------------------------
+from __future__ import annotations
+
 import re
 from contextlib import suppress
 from pathlib import Path
@@ -12,11 +14,11 @@ from pathlib import Path
 from gemmi import cif as gcif
 
 from finalcif.cif.cif_file_io import CifContainer
-from finalcif.cif.hkl import calculate_rint
+from finalcif.cif.hkl import calculate_rint, reference_domain
 from finalcif.datafiles.bruker_frame import BrukerFrameHeader
 from finalcif.datafiles.data import WorkDataMixin
 from finalcif.datafiles.p4p_reader import P4PFile
-from finalcif.datafiles.sadabs import Sadabs
+from finalcif.datafiles.sadabs import Dataset, Sadabs
 from finalcif.datafiles.saint import SaintListFile
 from finalcif.datafiles.shelx_lst import SolutionProgram
 from finalcif.gui.dialogs import show_general_warning
@@ -231,38 +233,91 @@ class BrukerData(WorkDataMixin):
         """
         Adds the number of measured reflections and R(int) of the data set that belongs to the
         hkl file of this refinement. SHELXL can not determine these values from an HKLF 5 file,
-        thus the values of a TWINABS file take precedence over the values in the CIF.
+        thus the number of reflections of a TWINABS file and a calculated R(int) take precedence
+        over the values in the CIF.
         """
         dataset = sadabs.select_dataset(hkl_basename=self._hkl_basename,
                                         reflections=self._reflections_in_hkl_file(),
                                         hklf=self.cif.hklf_number)
-        if not dataset:
-            return
-        rint = dataset.rint or self._rint_from_hkl_data()
-        if rint:
-            self.sources['_diffrn_reflns_av_R_equivalents'] = (rint, self._rint_source(dataset, sadabs))
-        if dataset.reflections_number:
+        self._add_rint(dataset, sadabs)
+        if dataset and dataset.reflections_number:
             self.sources['_diffrn_reflns_number'] = (dataset.reflections_number, source_path(sadabs.filename))
-        if sadabs.is_twinabs and dataset.filetype == 5:
-            self.overrides.update({'_diffrn_reflns_av_R_equivalents', '_diffrn_reflns_number'})
+            if sadabs.is_twinabs and dataset.filetype == 5:
+                self.overrides.add('_diffrn_reflns_number')
 
-    def _rint_source(self, dataset, sadabs: Sadabs) -> str:
-        if dataset.rint:
-            return source_path(sadabs.filename)
+    def _add_rint(self, dataset: Dataset | None, sadabs: Sadabs) -> None:
+        """
+        The R(int) of an HKLF 5 refinement is calculated from the reflection data, because the
+        R(int) of a TWINABS listing file is a residual of the TWINABS twin fraction refinement
+        and not the agreement of symmetry equivalent reflections.
+        """
+        calculated = self._rint_from_hkl_data()
+        listed = dataset.rint if dataset else None
+        twinned = self._is_twinned(dataset, sadabs)
+        if twinned:
+            rint, source = calculated, self._calculated_rint_source(twinned)
+            if not rint:
+                rint, source = listed, self._listed_rint_source(dataset, sadabs)
+        else:
+            rint, source = listed, source_path(sadabs.filename)
+            if not rint:
+                rint, source = calculated, self._calculated_rint_source(twinned)
+        if not rint:
+            return
+        self.sources['_diffrn_reflns_av_R_equivalents'] = (rint, source)
+        if twinned:
+            self.overrides.add('_diffrn_reflns_av_R_equivalents')
+
+    def _is_twinned(self, dataset: Dataset | None, sadabs: Sadabs) -> bool:
+        """
+        SHELXL can not determine R(int) of HKLF 5 data, thus FinalCif has to do it.
+        """
+        return self.cif.hklf_number >= 5 or bool(
+            sadabs.is_twinabs and dataset and dataset.filetype == 5)
+
+    def _calculated_rint_source(self, twinned: bool) -> str:
+        if twinned:
+            return (f'calculated from {source_path(self.cif.fileobj)} '
+                    f'(singles of twin component {self._reference_domain()}, '
+                    f'merged in {self.cif.space_group})')
         return f'calculated from {source_path(self.cif.fileobj)}'
 
+    def _reference_domain(self) -> int | None:
+        return self._twst() or reference_domain(self.cif.hkl_file)
+
+    def _listed_rint_source(self, dataset: Dataset | None, sadabs: Sadabs) -> str:
+        """
+        The R(int) of the TWINABS statistics is only valid for the point group the equivalent
+        reflections were defined with.
+        """
+        source = source_path(sadabs.filename)
+        statistics = dataset.singles_statistics if dataset else None
+        if statistics and dataset.equivalents_point_group:
+            return (f'{source} (singles of twin component {statistics.component}, '
+                    f'point group {dataset.equivalents_point_group})')
+        return source
+
     def _rint_from_hkl_data(self) -> float | None:
         """
-        SADABS writes no overall R(int) into its listing file, therefore it is calculated from
-        the reflection data, but only if the CIF has no R(int) yet. SHELXL can not calculate it
-        for the composite reflections of HKLF 5 data.
+        R(int) calculated from the reflection data of the CIF.
+
+        SADABS writes no overall R(int) into its listing file and SHELXL can not determine it
+        from an HKLF 5 file, therefore it is calculated here. For HKLF 4 data this only happens
+        if the CIF has no R(int) yet, while for HKLF 5 data the calculated value is always
+        preferred over the R(int) of a TWINABS listing file, which is a model residual of the
+        TWINABS twin fraction refinement instead of a merging R(int).
         """
-        if self.cif.hklf_number != 4:
-            return None
-        if gcif.as_string(self.cif['_diffrn_reflns_av_R_equivalents']).strip(' ?'):
+        if self.cif.hklf_number == 4 and gcif.as_string(
+                self.cif['_diffrn_reflns_av_R_equivalents']).strip(' ?'):
             return None
         return calculate_rint(self.cif.hkl_file, self.cif.space_group,
-                              cell=self.cif.cell, resolution=self._resolution_limits())
+                              cell=self.cif.cell, resolution=self._resolution_limits(),
+                              hklf=self.cif.hklf_number, twst=self._twst())
+
+    def _twst(self) -> int | None:
+        """The reference domain of a SHELX TWST instruction."""
+        match = re.search(r'^TWST\s+(-?\d+)', self.cif.res_file_data or '', re.MULTILINE)
+        return int(match.group(1)) if match else None
 
     def _resolution_limits(self) -> tuple[float, float] | None:
         """The resolution limits of a SHELX SHEL instruction, if there is one."""