finalcif 172__tar.gz → 173__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: finalcif
-Version: 172
+Version: 173
 Summary: CIF file editor
 Project-URL: Homepage, https://dkratzert.de/finalcif.html
 Project-URL: Bug Tracker, https://github.com/dkratzert/FinalCif/issues

finalcif-173/finalcif/__init__.py

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

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

@@ -1072,6 +1072,7 @@ 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)
@@ -2499,7 +2500,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 +2542,20 @@ class AppWindow(QMainWindow):
                 # TypeError my originate from incomplete self.missing_data list!
                 # print(e, '##', miss_key)
                 pass
+        self._apply_source_overrides(bruker_data.overrides)
+
+    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 +2566,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-173/finalcif/cif/hkl.py

@@ -0,0 +1,224 @@
+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) -> float | None:
+    """
+    R(int) of an unmerged SHELX HKLF 4 file, calculated the way SHELXL does 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.
+
+    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.
+
+    Args:
+        hkl_file: Content of a SHELX HKLF 4 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).
+    """
+    miller, intensities, sigmas = _reflections_from_shelx_hkl(hkl_file)
+    if not len(miller) or not space_group:
+        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 _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]:
+    miller, intensities, sigmas = [], [], []
+    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)
+    return (np.array(miller, dtype=np.int32).reshape(-1, 3),
+            np.array(intensities, dtype=np.float64),
+            np.array(sigmas, dtype=np.float64))
+
+
+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)

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

@@ -12,6 +12,7 @@ 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.datafiles.bruker_frame import BrukerFrameHeader
 from finalcif.datafiles.data import WorkDataMixin
 from finalcif.datafiles.p4p_reader import P4PFile
@@ -21,6 +22,20 @@ from finalcif.datafiles.shelx_lst import SolutionProgram
 from finalcif.gui.dialogs import show_general_warning
 
 
+def source_path(file: Path | str | None) -> str:
+    """
+    Returns the absolute path of a data source file or an empty string if it does not exist.
+    """
+    if not file:
+        return ''
+    path = Path(file)
+    with suppress(OSError):
+        path = path.resolve()
+        if path.is_file():
+            return str(path)
+    return ''
+
+
 class MissingCifData:
     def __init__(self):
         self.data = {}
@@ -54,12 +69,13 @@ class BrukerData(WorkDataMixin):
         abstype = '?'
         t_min = '?'
         t_max = '?'
+        sadabs = self.sadabs
         # Going back from last dataset:
-        for n in range(1, len(self.sadabs.datasets) + 1):
+        for n in range(1, len(sadabs.datasets) + 1):
             try:
-                abstype = 'numerical' if self.sadabs.dataset(-n).numerical else 'multi-scan'
-                t_min = self.sadabs.dataset(-n).transmission.tmin
-                t_max = self.sadabs.dataset(-n).transmission.tmax
+                abstype = 'numerical' if sadabs.dataset(-n).numerical else 'multi-scan'
+                t_min = sadabs.dataset(-n).transmission.tmin
+                t_max = sadabs.dataset(-n).transmission.tmax
                 if all([abstype, t_min, t_max]):
                     break
             except (KeyError, AttributeError, TypeError):
@@ -80,35 +96,34 @@ class BrukerData(WorkDataMixin):
         except (AttributeError, KeyError, FileNotFoundError):
             milliamps = ''
         try:
-            frame_name = self.frame_header.filename.name
+            frame_name = source_path(self.frame_header.filename)
         except FileNotFoundError:
             frame_name = ''
         if not self.cif['_computing_structure_solution'] and self.cif.solution_program_details:
-            solution_program = (self.cif.solution_program_details, self.cif.fileobj.name)
+            solution_program = (self.cif.solution_program_details, source_path(self.cif.fileobj))
         if self.cif['_computing_structure_solution']:
-            solution_program = (gcif.as_string(self.cif['_computing_structure_solution']), self.cif.fileobj.name)
+            solution_program = (gcif.as_string(self.cif['_computing_structure_solution']),
+                                source_path(self.cif.fileobj))
         if not solution_program:
-            solution_program = (sol.program.version, Path(sol.program.filename).name)
+            solution_program = (sol.program.version, source_path(sol.program.filename))
         if self.cif.absorpt_process_details:
-            absdetails = (self.cif.absorpt_process_details, self.cif.fileobj.name)
+            absdetails = (self.cif.absorpt_process_details, source_path(self.cif.fileobj))
         else:
-            absdetails = (self.sadabs.version, self.sadabs.filename.name)
+            absdetails = (sadabs.version, source_path(sadabs.filename))
         if self.cif.absorpt_correction_type:
-            abscorrtype = (self.cif.absorpt_correction_type, self.cif.fileobj.name)
+            abscorrtype = (self.cif.absorpt_correction_type, source_path(self.cif.fileobj))
         else:
-            abscorrtype = (abstype, self.sadabs.filename.name)
+            abscorrtype = (abstype, source_path(sadabs.filename))
         if self.cif.absorpt_correction_t_max:
-            abs_tmax = (self.cif.absorpt_correction_t_max, self.cif.fileobj.name)
+            abs_tmax = (self.cif.absorpt_correction_t_max, source_path(self.cif.fileobj))
         else:
-            abs_tmax = (str(t_max), self.sadabs.filename.name)
+            abs_tmax = (str(t_max), source_path(sadabs.filename))
         if self.cif.absorpt_correction_t_min:
-            abs_tmin = (self.cif.absorpt_correction_t_min, self.cif.fileobj.name)
+            abs_tmin = (self.cif.absorpt_correction_t_min, source_path(self.cif.fileobj))
         else:
-            abs_tmin = (str(t_min), self.sadabs.filename.name)
+            abs_tmin = (str(t_min), source_path(sadabs.filename))
 
-        if self.sadabs.Rint:
-            rint = (self.sadabs.Rint, self.sadabs.filename.name)
-            self.sources['_diffrn_reflns_av_R_equivalents'] = rint
+        self._add_reflection_data(sadabs)
         temp2 = self.p4p.temperature
         if temp1 is not None and temp2 is not None:
             temperature = round(min([temp1, temp2]), 1)
@@ -164,25 +179,26 @@ class BrukerData(WorkDataMixin):
         # All sources that are not filled with data will be yellow in the main table
         #                          data                         tooltip
         self.sources['_cell_measurement_reflns_used'] = (
-            self.saint_data.cell_reflections, self.saint_data.filename.name)
+            self.saint_data.cell_reflections, source_path(self.saint_data.filename))
         self.sources['_cell_measurement_theta_min'] = (
-            self.saint_data.cell_res_min_theta or '', self.saint_data.filename.name)
+            self.saint_data.cell_res_min_theta or '', source_path(self.saint_data.filename))
         self.sources['_cell_measurement_theta_max'] = (
-            self.saint_data.cell_res_max_theta or '', self.saint_data.filename.name)
-        self.sources['_computing_data_collection'] = (saint_first_ls.aquire_software, saint_first_ls.filename.name)
-        self.sources['_computing_cell_refinement'] = (self.saint_data.version, self.saint_data.filename.name)
-        self.sources['_computing_data_reduction'] = (self.saint_data.version, self.saint_data.filename.name)
+            self.saint_data.cell_res_max_theta or '', source_path(self.saint_data.filename))
+        self.sources['_computing_data_collection'] = (saint_first_ls.aquire_software,
+                                                      source_path(saint_first_ls.filename))
+        self.sources['_computing_cell_refinement'] = (self.saint_data.version, source_path(self.saint_data.filename))
+        self.sources['_computing_data_reduction'] = (self.saint_data.version, source_path(self.saint_data.filename))
         self.sources['_exptl_absorpt_correction_type'] = abscorrtype
         self.sources['_exptl_absorpt_correction_T_min'] = abs_tmin
         self.sources['_exptl_absorpt_correction_T_max'] = abs_tmax
         self.sources['_exptl_absorpt_process_details'] = absdetails
-        self.sources['_cell_measurement_temperature'] = (temperature, self.p4p.filename.name)
-        self.sources['_diffrn_ambient_temperature'] = (temperature, self.p4p.filename.name)
-        self.sources['_exptl_crystal_colour'] = (self.p4p.crystal_color, self.p4p.filename.name)
-        self.sources['_exptl_crystal_description'] = (self.p4p.morphology, self.p4p.filename.name)
-        self.sources['_exptl_crystal_size_min'] = (self.p4p.crystal_size[0] or '', self.p4p.filename.name)
-        self.sources['_exptl_crystal_size_mid'] = (self.p4p.crystal_size[1] or '', self.p4p.filename.name)
-        self.sources['_exptl_crystal_size_max'] = (self.p4p.crystal_size[2] or '', self.p4p.filename.name)
+        self.sources['_cell_measurement_temperature'] = (temperature, source_path(self.p4p.filename))
+        self.sources['_diffrn_ambient_temperature'] = (temperature, source_path(self.p4p.filename))
+        self.sources['_exptl_crystal_colour'] = (self.p4p.crystal_color, source_path(self.p4p.filename))
+        self.sources['_exptl_crystal_description'] = (self.p4p.morphology, source_path(self.p4p.filename))
+        self.sources['_exptl_crystal_size_min'] = (self.p4p.crystal_size[0] or '', source_path(self.p4p.filename))
+        self.sources['_exptl_crystal_size_mid'] = (self.p4p.crystal_size[1] or '', source_path(self.p4p.filename))
+        self.sources['_exptl_crystal_size_max'] = (self.p4p.crystal_size[2] or '', source_path(self.p4p.filename))
         self.sources['_computing_structure_solution'] = solution_program
         self.sources['_atom_sites_solution_primary'] = (sol.method, 'Inherited from solution program.')
         self.sources['_diffrn_source_voltage'] = (kilovolt or '', frame_name)
@@ -196,19 +212,81 @@ class BrukerData(WorkDataMixin):
         if self.saint_data.is_twin and self.saint_data.components_firstsample == 2:
             with suppress(Exception):
                 law = self.saint_data.twinlaw[next(iter(self.saint_data.twinlaw.keys()))]
-                self.sources['_twin_individual_twin_matrix_11'] = (str(law[0][1]), self.saint_data.filename.name)
-                self.sources['_twin_individual_twin_matrix_12'] = (str(law[0][2]), self.saint_data.filename.name)
-                self.sources['_twin_individual_twin_matrix_13'] = (str(law[0][0]), self.saint_data.filename.name)
-                self.sources['_twin_individual_twin_matrix_21'] = (str(law[1][1]), self.saint_data.filename.name)
-                self.sources['_twin_individual_twin_matrix_22'] = (str(law[1][2]), self.saint_data.filename.name)
-                self.sources['_twin_individual_twin_matrix_23'] = (str(law[1][0]), self.saint_data.filename.name)
-                self.sources['_twin_individual_twin_matrix_31'] = (str(law[2][1]), self.saint_data.filename.name)
-                self.sources['_twin_individual_twin_matrix_32'] = (str(law[2][2]), self.saint_data.filename.name)
-                self.sources['_twin_individual_twin_matrix_33'] = (str(law[2][0]), self.saint_data.filename.name)
+                saint_file = source_path(self.saint_data.filename)
+                self.sources['_twin_individual_twin_matrix_11'] = (str(law[0][1]), saint_file)
+                self.sources['_twin_individual_twin_matrix_12'] = (str(law[0][2]), saint_file)
+                self.sources['_twin_individual_twin_matrix_13'] = (str(law[0][0]), saint_file)
+                self.sources['_twin_individual_twin_matrix_21'] = (str(law[1][1]), saint_file)
+                self.sources['_twin_individual_twin_matrix_22'] = (str(law[1][2]), saint_file)
+                self.sources['_twin_individual_twin_matrix_23'] = (str(law[1][0]), saint_file)
+                self.sources['_twin_individual_twin_matrix_31'] = (str(law[2][1]), saint_file)
+                self.sources['_twin_individual_twin_matrix_32'] = (str(law[2][2]), saint_file)
+                self.sources['_twin_individual_twin_matrix_33'] = (str(law[2][0]), saint_file)
                 self.sources['_twin_individual_id'] = (
-                    str(self.saint_data.components_firstsample), self.saint_data.filename.name)
+                    str(self.saint_data.components_firstsample), saint_file)
                 self.sources['_twin_special_details'] = (
-                    'The data was integrated as a 2-component twin.', self.saint_data.filename.name)
+                    'The data was integrated as a 2-component twin.', saint_file)
+
+    def _add_reflection_data(self, sadabs: Sadabs) -> None:
+        """
+        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.
+        """
+        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.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'})
+
+    def _rint_source(self, dataset, sadabs: Sadabs) -> str:
+        if dataset.rint:
+            return source_path(sadabs.filename)
+        return f'calculated from {source_path(self.cif.fileobj)}'
+
+    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.
+        """
+        if self.cif.hklf_number != 4:
+            return None
+        if 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())
+
+    def _resolution_limits(self) -> tuple[float, float] | None:
+        """The resolution limits of a SHELX SHEL instruction, if there is one."""
+        shel = getattr(self.cif.shx, 'shel', None)
+        if not shel:
+            return None
+        with suppress(AttributeError, TypeError):
+            return float(shel.lowres), float(shel.highres)
+        return None
+
+    @property
+    def _hkl_basename(self) -> str:
+        return self.cif.fileobj.stem.replace('-finalcif', '')
+
+    def _reflections_in_hkl_file(self) -> int | None:
+        """
+        The number of reflections in the hkl file of this refinement, without the terminating
+        0 0 0 reflection and the SADABS/TWINABS footer.
+        """
+        hkl = self.cif.hkl_file_without_foot
+        if not hkl:
+            return None
+        lines = [x for x in hkl.splitlines(keepends=False) if x.strip()]
+        return len(lines) - 1 if lines else None
 
     @property
     def sadabs(self):

{finalcif-172 → finalcif-173}/finalcif/datafiles/data.py

@@ -13,6 +13,8 @@ class WorkDataMixin:
     """
 
     def __init__(self):
+        # Keys whose source value replaces an already existing (wrong) value in the CIF:
+        self.overrides: set[str] = set()
         self.sources = {'_atom_sites_solution_primary'           : None,
                         '_cell_measurement_reflns_used'          : None,
                         '_cell_measurement_temperature'          : None,
@@ -27,6 +29,7 @@ class WorkDataMixin:
                         '_database_code_depnum_ccdc_archive'     : None,
                         '_diffrn_ambient_temperature'            : None,
                         '_diffrn_reflns_av_R_equivalents'        : None,
+                        '_diffrn_reflns_number'                  : None,
                         '_diffrn_source_voltage'                 : None,
                         '_diffrn_source_current'                 : None,
                         '_exptl_absorpt_correction_type'         : None,