fix(GH2): Avoid getting wrong data sources or including control devices' sources.

Description

This addresses this issue on sorting receiver names that can match the wrong receiver with the wrong DA.

Two issues are addressed here:

• Remove unneeded sort
• Add daqOutput to the receiver names by default to avoid getting ctrl device sources

receiver_template = "RECEIVER{}"
receiver_affixes = [""]
control_template = "CONTROL"

run_dc.select(receiver_names).all_sources
> frozenset({'SPB_50UM_GH2/DET/RECEIVER', 'SPB_50UM_GH2/DET/RECEIVER:daqOutput'})

run_dc.select('SPB_50UM_GH2/DET/RECEIVER').files

> [FileAccess('/gpfs/exfel/exp/SPB/202431/p900463/raw/r0053/RAW-R0053-GH2CTRL00-S00001.h5'),
 FileAccess('/gpfs/exfel/exp/SPB/202431/p900463/raw/r0053/RAW-R0053-GH2CTRL00-S00000.h5')]

Adding daqOutput will lead to removing error prone requirement in adding daqOutput for reciever names

e.g.

  SA2_XTD6_HIREX:
    detector-type: Gotthard2
    karabo-da:
    - GH200/1
    - GH200/2
    receiver-affixes:
    - _MASTER:daqOutput
    - _SLAVE:daqOutput
    receiver-template: GOTTHARD2{}
    control-template: GOTTHARD2_CTRL

  SPB_50UM_GH2:
    detector-type: Gotthard2
    karabo-da:
    - GH201
    receiver-affixes:
    - :daqOutput

How Has This Been Tested?

Relevant Documents (optional)

The report with the failed dark

Types of changes

• Bug fix (non-breaking change which fixes an issue)

Checklist:

• Update calibration configurations while deploying.

Reviewers

@schmidtp @kluyvert

tests/test_reference_runs/test_pre_deployment.py

@@ -71,6 +71,54 @@ def iter_sized_chunks(ds: h5py.Dataset, chunk_size: int):
         yield slice(start, start + chunk_l)
 
 
+def equal_data(ref, test, dtype):
+    """Compare arrays based on their dtype."""
+    if (
+        np.issubdtype(dtype, np.floating) or
+        np.issubdtype(dtype, np.complexfloating)
+    ):
+        return np.allclose(ref, test, equal_nan=True)
+    else:
+        return np.array_equal(ref, test)
+
+
+def handle_differences(ref_chunk, out_chunk, ref_ds, out_ds):
+    changes = []
+    dsname = ref_ds.name
+    if out_ds.dtype.names:
+        # Handle compound datasets
+        field_differences = []
+        for field in out_ds.dtype.names:
+            ref_field_chunk = ref_chunk[field]
+            out_field_chunk = out_chunk[field]
+            if not equal_data(
+                ref_field_chunk, out_field_chunk, ref_field_chunk.dtype):
+                field_differences.append(field)
+
+        if field_differences:
+            if ref_ds.size == 1:
+                # If just 1 entry, show the values for all differing fields
+                for field in field_differences:
+                    r, o = np.squeeze(
+                        ref_chunk[field]), np.squeeze(out_chunk[field])
+                    changes.append((
+                        dsname, f"Field '{field}' Value: {r} -> {o}"))
+            else:
+                changes.append((
+                    dsname, f"Fields changed: {', '.join(field_differences)}"))
+
+    else:
+        if not equal_data(ref_chunk, out_chunk, ref_ds.dtype):
+            # If just 1 entry, show the values
+            if ref_ds.size == 1:
+                r, o = np.squeeze(ref_chunk), np.squeeze(out_chunk)
+                changes.append((ref_ds.name, f"Value: {r} -> {o}"))
+            else:
+                changes.append((ref_ds.name, "Data changed"))
+
+    return changes
+
+
 def validate_file(
     ref_folder: pathlib.PosixPath,
     out_folder: pathlib.PosixPath,
@@ -95,25 +143,15 @@ def validate_file(
                     dsname, f"Dtype: {ref_ds.dtype} -> {out_ds.dtype}"
                 ))
             else:
-                floaty = np.issubdtype(ref_ds.dtype, np.floating) \
-                        or np.issubdtype(ref_ds.dtype, np.complexfloating)
-
                 # Compare data incrementally rather than loading it all at once;
                 # read in blocks of ~64 MB (arbitrary limit) along first axis.
                 for chunk_slice in iter_sized_chunks(ref_ds, 64 * 1024 * 1024):
                     ref_chunk = ref_ds[chunk_slice]
                     out_chunk = out_ds[chunk_slice]
-                    if floaty:
-                        eq = np.allclose(ref_chunk, out_chunk, equal_nan=True)
-                    else:
-                        eq = np.array_equal(ref_chunk, out_chunk)
-                    if not eq:
-                        # If just 1 entry, show the values
-                        if ref_ds.size == 1:
-                            r, o = np.squeeze(ref_chunk), np.squeeze(out_chunk)
-                            changed.append((dsname, f"Value: {r} -> {o}"))
-                        else:
-                            changed.append((dsname, "Data changed"))
+                    differences =  handle_differences(
+                        ref_chunk, out_chunk, ref_ds, out_ds)
+                    changed += differences
+                    if differences:
                         break
 
     return ComparisonResult(