Metrics

KernelFidelityMetrics dataclass

KernelFidelityMetrics(
    gate_fidelities: list[float],
    gate_fidelity_product: float,
)

Fidelity metrics computed from a physical noisy SQuin kernel.

KernelMoveMetrics dataclass

KernelMoveMetrics(
    approx_lane_parallelism: float, moved_lane_count: int
)

Move metadata computed from a compiled Move kernel.

KernelMoveTimeMetrics dataclass

KernelMoveTimeMetrics(
    total_move_time_us: float,
    events: list[MoveTimeEvent],
    timing_model: str,
)

Move timing metrics computed from a compiled Move kernel.

Metrics dataclass

Metrics(
    arch_spec: Any,
    noise_model: LogicalNoiseModelABC | None = None,
)

Unified metrics computation for the lanes pipeline.

Owns kernel-level analysis methods and delegates all move-metric computation (lane durations, costs, distances) to a MoveMetricCalculator instance.

analyze_per_cz_motion

analyze_per_cz_motion(
    move_mt: Method,
) -> tuple[float, float]

Average hops and traveled distance per moving qubit per CZ episode.

Source code in .venv/lib/python3.12/site-packages/bloqade/lanes/metrics.py

def analyze_per_cz_motion(
    self,
    move_mt: ir.Method,
) -> tuple[float, float]:
    """Average hops and traveled distance per moving qubit per CZ episode."""
    initial_layout = _infer_initial_qubit_layout(move_mt)
    if initial_layout is None or len(initial_layout) == 0:
        return 0.0, 0.0

    qubit_by_location = {
        location: qubit_id for qubit_id, location in initial_layout.items()
    }

    per_cz_hops: list[float] = []
    per_cz_distance_um: list[float] = []
    episode_stats: dict[int, tuple[int, float]] = {}

    for stmt in move_mt.callable_region.walk():
        if isinstance(stmt, move.Move):
            for lane in stmt.lanes:
                src, dst = self.arch_spec.get_endpoints(lane)
                qubit_id = qubit_by_location.pop(src, None)
                if qubit_id is None:
                    continue
                qubit_by_location[dst] = qubit_id
                hop_count, distance_um = episode_stats.get(qubit_id, (0, 0.0))
                episode_stats[qubit_id] = (
                    hop_count + 1,
                    distance_um + self.move_calc.lane_distance_um(lane),
                )
            continue

        if isinstance(stmt, move.CZ):
            if len(episode_stats) > 0:
                for hop_count, distance_um in episode_stats.values():
                    per_cz_hops.append(float(hop_count))
                    per_cz_distance_um.append(distance_um)
            episode_stats = {}

    if len(per_cz_hops) == 0:
        return 0.0, 0.0
    return (
        sum(per_cz_hops) / len(per_cz_hops),
        sum(per_cz_distance_um) / len(per_cz_distance_um),
    )

MoveTimeEvent dataclass

MoveTimeEvent(
    event_index: int,
    lane_count: int,
    move_type: str,
    bus_id: int,
    direction: str,
    lane_durations_us: list[float],
    event_duration_us: float,
    segment_distances_um: list[float],
    segment_durations_us: list[float],
    pick_time_us: float,
    drop_time_us: float,
    timing_model: str,
)

Per-move event timing details in microseconds.