some fixes

python_app/workflows/multi_radar_capture_workflow.py

@@ -19,6 +19,7 @@ from python_app.workflows.radar_config_variants import RadarConfigVariant
 from python_app.workflows.sequential_capture_workflow import (
     MATRIX_RADAR_MANUAL_CAPTURE_KINDS,
     SequentialCaptureState,
+    acquire_matrix_combo_collection,
     combine_collections_via_median,
     combine_traces_via_median,
     select_trace_for_combo,
@@ -192,20 +193,27 @@ class MultiRadarSequentialCaptureSession:
                 self._radar.configure(variant.config.radar.sweep)
                 if self._base_config.runtime.settling_ms > 0:
                     time.sleep(self._base_config.runtime.settling_ms / 1000.0)
-                collections: list[SweepCollection] = []
-                for _ in range(self._median_sweep_count):
-                    collection = self._radar.acquire_collection(collection_id=1)
-                    if not collection.traces:
-                        raise RuntimeError(
-                            f"Matrix radar variant {variant.display_name} returned no traces"
-                        )
-                    collections.append(collection)
                 if self._manual_matrix_radar_capture:
-                    per_sweep_traces = [select_trace_for_combo(collection, combo) for collection in collections]
+                    # Only this combo is kept, so acquire the smallest collection
+                    # that contains it instead of the full (switch-widened) matrix.
+                    per_sweep_traces = [
+                        select_trace_for_combo(
+                            acquire_matrix_combo_collection(self._radar, combo), combo
+                        )
+                        for _ in range(self._median_sweep_count)
+                    ]
                     trace = combine_traces_via_median(per_sweep_traces)
                     pending_traces_by_radar_key[variant.radar_key] = [trace]
                     display_traces.append(trace)
                 else:
+                    collections: list[SweepCollection] = []
+                    for _ in range(self._median_sweep_count):
+                        collection = self._radar.acquire_collection(collection_id=1)
+                        if not collection.traces:
+                            raise RuntimeError(
+                                f"Matrix radar variant {variant.display_name} returned no traces"
+                            )
+                        collections.append(collection)
                     combined_collection = combine_collections_via_median(collections)
                     pending_traces_by_radar_key[variant.radar_key] = list(combined_collection.traces)
                     display_traces.append(combined_collection.traces[-1])

python_app/workflows/sequential_capture_workflow.py

@@ -156,20 +156,27 @@ class SequentialCaptureSession:
             raise RuntimeError("Capture session is already complete")
 
         if self._is_matrix_radar:
-            collections: list[SweepCollection] = []
-            for _ in range(self._median_sweep_count):
-                collection = self._radar.acquire_collection(collection_id=1)
-                if not collection.traces:
-                    raise RuntimeError("Matrix radar capture returned no traces")
-                collections.append(collection)
             if self._manual_matrix_radar_capture:
-                per_sweep_traces = [select_trace_for_combo(collection, combo) for collection in collections]
+                # Only this combo is kept, so acquire the smallest collection that
+                # contains it instead of the full (switch-widened) matrix.
+                per_sweep_traces = [
+                    select_trace_for_combo(
+                        acquire_matrix_combo_collection(self._radar, combo), combo
+                    )
+                    for _ in range(self._median_sweep_count)
+                ]
                 trace = combine_traces_via_median(per_sweep_traces)
                 self._traces.append(trace)
                 self._next_index += 1
                 logger.debug("Captured matrix combo input=%d output=%d", combo.input, combo.output)
                 return trace
 
+            collections: list[SweepCollection] = []
+            for _ in range(self._median_sweep_count):
+                collection = self._radar.acquire_collection(collection_id=1)
+                if not collection.traces:
+                    raise RuntimeError("Matrix radar capture returned no traces")
+                collections.append(collection)
             combined_collection = combine_collections_via_median(collections)
             self._traces.extend(combined_collection.traces)
             self._next_index = len(self._combos)
@@ -301,6 +308,32 @@ class SequentialCaptureSession:
         return self._combos[self._next_index]
 
 
+def acquire_matrix_combo_collection(
+    radar: MatrixRadarService,
+    combo: ComboModel,
+    collection_id: int = 1,
+) -> SweepCollection:
+    """Acquire the smallest matrix collection that contains one combo.
+
+    A switch-widened matrix radar (``SwitchedMatrixRadarService``) can acquire just
+    the physical switch step carrying the combo, which is several times faster than
+    the full matrix and keeps the per-combo capture UI responsive. Plain matrix
+    radars expose only full-matrix acquisition, so they fall back to it.
+    """
+    acquire_combo = getattr(radar, "acquire_combo_collection", None)
+    if callable(acquire_combo):
+        collection = acquire_combo(
+            input_pos=int(combo.input),
+            output_pos=int(combo.output),
+            collection_id=collection_id,
+        )
+    else:
+        collection = radar.acquire_collection(collection_id=collection_id)
+    if not collection.traces:
+        raise RuntimeError("Matrix radar capture returned no traces")
+    return collection
+
+
 def select_trace_for_combo(collection: SweepCollection, combo: ComboModel) -> TraceData:
     """Return the trace matching a virtual combo from a full multi-device capture."""
     for trace in collection.traces: