opentrons 8.7.0a9__py3-none-any.whl → 8.8.0a8__py3-none-any.whl

opentrons/protocol_engine/state/geometry.py

@@ -24,6 +24,7 @@ from opentrons_shared_data.labware.constants import WELL_NAME_PATTERN
 from opentrons_shared_data.labware.labware_definition import (
     LabwareDefinition,
     LabwareDefinition2,
+    LabwareDefinition3,
     InnerWellGeometry,
 )
 from opentrons_shared_data.deck.types import CutoutFixture
@@ -44,7 +45,6 @@ from ..errors.exceptions import (
 )
 from ..resources import (
     fixture_validation,
-    labware_validation,
     deck_configuration_provider,
 )
 from ..types import (
@@ -63,13 +63,13 @@ from ..types import (
     ModuleLocation,
     OnLabwareLocation,
     LabwareLocation,
-    LabwareOffsetVector,
     ModuleOffsetData,
     CurrentWell,
     CurrentPipetteLocation,
     TipGeometry,
-    LabwareMovementOffsetData,
     InStackerHopperLocation,
+    WASTE_CHUTE_LOCATION,
+    AccessibleByGripperLocation,
     OnDeckLabwareLocation,
     AddressableAreaLocation,
     AddressableOffsetVector,
@@ -91,7 +91,7 @@ from ..types import (
     labware_location_is_system,
     WellLocationType,
     WellLocationFunction,
-    LabwareParentDefinition,
+    GripperMoveType,
     AddressableArea,
 )
 from ..types.liquid_level_detection import SimulatedProbeResult, LiquidTrackingType
@@ -108,8 +108,11 @@ from .inner_well_math_utils import (
     find_volume_user_defined_volumes,
 )
 from ._well_math import wells_covered_by_pipette_configuration, nozzles_per_well
-from ._labware_origin_math import get_parent_placement_origin_to_lw_origin
-
+from .labware_origin_math.stackup_origin_to_labware_origin import (
+    get_stackup_origin_to_labware_origin,
+    LabwareOriginContext,
+    LabwareStackupAncestorDefinition,
+)
 
 _LOG = getLogger(__name__)
 SLOT_WIDTH = 128
@@ -125,13 +128,6 @@ class _TipDropSection(enum.Enum):
     RIGHT = "right"
 
 
-class _GripperMoveType(enum.Enum):
-    """Types of gripper movement."""
-
-    PICK_UP_LABWARE = enum.auto()
-    DROP_LABWARE = enum.auto()
-
-
 @dataclass
 class _AbsoluteRobotExtents:
     front_left: Dict[MountType, Point]
@@ -204,6 +200,7 @@ class GeometryView:
             if isinstance(loc, InStackerHopperLocation) or isinstance(
                 loc, NotOnDeckLocationSequenceComponent
             ):
+
                 return False
         return True
 
@@ -402,6 +399,11 @@ class GeometryView:
                 "Labware does not have a slot or module associated with it"
                 " since it is no longer on the deck."
             )
+        elif location == WASTE_CHUTE_LOCATION:
+            raise errors.LabwareNotOnDeckError(
+                "Labware does not have a slot or module associated with it"
+                " since it is in the waste chute."
+            )
 
     def get_labware_origin_position(self, labware_id: str) -> Point:
         """Get the deck coordinates of a labware's origin.
@@ -410,145 +412,117 @@ class GeometryView:
         """
         location = self._labware.get(labware_id).location
         definition = self._labware.get_definition(labware_id)
+        aa_name = self._get_underlying_addressable_area_name(location)
+        # TODO(jh, 08-18-25): Labware locations return the underlying slot as the "on location" for the fixed trash,
+        #  but the underlying slot's name does not exist in addressable area state. Getting the addressable area from data is
+        #  a workaround. Investigate further.
+        addressable_area = self._addressable_areas._get_addressable_area_from_deck_data(
+            aa_name, do_compatibility_check=False
+        )
+        stackup_lw_defs_locs = self._get_stackup_lw_info_top_to_bottom(
+            labware_definition=definition, location=location
+        )
+        underlying_ancestor_def = self._get_stackup_underlying_ancestor_definition(
+            location
+        )
+        module_parent_to_child_offset = self._get_stackup_module_parent_to_child_offset(
+            location
+        )
 
-        slot_front_left = self._get_labware_ancestor_position(labware_id)
-        stackup_origin_to_lw_origin = self._get_stackup_placement_origin_to_lw_origin(
-            location=location, definition=definition, is_topmost_labware=True
+        slot_front_left = self._addressable_areas.get_addressable_area_position(aa_name)
+        stackup_origin_to_lw_origin = get_stackup_origin_to_labware_origin(
+            context=LabwareOriginContext.PIPETTING,
+            stackup_lw_info_top_to_bottom=stackup_lw_defs_locs,
+            underlying_ancestor_definition=underlying_ancestor_def,
+            module_parent_to_child_offset=module_parent_to_child_offset,
+            deck_definition=self._addressable_areas.deck_definition,
+            slot_name=addressable_area.base_slot,
         )
         module_cal_offset = self._get_calibrated_module_offset(location)
 
         return slot_front_left + stackup_origin_to_lw_origin + module_cal_offset
 
-    def _get_labware_ancestor_position(self, labware_id: str) -> Point:
-        """Get the position of the labware's underlying ancestor."""
-        slot_name = self._get_underlying_addressable_area_name(
-            self._labware.get(labware_id).location
-        )
-        parent_pos = self._addressable_areas.get_addressable_area_position(slot_name)
+    def _get_stackup_lw_info_top_to_bottom(
+        self, labware_definition: LabwareDefinition, location: LabwareLocation
+    ) -> list[tuple[LabwareDefinition, LabwareLocation]]:
+        """Returns info about each labware in the stackup.
 
-        return parent_pos
-
-    def _get_stackup_placement_origin_to_lw_origin(
-        self,
-        location: LabwareLocation,
-        definition: LabwareDefinition,
-        is_topmost_labware: bool,
-    ) -> Point:
-        """Get the offset vector from the lowest entity in a stackup to the labware."""
-        if isinstance(
-            location, (AddressableAreaLocation, DeckSlotLocation, ModuleLocation)
-        ):
-            return self._get_parent_placement_origin_to_lw_origin(
-                labware_location=location,
-                labware_definition=definition,
-                is_topmost_labware=is_topmost_labware,
-            )
-        elif isinstance(location, OnLabwareLocation):
-            parent_id = location.labwareId
-            parent_location = self._labware.get(parent_id).location
-            parent_definition = self._labware.get_definition(parent_id)
-
-            parent_placement_origin_to_lw_origin = (
-                self._get_parent_placement_origin_to_lw_origin(
-                    labware_location=location,
-                    labware_definition=definition,
-                    is_topmost_labware=is_topmost_labware,
-                )
-            )
+        The list is ordered from the top labware to the bottom-most labware.
+        The first entry will always be the definition and location of the given labware itself.
+        """
+        definitions_locations_top_to_bottom: list[
+            tuple[LabwareDefinition, LabwareLocation]
+        ] = []
+        current_location = location
+        current_definition = labware_definition
 
-            return (
-                parent_placement_origin_to_lw_origin
-                + self._get_stackup_placement_origin_to_lw_origin(
-                    location=parent_location,
-                    definition=parent_definition,
-                    is_topmost_labware=False,
-                )
-            )
-        else:
-            raise errors.LabwareNotOnDeckError(
-                "Cannot access labware since it is not on the deck. "
-                "Either it has been loaded off-deck or its been moved off-deck."
+        while True:
+            definitions_locations_top_to_bottom.append(
+                (current_definition, current_location)
             )
 
-    def _get_parent_placement_origin_to_lw_origin(
-        self,
-        labware_location: LabwareLocation,
-        labware_definition: LabwareDefinition,
-        is_topmost_labware: bool,
-    ) -> Point:
-        parent_deck_item = self._get_parent_definition(labware_location)
-
-        if isinstance(labware_location, ModuleLocation):
-            module_parent_to_child_offset = (
-                self._modules.get_nominal_offset_to_child_from_addressable_area(
-                    module_id=labware_location.moduleId,
+            if isinstance(current_location, OnLabwareLocation):
+                current_labware_id = current_location.labwareId
+                current_location = self._labware.get(current_labware_id).location
+                current_definition = self._labware.get_definition(current_labware_id)
+            else:
+                break
+        return definitions_locations_top_to_bottom
+
+    def _get_stackup_module_parent_to_child_offset(
+        self, top_most_lw_location: LabwareLocation
+    ) -> Union[Point, None]:
+        """Traverse the stackup to find the first parent-to-child module offset, if any."""
+        current_location = top_most_lw_location
+
+        while True:
+            if isinstance(current_location, ModuleLocation):
+                module_parent_to_child_offset = (
+                    self._modules.get_nominal_offset_to_child_from_addressable_area(
+                        module_id=current_location.moduleId,
+                    )
                 )
-            )
-            return get_parent_placement_origin_to_lw_origin(
-                child_labware=labware_definition,
-                parent_deck_item=parent_deck_item,  # type: ignore[arg-type]
-                module_parent_to_child_offset=module_parent_to_child_offset,
-                deck_definition=self._addressable_areas.deck_definition,
-                is_topmost_labware=is_topmost_labware,
-                labware_location=labware_location,
-            )
-        elif isinstance(labware_location, OnLabwareLocation):
-            return get_parent_placement_origin_to_lw_origin(
-                child_labware=labware_definition,
-                parent_deck_item=parent_deck_item,  # type: ignore[arg-type]
-                module_parent_to_child_offset=None,
-                deck_definition=self._addressable_areas.deck_definition,
-                is_topmost_labware=is_topmost_labware,
-                labware_location=labware_location,
-            )
-        elif isinstance(labware_location, (DeckSlotLocation, AddressableAreaLocation)):
-            return get_parent_placement_origin_to_lw_origin(
-                child_labware=labware_definition,
-                parent_deck_item=parent_deck_item,  # type: ignore[arg-type]
-                module_parent_to_child_offset=None,
-                deck_definition=self._addressable_areas.deck_definition,
-                is_topmost_labware=is_topmost_labware,
-                labware_location=labware_location,
-            )
-        else:
-            raise ValueError(f"Invalid labware location: {labware_location}")
-
-    def _get_parent_definition(
-        self, location: LabwareLocation
-    ) -> LabwareParentDefinition:
-        """Get the parent's definition given the labware's location."""
-        if isinstance(location, DeckSlotLocation):
-            addressable_area_name = location.slotName.id
-            return self._addressable_areas.get_slot_definition(addressable_area_name)
-
-        elif isinstance(location, AddressableAreaLocation):
-            addressable_area_name = location.addressableAreaName
-            return self._addressable_areas.get_addressable_area(addressable_area_name)
+                return module_parent_to_child_offset
 
-        elif isinstance(location, ModuleLocation):
-            module_id = location.moduleId
-            return self._modules.get_definition(module_id)
-
-        elif isinstance(location, OnLabwareLocation):
-            below_labware_id = location.labwareId
-            return self._labware.get_definition(below_labware_id)
+            if isinstance(current_location, OnLabwareLocation):
+                current_labware_id = current_location.labwareId
+                current_labware = self._labware.get(current_labware_id)
+                current_location = current_labware.location
+            else:
+                break
 
-        elif location == OFF_DECK_LOCATION or location == SYSTEM_LOCATION:
-            raise errors.LabwareNotOnDeckError(
-                f"Labware location {location} does not have a slot associated with it"
-                f" since it is no longer on the deck."
-            )
+        return None
 
-        elif isinstance(location, InStackerHopperLocation):
-            raise errors.LabwareNotOnDeckError(
-                "Labware does not have a slot or module associated with it"
-                " since it is no longer on the deck."
-            )
+    def _get_stackup_underlying_ancestor_definition(
+        self, top_most_lw_location: LabwareLocation
+    ) -> LabwareStackupAncestorDefinition:
+        """Traverse the stackup to find the first non-labware definition."""
+        current_location = top_most_lw_location
+        while True:
+            if isinstance(current_location, OnLabwareLocation):
+                current_labware_id = current_location.labwareId
+                current_labware = self._labware.get(current_labware_id)
+                current_location = current_labware.location
+            else:
+                if isinstance(current_location, ModuleLocation):
+                    return self._modules.get_definition(current_location.moduleId)
 
-        else:
-            raise errors.InvalidLabwarePositionError(
-                f"Cannot get ancestor from location {location}"
-            )
+                elif isinstance(current_location, AddressableAreaLocation):
+                    return self._addressable_areas.get_addressable_area(
+                        current_location.addressableAreaName
+                    )
+                elif isinstance(current_location, DeckSlotLocation):
+                    return self._addressable_areas.get_slot_definition(
+                        current_location.slotName.id
+                    )
+                elif current_location == WASTE_CHUTE_LOCATION:
+                    return self._addressable_areas.get_addressable_area(
+                        "gripperWasteChute"
+                    )
+                else:
+                    raise errors.InvalidLabwarePositionError(
+                        f"Cannot get ancestor slot of location {current_location}"
+                    )
 
     def _get_underlying_addressable_area_name(self, location: LabwareLocation) -> str:
         if isinstance(location, DeckSlotLocation):
@@ -559,6 +533,8 @@ class GeometryView:
             return self._modules.get_provided_addressable_area(location.moduleId)
         elif isinstance(location, OnLabwareLocation):
             return self.get_ancestor_addressable_area_name(location.labwareId)
+        elif location == WASTE_CHUTE_LOCATION:
+            return "gripperWasteChute"
         else:
             raise errors.InvalidLabwarePositionError(
                 f"Cannot get ancestor slot of location {location}"
@@ -661,7 +637,9 @@ class GeometryView:
         if meniscus_tracking:
             location = LiquidHandlingWellLocation(
                 origin=WellOrigin.MENISCUS,
-                offset=WellOffset(x=0, y=0, z=absolute_point.z),
+                offset=WellOffset(
+                    x=absolute_point.x, y=absolute_point.y, z=absolute_point.z
+                ),
             )
             # TODO(cm): handle operationVolume being a float other than 0
             if meniscus_tracking == MeniscusTrackingTarget.END:
@@ -717,6 +695,9 @@ class GeometryView:
         return well_def.depth
 
     def _get_highest_z_from_labware_data(self, lw_data: LoadedLabware) -> float:
+        if lw_data.location == WASTE_CHUTE_LOCATION:
+            # Returns 0 so that the waste chute height is not added to the height of the lbw
+            return 0
         labware_pos = self.get_labware_position(lw_data.id)
         z_dim = self._labware.get_dimensions(labware_id=lw_data.id).z
         height_over_labware: float = 0
@@ -776,7 +757,7 @@ class GeometryView:
 
         if well_def.shape != "circular":
             raise errors.LabwareIsNotTipRackError(
-                f"Well {well_name} in labware {labware_id} is not circular."
+                f"Well {well_name} in labware {self._labware.get_display_name(labware_id)} is not circular."
             )
 
         return TipGeometry(
@@ -867,9 +848,14 @@ class GeometryView:
                 slot_name = DeckSlotName.from_primitive(area_name)
         elif labware.location == OFF_DECK_LOCATION:
             raise errors.LabwareNotOnDeckError(
-                f"Labware {labware_id} does not have a slot associated with it"
+                f"Labware {self._labware.get_display_name(labware_id)} does not have a slot associated with it"
                 f" since it is no longer on the deck."
             )
+        elif labware.location == WASTE_CHUTE_LOCATION:
+            raise errors.LabwareNotOnDeckError(
+                f"Labware {self._labware.get_display_name(labware_id)} does not have a slot associated with it"
+                f" since it is in the waste chute."
+            )
         else:
             _LOG.error(
                 f"Unhandled location type in get_ancestor_slot_name: {labware.location}"
@@ -1055,9 +1041,9 @@ class GeometryView:
     def get_labware_grip_point(
         self,
         labware_definition: LabwareDefinition,
-        location: Union[
-            DeckSlotLocation, ModuleLocation, OnLabwareLocation, AddressableAreaLocation
-        ],
+        location: AccessibleByGripperLocation,
+        move_type: GripperMoveType,
+        user_additional_offset: Point | None,
     ) -> Point:
         """Get the grip point of the labware as placed on the given location.
 
@@ -1069,28 +1055,105 @@ class GeometryView:
         It is calculated as the xy center of the slot with z as the point indicated by
         z-position of labware bottom + grip height from labware bottom.
         """
-        grip_z_from_lw_origin = self._labware.get_grip_z(labware_definition)
-        aa_name = self._get_underlying_addressable_area_name(location)
-        parent_to_lw_offset = self._get_stackup_placement_origin_to_lw_origin(
+        mod_cal_offset = self._get_calibrated_module_offset(location)
+        user_additional_offset = user_additional_offset or Point()
+        aa_origin_to_nominal_grip_point = self._get_aa_origin_to_nominal_grip_point(
+            labware_definition=labware_definition,
             location=location,
-            definition=labware_definition,
-            is_topmost_labware=True,  # We aren't concerned with entities above the gripped labware.
+            move_type=move_type,
         )
+
+        return aa_origin_to_nominal_grip_point + mod_cal_offset + user_additional_offset
+
+    def _get_aa_origin_to_nominal_grip_point(
+        self,
+        labware_definition: LabwareDefinition,
+        location: AccessibleByGripperLocation,
+        move_type: GripperMoveType,
+    ) -> Point:
+        """Get the nominal grip point of a labware.
+
+        Does not include module calibration offsets or user additional offsets.
+        """
+        grip_z_from_lw_origin = self._labware.get_grip_z(labware_definition)
+        aa_name = self._get_underlying_addressable_area_name(location)
         addressable_area = self._addressable_areas.get_addressable_area(aa_name)
-        lw_origin_to_parent = self._get_lw_origin_to_parent(
-            labware_definition=labware_definition, addressable_area=addressable_area
+        stackup_defs_locs = self._get_stackup_lw_info_top_to_bottom(
+            labware_definition=labware_definition, location=location
+        )
+        module_parent_to_child_offset = self._get_stackup_module_parent_to_child_offset(
+            location
+        )
+        underlying_ancestor_def = self._get_stackup_underlying_ancestor_definition(
+            location
+        )
+        context_type = (
+            LabwareOriginContext.GRIPPER_PICKING_UP
+            if move_type == GripperMoveType.PICK_UP_LABWARE
+            else LabwareOriginContext.GRIPPER_DROPPING
         )
-        mod_cal_offset = self._get_calibrated_module_offset(location)
-        location_center = self._addressable_areas.get_addressable_area_center(aa_name)
 
-        return (
-            location_center
-            + parent_to_lw_offset
-            + lw_origin_to_parent
-            + mod_cal_offset
-            + Point(0, 0, grip_z_from_lw_origin)
+        aa_origin_to_lw_origin = get_stackup_origin_to_labware_origin(
+            context=context_type,
+            module_parent_to_child_offset=module_parent_to_child_offset,
+            underlying_ancestor_definition=underlying_ancestor_def,
+            stackup_lw_info_top_to_bottom=stackup_defs_locs,
+            slot_name=addressable_area.base_slot,
+            deck_definition=self._addressable_areas.deck_definition,
         )
 
+        if isinstance(labware_definition, LabwareDefinition2):
+            lw_origin_to_aa_origin = self._get_lw_origin_to_parent(
+                labware_definition=labware_definition, addressable_area=addressable_area
+            )
+            aa_origin_to_aa_center = (
+                self._addressable_areas.get_addressable_area_center(aa_name)
+            )
+            aa_center_to_nominal_grip_point = Point(0, 0, grip_z_from_lw_origin)
+
+            return (
+                aa_origin_to_lw_origin
+                + lw_origin_to_aa_origin
+                + aa_origin_to_aa_center
+                + aa_center_to_nominal_grip_point
+            )
+
+        else:
+            assert isinstance(labware_definition, LabwareDefinition3)
+
+            aa_origin = self._addressable_areas.get_addressable_area_position(aa_name)
+            lw_origin_to_lw_center = self._get_lw_origin_to_lw_center(
+                labware_definition
+            )
+            lw_origin_to_lw_grip_center = Point(
+                x=lw_origin_to_lw_center.x,
+                y=lw_origin_to_lw_center.y,
+                z=grip_z_from_lw_origin,
+            )
+
+            return aa_origin + aa_origin_to_lw_origin + lw_origin_to_lw_grip_center
+
+    def _get_lw_origin_to_lw_center(
+        self, labware_definition: LabwareDefinition
+    ) -> Point:
+        """Get the x,y,z center of the labware."""
+        if isinstance(labware_definition, LabwareDefinition2):
+            dimensions = labware_definition.dimensions
+            x = dimensions.xDimension / 2
+            y = dimensions.yDimension / 2
+            z = dimensions.zDimension / 2
+
+            return Point(x, y, z)
+        else:
+            front_right_top = labware_definition.extents.total.frontRightTop
+            back_left_bottom = labware_definition.extents.total.backLeftBottom
+
+            x = (front_right_top.x - back_left_bottom.x) / 2
+            y = (front_right_top.y - back_left_bottom.y) / 2
+            z = (front_right_top.z - back_left_bottom.z) / 2
+
+            return Point(x, y, z)
+
     def _get_lw_origin_to_parent(
         self, labware_definition: LabwareDefinition, addressable_area: AddressableArea
     ) -> Point:
@@ -1124,7 +1187,6 @@ class GeometryView:
             if self._modules.should_dodge_thermocycler(
                 from_slot=from_slot, to_slot=to_slot
             ):
-
                 middle_slot_fixture = (
                     self._addressable_areas.get_fixture_by_deck_slot_name(
                         DeckSlotName.SLOT_C2.to_equivalent_for_robot_type(
@@ -1393,48 +1455,20 @@ class GeometryView:
                     x_well_offset = 0
         return x_well_offset
 
-    def get_final_labware_movement_offset_vectors(
-        self,
-        from_location: OnDeckLabwareLocation,
-        to_location: OnDeckLabwareLocation,
-        additional_pick_up_offset: Point,
-        additional_drop_offset: Point,
-        current_labware: LabwareDefinition,
-    ) -> LabwareMovementOffsetData:
-        """Calculate the final labware offset vector to use in labware movement."""
-        pick_up_offset = (
-            self.get_total_nominal_gripper_offset_for_move_type(
-                location=from_location,
-                move_type=_GripperMoveType.PICK_UP_LABWARE,
-                current_labware=current_labware,
-            )
-            + additional_pick_up_offset
-        )
-        drop_offset = (
-            self.get_total_nominal_gripper_offset_for_move_type(
-                location=to_location,
-                move_type=_GripperMoveType.DROP_LABWARE,
-                current_labware=current_labware,
-            )
-            + additional_drop_offset
-        )
-
-        return LabwareMovementOffsetData(
-            pickUpOffset=LabwareOffsetVector(
-                x=pick_up_offset.x, y=pick_up_offset.y, z=pick_up_offset.z
-            ),
-            dropOffset=LabwareOffsetVector(
-                x=drop_offset.x, y=drop_offset.y, z=drop_offset.z
-            ),
-        )
-
     @staticmethod
     def ensure_valid_gripper_location(
         location: LabwareLocation,
     ) -> Union[
-        DeckSlotLocation, ModuleLocation, OnLabwareLocation, AddressableAreaLocation
+        DeckSlotLocation,
+        ModuleLocation,
+        OnLabwareLocation,
+        AddressableAreaLocation,
     ]:
         """Ensure valid on-deck location for gripper, otherwise raise error."""
+        if location == WASTE_CHUTE_LOCATION:
+            raise errors.LabwareMovementNotAllowedError(
+                "Labware movements out of the waste chute are not supported using the gripper."
+            )
         if not isinstance(
             location,
             (
@@ -1449,129 +1483,27 @@ class GeometryView:
             )
         return location
 
-    def get_total_nominal_gripper_offset_for_move_type(
-        self,
-        location: OnDeckLabwareLocation,
-        move_type: _GripperMoveType,
-        current_labware: LabwareDefinition,
-    ) -> Point:
-        """Get the total of the offsets to be used to pick up labware in its current location."""
-        if move_type == _GripperMoveType.PICK_UP_LABWARE:
-            if isinstance(
-                location, (ModuleLocation, DeckSlotLocation, AddressableAreaLocation)
-            ):
-                return Point.from_xyz_attrs(
-                    self._nominal_gripper_offsets_for_location(location).pickUpOffset
-                )
-            else:
-                # If it's a labware on a labware (most likely an adapter),
-                # we calculate the offset as sum of offsets for the direct parent labware
-                # and the underlying non-labware parent location.
-                direct_parent_offset = self._nominal_gripper_offsets_for_location(
-                    location
-                )
-                ancestor = self._labware.get_parent_location(location.labwareId)
-                extra_offset = Point(x=0, y=0, z=0)
-                if (
-                    isinstance(ancestor, ModuleLocation)
-                    # todo(mm, 2025-06-20): Avoid this private attribute access.
-                    and self._modules._state.requested_model_by_id[ancestor.moduleId]
-                    == ModuleModel.THERMOCYCLER_MODULE_V2
-                    and labware_validation.validate_definition_is_lid(current_labware)
-                ):
-                    if "lidOffsets" in current_labware.gripperOffsets.keys():
-                        extra_offset = Point(
-                            x=current_labware.gripperOffsets[
-                                "lidOffsets"
-                            ].pickUpOffset.x,
-                            y=current_labware.gripperOffsets[
-                                "lidOffsets"
-                            ].pickUpOffset.y,
-                            z=current_labware.gripperOffsets[
-                                "lidOffsets"
-                            ].pickUpOffset.z,
-                        )
-                    else:
-                        raise errors.LabwareOffsetDoesNotExistError(
-                            f"Labware Definition {current_labware.parameters.loadName} does not contain required field 'lidOffsets' of 'gripperOffsets'."
-                        )
-
-                assert isinstance(
-                    ancestor,
-                    (
-                        DeckSlotLocation,
-                        ModuleLocation,
-                        OnLabwareLocation,
-                        AddressableAreaLocation,
-                    ),
-                ), "No gripper offsets for off-deck labware"
-                return (
-                    Point.from_xyz_attrs(direct_parent_offset.pickUpOffset)
-                    + Point.from_xyz_attrs(
-                        self._nominal_gripper_offsets_for_location(
-                            location=ancestor
-                        ).pickUpOffset
-                    )
-                    + extra_offset
-                )
-        else:
-            if isinstance(
-                location, (ModuleLocation, DeckSlotLocation, AddressableAreaLocation)
-            ):
-                return Point.from_xyz_attrs(
-                    self._nominal_gripper_offsets_for_location(location).dropOffset
-                )
-            else:
-                # If it's a labware on a labware (most likely an adapter),
-                # we calculate the offset as sum of offsets for the direct parent labware
-                # and the underlying non-labware parent location.
-                direct_parent_offset = self._nominal_gripper_offsets_for_location(
-                    location
-                )
-                ancestor = self._labware.get_parent_location(location.labwareId)
-                extra_offset = Point(x=0, y=0, z=0)
-                if (
-                    isinstance(ancestor, ModuleLocation)
-                    # todo(mm, 2024-11-06): Do not access private module state; only use public ModuleView methods.
-                    and self._modules._state.requested_model_by_id[ancestor.moduleId]
-                    == ModuleModel.THERMOCYCLER_MODULE_V2
-                    and labware_validation.validate_definition_is_lid(current_labware)
-                ):
-                    if "lidOffsets" in current_labware.gripperOffsets.keys():
-                        extra_offset = Point(
-                            x=current_labware.gripperOffsets[
-                                "lidOffsets"
-                            ].pickUpOffset.x,
-                            y=current_labware.gripperOffsets[
-                                "lidOffsets"
-                            ].pickUpOffset.y,
-                            z=current_labware.gripperOffsets[
-                                "lidOffsets"
-                            ].pickUpOffset.z,
-                        )
-                    else:
-                        raise errors.LabwareOffsetDoesNotExistError(
-                            f"Labware Definition {current_labware.parameters.loadName} does not contain required field 'lidOffsets' of 'gripperOffsets'."
-                        )
-
-                assert isinstance(
-                    ancestor,
-                    (
-                        DeckSlotLocation,
-                        ModuleLocation,
-                        OnLabwareLocation,
-                        AddressableAreaLocation,
-                    ),
-                ), "No gripper offsets for off-deck labware"
-                return (
-                    Point.from_xyz_attrs(direct_parent_offset.dropOffset)
-                    + Point.from_xyz_attrs(
-                        self._nominal_gripper_offsets_for_location(
-                            location=ancestor
-                        ).dropOffset
-                    )
-                    + extra_offset
-                )
+    @staticmethod
+    def ensure_valid_new_gripper_location(
+        location: LabwareLocation,
+    ) -> AccessibleByGripperLocation:
+        """Ensure valid on-deck location for gripper, otherwise raise error."""
+        if (
+            not isinstance(
+                location,
+                (
+                    DeckSlotLocation,
+                    ModuleLocation,
+                    OnLabwareLocation,
+                    AddressableAreaLocation,
+                ),
+            )
+            and location != WASTE_CHUTE_LOCATION
+        ):
+            raise errors.LabwareMovementNotAllowedError(
+                "Off-deck labware movements are not supported using the gripper."
+            )
+        return location
 
     # todo(mm, 2024-11-05): This may be incorrect because it does not take the following
     # offsets into account, which *are* taken into account for the actual gripper movement:
@@ -1624,64 +1556,6 @@ class GeometryView:
                     f"Cannot move labware '{labware_definition.parameters.loadName}' when {int(tip.volume)} µL tips are attached."
                 )
 
-    def _nominal_gripper_offsets_for_location(
-        self, location: OnDeckLabwareLocation
-    ) -> LabwareMovementOffsetData:
-        """Provide the default gripper offset data for the given location type."""
-        if isinstance(location, (DeckSlotLocation, AddressableAreaLocation)):
-            # TODO we might need a separate type of gripper offset for addressable areas but that also might just
-            #   be covered by the drop labware offset/location
-            offsets = self._labware.get_deck_default_gripper_offsets()
-        elif isinstance(location, ModuleLocation):
-            offsets = self._modules.get_default_gripper_offsets(location.moduleId)
-        else:
-            # Labware is on a labware/adapter
-            offsets = self._labware_gripper_offsets(location.labwareId)
-        return offsets or LabwareMovementOffsetData(
-            pickUpOffset=LabwareOffsetVector(x=0, y=0, z=0),
-            dropOffset=LabwareOffsetVector(x=0, y=0, z=0),
-        )
-
-    def _labware_gripper_offsets(
-        self, labware_id: str
-    ) -> Optional[LabwareMovementOffsetData]:
-        """Provide the most appropriate gripper offset data for the specified labware.
-
-        We check the types of gripper offsets available for the labware ("default" or slot-based)
-        and return the most appropriate one for the overall location of the labware.
-        Currently, only module adapters (specifically, the H/S universal flat adapter)
-        have non-default offsets that are specific to location of the module on deck,
-        so, this code only checks for the presence of those known offsets.
-        """
-        parent_location = self._labware.get_parent_location(labware_id)
-        assert isinstance(
-            parent_location,
-            (
-                DeckSlotLocation,
-                ModuleLocation,
-                AddressableAreaLocation,
-                OnLabwareLocation,
-            ),
-        ), "No gripper offsets for off-deck labware"
-
-        if isinstance(parent_location, DeckSlotLocation):
-            slot_name = parent_location.slotName
-        elif isinstance(parent_location, AddressableAreaLocation):
-            slot_name = self._addressable_areas.get_addressable_area_base_slot(
-                parent_location.addressableAreaName
-            )
-        else:
-            module_loc = self._modules.get_location(parent_location.moduleId)
-            slot_name = module_loc.slotName
-
-        slot_based_offset = self._labware.get_child_gripper_offsets(
-            labware_id=labware_id, slot_name=slot_name.to_ot3_equivalent()
-        )
-
-        return slot_based_offset or self._labware.get_child_gripper_offsets(
-            labware_id=labware_id, slot_name=None
-        )
-
     def get_location_sequence(self, labware_id: str) -> LabwareLocationSequence:
         """Provide the LocationSequence specifying the current position of the labware.
 
@@ -1851,6 +1725,12 @@ class GeometryView:
             return self._recurse_labware_location_from_stacker_hopper(
                 labware_location, building
             )
+        elif labware_location == WASTE_CHUTE_LOCATION:
+            return [
+                NotOnDeckLocationSequenceComponent(
+                    logicalLocationName=WASTE_CHUTE_LOCATION
+                )
+            ]
         else:
             _LOG.warn(f"Unhandled labware location kind: {labware_location}")
             return building
@@ -2041,6 +1921,15 @@ class GeometryView:
         else:
             return initial_handling_height
 
+    def well_has_tracked_liquid(
+        self,
+        labware_id: str,
+        well_name: str,
+    ) -> bool:
+        """Returns true if this well has had a liquid loaded or a probe result."""
+        last_updated = self._wells.get_last_liquid_update(labware_id, well_name)
+        return last_updated is not None
+
     def get_current_well_volume(
         self,
         labware_id: str,
@@ -2288,7 +2177,8 @@ class GeometryView:
             except InvalidLiquidHeightFound as _exception:
                 raise InvalidLiquidHeightFound(
                     message=_exception.message
-                    + f"for well {well_name} of {self._labware.get_display_name(labware_id)} on slot {self.get_ancestor_slot_name(labware_id)}"
+                    + f"for well {well_name} of {self._labware.get_display_name(labware_id)}"
+                    f" on slot {self.get_ancestor_slot_name(labware_id)}"
                 )
             # if meniscus volume is a simulated value, comparisons aren't meaningful
             if isinstance(meniscus_volume, SimulatedProbeResult):
@@ -2296,13 +2186,16 @@ class GeometryView:
             remaining_volume = well_volumetric_capacity - meniscus_volume
             if volume > remaining_volume:
                 raise errors.InvalidDispenseVolumeError(
-                    f"Attempting to dispense {volume}µL of liquid into a well that can currently only hold {remaining_volume}µL (well {well_name} in labware_id: {labware_id})"
+                    f"Attempting to dispense {volume}µL of liquid into a well that can currently only hold"
+                    f" {remaining_volume}µL (well {well_name} in labware {self._labware.get_display_name(labware_id)})"
                 )
         else:
             # TODO(pbm, 10-08-24): factor in well (LabwareStore) state volume
             if volume > well_volumetric_capacity:
                 raise errors.InvalidDispenseVolumeError(
-                    f"Attempting to dispense {volume}µL of liquid into a well that can only hold {well_volumetric_capacity}µL (well {well_name} in labware_id: {labware_id})"
+                    f"Attempting to dispense {volume}µL of liquid into a well that can only hold"
+                    f" {well_volumetric_capacity}µL (well {well_name} in"
+                    f" labware {self._labware.get_display_name(labware_id)})"
                 )
 
     def get_wells_covered_by_pipette_with_active_well(
@@ -2423,6 +2316,10 @@ class GeometryView:
             raise errors.LocationNotAccessibleByPipetteError(
                 f"Cannot move pipette to {labware.loadName}, labware is off-deck."
             )
+        elif labware_location == WASTE_CHUTE_LOCATION:
+            raise errors.LocationNotAccessibleByPipetteError(
+                f"Cannot move pipette to {labware.loadName}, labware is in waste chute."
+            )
         elif isinstance(labware_location, ModuleLocation):
             module = self._modules.get(labware_location.moduleId)
             if ModuleModel.is_flex_stacker(module.model):