provenance/generation_code/p04_phase/scene.py

"""PcGpuAssemblyScene — insert a graphics card into the PC's PCIe slot.

The same gaming-PC case as `pc_motherboard` lies on its side on the table, opening up, motherboard
facing the ceiling — but here the board's PCIe area is the work site. Beside the case lies a loose
RTX 2060 (extracted from the PC model as its own rigid body, backplate down). Goal (carried here,
no task layer): stand the card upright over the primary x16 slot, line its PCB edge up with the
slot, and press it straight down until it seats.

The case is one kinematic body that never moves — the PC model stays visual-only; its physics is
an invisible fixture inside the case body: a channel whose walls grip the card's 4 mm PCB tab at
0.15 mm/side (flaring to a 1.2 mm/side funnel mouth — idealizing the real slot's spring
contacts, and capping the unscrewed card's gravity roll at ~2 deg), a floor whose top is the
model's own seated tab height, end stops (~1.6 mm play), a flush board plate so a dropped card
rests on the board face, and a REAR I/O PANEL frame around the expansion-slot cutout — so the
card must be placed inside the case, slid rearward until its bracket/ports pass through the
opening, and only then pressed down (a straight vertical drop is physically blocked by the
panel above the cutout, exactly like a real build). The card's origin is its
PCB-tab bottom CENTRE with axes equal to the case's, so the seated pose is just `seat_pos` +
identity orientation in the case frame, and insertion depth is a z difference.

Heavy imports (isaaclab, pxr) are deferred so importing this module stays app-free.
"""

from __future__ import annotations

import math
from dataclasses import dataclass
from pathlib import Path
from robobench.core.assets import asset_path
from typing import TYPE_CHECKING, Any, ClassVar

import torch

from robobench.core import GraspWeldContract, SCENES, BaseCfg, BaseScene, SimCfg

if TYPE_CHECKING:
    from isaaclab.assets import RigidObject

    from robobench.core import BaseEnv


@dataclass
class PcGpuAssemblySceneCfg(BaseCfg):
    """Config for `PcGpuAssemblyScene`. Nothing is locked — a variant is just a copy with a few
    fields changed."""

    # --- the curriculum / difficulty dials -----------------------------------------------
    # The card is "seated" when — in the case's frame — its tab is >= `seat_depth` below the slot
    # mouth, its origin is within `align_xy` of the seated point, and its axes are within
    # `align_axis_deg` (tilt) / `align_yaw_deg` (heading along the slot) of the case's. The full
    # stroke from the slot mouth to the channel floor is 5 mm, so 4 mm separates "seated" from
    # "merely resting in the mouth".
    seat_depth: float = 0.004  # min tab depth below the slot mouth (m) to count as seated
    align_xy: float = 0.003  # max distance (m) of the card origin from the seated point
    align_axis_deg: float = 3.0  # max tilt of the card's up axis off the slot axis (deg)
    align_yaw_deg: float = 3.0  # max heading error of the card's length axis (deg)
    reset_pos_jitter: float = 0.01  # uniform +/- xy jitter for the loose card at reset (m)
    # Part friction (static = dynamic), set on every shape at bind. The moving card runs moderately
    # slick against a grippier fixed case, so it slides down the channel but holds seat.
    card_friction: float = 0.3
    case_friction: float = 0.75
    # Weld-on-closure grasping (the benchmark's auto-weld contract, PhysX
    # form — the grasp-weld machinery at the end of this scene class):
    # close the fingers squarely across the card's body slab near its top edge and the card welds
    # to the hand; open wide to release. Gripper envs only (no-op under robot="null").
    grasp_weld: bool = True
    grasp_weld_dist: float = 0.010  # pinch-point-to-grip-band engage radius (m)

    pilot_jitter_x: float = 0.004
    pilot_jitter_y: float = 0.0007

    # --- structure, reset layout, masses, asset paths (fixed) -------------------------------
    # Seated card origin (its PCB-tab bottom centre) in the case's local frame; orientation seated
    # = the case's own axes (identity). Baked into the committed USDs (keep in sync if they change).
    seat_pos: tuple[float, float, float] = (-0.01595, 0.0293, 0.0035)
    slot_mouth_z: float = 0.0085  # slot top in the case frame: depth datum (5 mm at full seat)
    board_top: float = 0.0  # board face height in the case frame (the asset's own origin)
    case_lift: float = 0.0289  # board face above the side panel the case lies on
    card_mass: float = 1.0  # dual-fan RTX 2060 (kg)
    light_intensity: float = 2500.0
    # Loose card start pose: lying backplate-down on the table beside the case (+x side; the case
    # spans x < 0.13 and the lying card's tail reaches origin_x - 0.132).
    card_init_xy: tuple[float, float] = (0.28, 0.0)  # card start xy (table-rel.)
    card_init_z: float = 0.0022  # origin height lying backplate-down (backplate plane -2 mm)
    card_init_quat: tuple[float, float, float, float] = (0.70711, 0.70711, 0.0, 0.0)  # flat
    card_contact_offset: float = 0.0001  # well below the 0.15 mm/side channel grip
    case_contact_offset: float = 0.0001  # ditto for the slot fixture's walls
    # Optional foam holder (a floor pad + two rails flanking the card's 36 mm body slab) that
    # presents the card UPRIGHT for a parallel-jaw grasp. The lying default is ungraspable by a
    # Franka gripper: flat on its backplate the card's only sub-80 mm dimension (the 36 mm body
    # thickness) points UP, so no top-down or side pinch can straddle it. Enable together with an
    # upright `card_init_quat` (identity = the seated orientation) and `card_init_z` = the
    # holder's floor top; the rails cap the free card's lean at ~3 deg and the pick pulls
    # straight up out of them.
    card_stand: bool = False
    card_stand_gap: float = 0.0025  # rail clearance per side around the body slab (m)
    # Selectable work surface (same presets as the sibling scenes).
    table: str = "lab_table"  # which work surface: "lab_table" | "packing"
    surface_z: float | None = None  # table-top height (m); None -> the preset's
    workbench_pos: tuple[float, float] | None = None  # xy the table sits at; None -> preset
    workbench_usd: str = ""  # empty -> the preset's vendored USD
    TABLES: ClassVar[dict[str, dict[str, Any]]] = {
        "lab_table": {"usd": ("lab_table", "table_instanceable.usd"), "scale": 1.0,
                      "orient": (0.70711, 0.0, 0.0, 0.70711), "surface_z": 0.0, "pos": (0.5, 0.0),
                      "top_offset": 0.0, "height": 1.05, "kinematic": False},
        "packing": {"usd": ("packing_table", "SM_HeavyDutyPackingTable_C02_01_physics.usd"), "scale": 0.01,
                    "orient": (1.0, 0.0, 0.0, 0.0), "surface_z": 0.994, "pos": (0.0, 0.0),
                    "top_offset": 0.994, "height": 0.994, "kinematic": True},
    }
    # Asset USDs; empty -> the prebuilt assets committed under `assets/`.
    asset_dir: str = ""
    case_usd: str = ""
    card_usd: str = ""

    def __post_init__(self) -> None:
        assets = asset_path(Path(__file__).resolve().parents[1] / "assets")
        self.asset_dir = self.asset_dir or str(assets)
        self.case_usd = self.case_usd or str(Path(self.asset_dir) / "pc" / "pc_case_gpu_assembly_mb.usd")
        self.card_usd = self.card_usd or str(Path(self.asset_dir) / "pc" / "gpu_rtx2060.usd")
        preset = self.TABLES[self.table]
        if self.surface_z is None:
            self.surface_z = preset["surface_z"]
        if self.workbench_pos is None:
            self.workbench_pos = preset["pos"]
        self.workbench_usd = self.workbench_usd or str(assets / "props" / preset["usd"][0] / preset["usd"][1])


@SCENES.register("pc_gpu_local")
class PcGpuAssemblyScene(BaseScene):
    cfg: PcGpuAssemblySceneCfg

    # Object physics remains nominal in this pilot; L4 uses the recorded noise channel.
    PHYSICAL_PARAMS = {'card_mass': None, 'card_friction': None, 'case_friction': None}
    VISUAL_PARAMS = {'light_intensity': {'dist': 'choice', 'options': [1600., 2500., 3400.]}}
    CAMERAS = {'front': {'eye': (-.1, -1.06, 1.282), 'target': (.42, -.08, .06),
                         'focal': 16., 'bands': {
                             'eye_x': {'dist': 'uniform', 'lo': -.125, 'hi': -.075},
                             'eye_y': {'dist': 'uniform', 'lo': -1.085, 'hi': -1.035},
                             'target_x': {'dist': 'uniform', 'lo': .405, 'hi': .435}}}}

    def apply_visual_params(self, env, values):
        # Render-only light; never touches geometry, contact, or robot control.
        from pxr import UsdLux
        if 'light_intensity' in values:
            prim = env.sim.stage.GetPrimAtPath('/World/light')
            UsdLux.LightAPI(prim).GetIntensityAttr().Set(float(values['light_intensity']))

    # Card-local y extent of the body collision slab (from gpu_rtx2060.usd `/gpu/collision/body`:
    # backplate plane -2 mm, fan-shroud plane +32.8 mm around the PCB-tab-centre origin — the
    # collider is trimmed to the VISUAL shell). The stand's rails flank THESE faces — the same
    # pair a parallel-jaw grasp pinches.
    CARD_BODY_Y: ClassVar[tuple[float, float]] = (-0.002, 0.0328)

    def __init__(self, cfg: PcGpuAssemblySceneCfg | None = None) -> None:
        super().__init__(cfg or PcGpuAssemblySceneCfg())

    # ----- assets -------------------------------------------------------------------------------
    def assets(self) -> dict[str, Any]:
        """Floor, dome light, table, the PC case lying on it (kinematic, with the invisible slot
        fixture), and one loose graphics card. The card loads with the high solver-iteration count
        the snug channel needs."""
        import isaaclab.sim as sim_utils
        from isaaclab.assets import AssetBaseCfg, RigidObjectCfg

        c = self.cfg
        for usd in (c.case_usd, c.card_usd):
            if not Path(usd).is_file():
                raise FileNotFoundError(
                    f"{usd} not found — the pc-gpu assets ship with the repo under "
                    f"`suites/assembly/assets/`"
                )
        preset = c.TABLES[c.table]
        wx, wy = c.workbench_pos
        table_z = c.surface_z - preset["top_offset"]
        ground_z = c.surface_z - preset["height"]
        table_spawn = sim_utils.UsdFileCfg(usd_path=c.workbench_usd, scale=(preset["scale"],) * 3)
        if preset["kinematic"]:
            table_spawn.rigid_props = sim_utils.RigidBodyPropertiesCfg(kinematic_enabled=True)

        cx, cy = c.card_init_xy
        assets: dict[str, Any] = {
            "ground": AssetBaseCfg(
                prim_path="/World/ground",
                spawn=sim_utils.GroundPlaneCfg(usd_path=str(
                    asset_path(Path(__file__).resolve().parents[1] / "assets") / "props" / "ground" / "default_ground.usd")),
                init_state=AssetBaseCfg.InitialStateCfg(pos=(0.0, 0.0, ground_z)),
            ),
            "light": AssetBaseCfg(
                prim_path="/World/light",
                spawn=sim_utils.DomeLightCfg(intensity=c.light_intensity, color=(0.9, 0.9, 0.9)),
            ),
            "workbench": AssetBaseCfg(
                prim_path="{ENV_REGEX_NS}/Table",
                init_state=AssetBaseCfg.InitialStateCfg(pos=(wx, wy, table_z), rot=preset["orient"]),
                spawn=table_spawn,
            ),
            # The case: kinematic; the invisible fixture inside it (slot channel + rear-panel
            # cutout frame) is what the card mates with. Fixture contact offsets are set here
            # (not just authored in the asset) so the 0.15 mm/side channel grip never fights
            # speculative contacts.
            "case": RigidObjectCfg(
                prim_path="{ENV_REGEX_NS}/Case",
                spawn=sim_utils.UsdFileCfg(
                    usd_path=c.case_usd,
                    activate_contact_sensors=True,
                    collision_props=sim_utils.CollisionPropertiesCfg(
                        contact_offset=c.case_contact_offset, rest_offset=0.0
                    ),
                    rigid_props=sim_utils.RigidBodyPropertiesCfg(kinematic_enabled=True),
                ),
                init_state=RigidObjectCfg.InitialStateCfg(pos=(wx, wy, c.surface_z + c.case_lift)),
            ),
            # Card contact offset must stay well below the channel grip (0.15 mm/side) or
            # speculative contacts choke the fit.
            "card": RigidObjectCfg(
                prim_path="{ENV_REGEX_NS}/Card",
                spawn=sim_utils.UsdFileCfg(
                    usd_path=c.card_usd,
                    activate_contact_sensors=True,
                    collision_props=sim_utils.CollisionPropertiesCfg(
                        contact_offset=c.card_contact_offset, rest_offset=0.0
                    ),
                    rigid_props=sim_utils.RigidBodyPropertiesCfg(
                        solver_position_iteration_count=192,
                        solver_velocity_iteration_count=1,
                        max_depenetration_velocity=0.02,
                        linear_damping=2.0,
                        angular_damping=2.0,
                    ),
                    mass_props=sim_utils.MassPropertiesCfg(mass=c.card_mass),
                ),
                init_state=RigidObjectCfg.InitialStateCfg(
                    pos=(wx + cx, wy + cy, c.surface_z + c.card_init_z), rot=c.card_init_quat
                ),
            ),
        }
        if c.card_stand:
            # Foam holder for a gripper env: three STATIC boxes (no rigid body). The floor pad's
            # top is the card spawn height (`card_init_z` = the tab-bottom plane), the two rails
            # flank the body slab's faces at `card_stand_gap` per side. Rail tops stay 35+ mm
            # below the pick grip band, so descending open fingers never meet them.
            y0, y1 = self.CARD_BODY_Y
            mid_y = wy + cy + 0.5 * (y0 + y1)  # body-slab mid-plane (the pinch/rail centre)
            half_gap = 0.5 * (y1 - y0) + c.card_stand_gap  # rail inner face off the mid-plane
            rail_h, rail_t = 0.055, 0.008
            foam = sim_utils.PreviewSurfaceCfg(diffuse_color=(0.17, 0.17, 0.2), roughness=0.9)
            for name, size, pos in (
                ("card_stand_floor", (0.11, 0.09, c.card_init_z),
                 (wx + cx, mid_y, c.surface_z + 0.5 * c.card_init_z)),
                ("card_stand_rail_pcb", (0.11, rail_t, rail_h),
                 (wx + cx, mid_y - half_gap - 0.5 * rail_t, c.surface_z + c.card_init_z + 0.5 * rail_h)),
                ("card_stand_rail_fan", (0.11, rail_t, rail_h),
                 (wx + cx, mid_y + half_gap + 0.5 * rail_t, c.surface_z + c.card_init_z + 0.5 * rail_h)),
            ):
                assets[name] = AssetBaseCfg(
                    prim_path="{ENV_REGEX_NS}/" + "".join(p.capitalize() for p in name.split("_")),
                    spawn=sim_utils.CuboidCfg(
                        size=size,
                        collision_props=sim_utils.CollisionPropertiesCfg(
                            contact_offset=0.001, rest_offset=0.0
                        ),
                        visual_material=foam,
                    ),
                    init_state=AssetBaseCfg.InitialStateCfg(pos=pos),
                )
        # Immutable visual-only set dressing, clear of the arm/task swept volume.
        assets['pilot_parts_box'] = AssetBaseCfg(
            prim_path='{ENV_REGEX_NS}/PilotPartsBox',
            spawn=sim_utils.CuboidCfg(size=(.075, .075, .045),
                visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(.08, .35, .65), roughness=.8)),
            init_state=AssetBaseCfg.InitialStateCfg(pos=(.90, .36, c.surface_z+.0225)))
        return assets

    def sim_cfg(self) -> SimCfg:
        return SimCfg(
            dt=1.0 / 120.0,
            physx={
                "solver_type": 1,
                "bounce_threshold_velocity": 0.2,
                "friction_offset_threshold": 0.01,
                "friction_correlation_distance": 0.00625,
                "gpu_max_rigid_contact_count": 2**23,
                "gpu_max_rigid_patch_count": 2**23,
                "gpu_collision_stack_size": 2**28,
                "gpu_max_num_partitions": 1,
            },
        )

    # ----- lifecycle ----------------------------------------------------------------------------

    def __getattr__(self, name: str):
        # Legacy surface: the grasp contract's state used to live directly on the scene
        # (inline machinery era) and existing solutions read it there — forward to the
        # composed contract. `__getattr__` only fires for attributes not found normally.
        if name.startswith("_gw_") and "grasp_weld" in self.__dict__:
            return getattr(self.grasp_weld, name)
        raise AttributeError(name)

    def bind(self, env: BaseEnv) -> None:
        """Grab the case + card handles, cache env origins, and set the part frictions."""
        super().bind(env)
        self.case: RigidObject = env.iscene["case"]
        self.card: RigidObject = env.iscene["card"]
        self.env_origins = env.iscene.env_origins
        self._set_friction(self.case, self.cfg.case_friction)
        self._set_friction(self.card, self.cfg.card_friction)
        self.grasp_weld = GraspWeldContract(self)  # composed, publishes self.grasp_held
        self.grasp_weld.bind()

    def grasp_sites(self) -> list:
        """One grip band: across the body slab (faces at CARD_BODY_Y, 34.8 mm wide), along the
        card's upper length — band centre 15 mm below the shroud's top edge (z 0.1155)."""
        y = 0.5 * (self.CARD_BODY_Y[0] + self.CARD_BODY_Y[1])
        return [("card", self.card, (-0.045, y, 0.1005), (0.045, y, 0.1005), (0.030, 0.039))]

    def post_step(self, env_ids: torch.Tensor | None = None) -> None:
        """Reconcile the weld-on-closure grasp contract every physics substep."""
        self.grasp_weld.step()

    def _set_friction(self, asset, value: float) -> None:
        """Overwrite the static + dynamic friction on every shape of `asset` (across all envs)."""
        mats = asset.root_physx_view.get_material_properties()
        mats[..., 0:2] = value  # [static, dynamic, restitution]
        asset.root_physx_view.set_material_properties(mats, torch.arange(self.env.num_envs, device="cpu"))

    def reset(self, env_ids: torch.Tensor) -> None:
        """Fresh, unassembled start: the case pinned at spawn, the card lying backplate-down on
        the table beside it, with xy jitter."""
        c = self.cfg
        dev = self.env.device
        m = len(env_ids)
        origin = self.env_origins[env_ids]  # (m, 3)
        wx, wy = c.workbench_pos
        cx, cy = c.card_init_xy

        st = torch.zeros(m, 13, device=dev)
        st[:, 0:3] = origin + torch.tensor((wx + cx, wy + cy, c.surface_z + c.card_init_z), device=dev)
        st[:, 0:2] += (torch.rand(m, 2, device=dev) * 2 - 1) * c.reset_pos_jitter
        # Small in-holder variation: below rail clearance; no case/slot changes.
        st[:, :2] += (torch.rand(m, 2, device=dev)*2-1) * torch.tensor(
            [c.pilot_jitter_x, c.pilot_jitter_y], device=dev)
        st[:, 3:7] = torch.tensor(c.card_init_quat, device=dev)
        self.card.write_root_state_to_sim(st, env_ids)
        self.grasp_weld.release_all(env_ids)

    # ----- state (full, restorable) -------------------------------------------------------------
    def get_state(self, env_ids: torch.Tensor) -> dict[str, Any]:
        """Restorable scene state: world root states (13) of the case and the card, plus the
        grasp-weld holds."""
        return {
            "case": self.case.data.root_state_w[env_ids].clone(),
            "card": self.card.data.root_state_w[env_ids].clone(),
            **self.grasp_weld.state(env_ids),
        }

    def set_state(self, state: dict[str, Any], env_ids: torch.Tensor) -> None:
        """Restore what `get_state` returned. The card's insertion depth is fully captured by its
        root state, so the channel holds it on restore."""
        self.case.write_root_pose_to_sim(state["case"][:, 0:7], env_ids)
        self.card.write_root_state_to_sim(state["card"], env_ids)
        self.grasp_weld.restore(state, env_ids)

    # ----- description --------------------------------------------------------------------------
    def describe(self) -> str:
        if self.cfg.card_stand:
            card = (
                "Beside the case a loose graphics card stands upright in a foam holder, already "
                "in its installation orientation.\nGoal: grip the card by its top edge, lift it "
                "straight out of the holder, "
            )
        else:
            card = (
                "Beside the case lies a loose graphics card, backplate down.\nGoal: lift the "
                "card upright (fans toward the case front), "
            )
        return (
            "A gaming-PC case lying on its side on a sturdy table, opening up, its motherboard "
            "facing the ceiling. The board's primary PCIe x16 slot is empty, and the rear I/O "
            f"panel has an open expansion-slot cutout. {card}"
            "lower it into the case with its I/O bracket just forward of the rear panel, slide "
            "it rearward until the bracket and ports pass through the cutout, line its PCB edge "
            "connector up with the x16 slot, and press it straight down until it bottoms out. "
            "A seated card stays put on its own. The task is complete once the card is fully "
            "seated."
            + " A fixed blue parts box decorates the far corner, outside the task volume."
            + (
                " The card holds in a firm pinch: close the fingers squarely across its body "
                "slab near the top edge and the grip locks; open wide to release."
                if self.cfg.grasp_weld
                else ""
            )
        )

    # ----- progress (public: seated()/engaged(); reads how far the assembly has got) -------------
    def engaged(self) -> torch.Tensor:
        """Tab depth below the slot mouth, shape (num_envs,), in metres (negative = still above
        the slot). The card bottoms out on the channel floor at 0.005 depth."""
        rel = self._card_offset_in_case()  # (n, 3), zero at the seated pose
        return (self.cfg.slot_mouth_z - self.cfg.seat_pos[2]) - rel[:, 2]

    def seated(self) -> torch.Tensor:
        """Whether the card is seated in the slot, shape (num_envs,): pressed down to `seat_depth`
        below the mouth, within `align_xy` of the seated point, and aligned in tilt AND heading."""
        c = self.cfg
        rel = self._card_offset_in_case()  # (n, 3)
        depth_ok = self.engaged() >= c.seat_depth
        xy_ok = rel[:, :2].norm(dim=-1) <= c.align_xy
        up_ok = self._axis_cos(2) >= math.cos(math.radians(c.align_axis_deg))
        yaw_ok = self._axis_cos(0) >= math.cos(math.radians(c.align_yaw_deg))
        return depth_ok & xy_ok & up_ok & yaw_ok

    def success(self) -> torch.Tensor:
        """(N,) bool: the card seated in its slot — this scene's assembled state
        (scene-level success alias, matching the other suites' surface)."""
        return self.seated()

    def _card_offset_in_case(self) -> torch.Tensor:
        """The card origin's offset from the seated point, in the case's local frame, shape
        (num_envs, 3). Zero means the card origin sits exactly at the seated pose."""
        from isaaclab.utils.math import quat_apply_inverse

        rel = quat_apply_inverse(
            self.case.data.root_quat_w, self.card.data.root_pos_w - self.case.data.root_pos_w
        )
        return rel - torch.tensor(self.cfg.seat_pos, device=rel.device)

    def _axis_cos(self, axis: int) -> torch.Tensor:
        """cos of the angle between the card's and the case's local `axis` (0=x: heading along the
        slot, 2=z: insertion axis), shape (num_envs,). Seated orientation = the case's own axes."""
        from isaaclab.utils.math import quat_apply

        e = torch.zeros(3, device=self.env.device)
        e[axis] = 1.0
        e = e.expand(self.env.num_envs, 3)
        case_ax = quat_apply(self.case.data.root_quat_w, e)
        card_ax = quat_apply(self.card.data.root_quat_w, e)
        return (card_ax * case_ax).sum(dim=-1)

    # Grasp-weld contract: composed `GraspWeldContract` (robobench.core.grasp_weld),
    # created in `bind()`; this scene supplies the part-side `grasp_sites()`.
    # Grasp-weld contract constants — the scene's public knobs (solutions read these off the
    # scene, e.g. `scene.GRASP_PINCH_OFFSET`); the composed GraspWeldContract consumes them.
    GRASP_HAND_BODY: ClassVar[str] = "panda_hand"
    GRASP_FINGER_JOINTS: ClassVar[str] = "panda_finger_joint.*"
    GRASP_PINCH_OFFSET: ClassVar[float] = 0.1034  # hand origin -> finger-pad centre, along approach
    GRASP_POOL: ClassVar[int] = 8  # engages per (env, site) per run; exhausted -> warn, no weld
    GRASP_STALL: ClassVar[float] = 0.01  # max |finger vel| sum (m/s): fingers stopped ON the part
    GRASP_DEBOUNCE: ClassVar[int] = 8  # consecutive qualifying substeps before the weld engages
    GRASP_RELEASE_MARGIN: ClassVar[float] = 0.008  # release at window-top + this (m), hysteresis