opentrons 8.4.1a1__py2.py3-none-any.whl → 8.5.0__py2.py3-none-any.whl

opentrons/protocol_api/core/engine/transfer_components_executor.py

@@ -12,7 +12,6 @@ from opentrons_shared_data.liquid_classes.liquid_class_definition import (
     Coordinate,
     BlowoutLocation,
 )
-from opentrons_shared_data.pipette.types import LIQUID_PROBE_START_OFFSET_FROM_WELL_TOP
 
 from opentrons.protocol_api._liquid_properties import (
     Submerge,
@@ -23,9 +22,10 @@ from opentrons.protocol_api._liquid_properties import (
     TouchTipProperties,
 )
 from opentrons.protocol_engine.errors import TouchTipDisabledError
-from opentrons.types import Location, Point
+from opentrons.types import Location, Point, Mount
 from opentrons.protocols.advanced_control.transfers.transfer_liquid_utils import (
     LocationCheckDescriptors,
+    check_current_volume_before_dispensing,
 )
 from opentrons.protocols.advanced_control.transfers import (
     transfer_liquid_utils as tx_utils,
@@ -39,6 +39,9 @@ if TYPE_CHECKING:
 log = logging.getLogger(__name__)
 
 
+AIR_GAP_LOC_Z_OFFSET_FROM_WELL_TOP = 2
+
+
 @dataclass
 class LiquidAndAirGapPair:
     """Pairing of a liquid and air gap in a tip, with air gap below the liquid in a tip."""
@@ -119,11 +122,32 @@ class TransferComponentsExecutor:
         self,
         instrument_core: InstrumentCore,
         transfer_properties: TransferProperties,
-        target_location: Location,
-        target_well: WellCore,
+        target_location: Union[Location, TrashBin, WasteChute],
+        target_well: Optional[WellCore],
         tip_state: TipState,
         transfer_type: TransferType,
     ) -> None:
+        """Create a TransferComponentsExecutor instance.
+
+        One instance should be created to execute all the steps inside each of the
+        liquid class' transfer components- aspirate, dispense and multi-dispense.
+        The state of the TransferComponentsExecutor instance is expected to be valid
+        only for the component it was created.
+
+        For example, if we want to execute all the steps (submerge, dispense, retract, etc)
+        related to the 'dispense' component of a liquid-class based transfer, the class
+        will be used to initialize info about the dispense by assigning values
+        to class attributes as follows-
+        - target_location: the dispense location
+        - target_well: the well associated with dispense location, will be None when the
+                        target_location argument is a TrashBin or WasteChute
+        - tip_state: the state of the tip before dispense component steps are executed
+        - transfer_type: whether the dispense component is being called as a part of a
+                        1-to-1 transfer or a consolidation or a distribution
+
+        These attributes will remain the same throughout the component's execution,
+        except `tip_state`, which will keep updating as fluids are handled.
+        """
         self._instrument = instrument_core
         self._transfer_properties = transfer_properties
         self._target_location = target_location
@@ -140,7 +164,6 @@ class TransferComponentsExecutor:
         self,
         submerge_properties: Submerge,
         post_submerge_action: Literal["aspirate", "dispense"],
-        volume_for_pipette_mode_configuration: Optional[float],
     ) -> None:
         """Execute submerge steps.
 
@@ -148,56 +171,37 @@ class TransferComponentsExecutor:
         Should raise an error if this point is inside the liquid?
             For liquid meniscus this is easy to tell. Can’t be below meniscus
             For reference pos of anything else, do not allow submerge position to be below aspirate position
-        2. move to aspirate position at desired speed
+        2. move to aspirate/dispense position at desired speed
         3. delay
+
+        If target location is a trash bin or waste chute, the pipette will move to the disposal location given,
+        remove air gap and delay
         """
-        submerge_start_point = absolute_point_from_position_reference_and_offset(
-            well=self._target_well,
-            position_reference=submerge_properties.position_reference,
-            offset=submerge_properties.offset,
-        )
-        submerge_start_location = Location(
-            point=submerge_start_point, labware=self._target_location.labware
-        )
-        prep_before_moving_to_submerge = (
-            post_submerge_action == "aspirate"
-            and volume_for_pipette_mode_configuration is not None
-        )
-        if prep_before_moving_to_submerge:
-            # Move to the tip probe start position
-            self._instrument.move_to(
-                location=Location(
-                    point=self._target_well.get_top(
-                        LIQUID_PROBE_START_OFFSET_FROM_WELL_TOP.z
-                    ),
-                    labware=self._target_location.labware,
-                ),
+        submerge_start_location: Union[Location, TrashBin, WasteChute]
+        if isinstance(self._target_location, Location):
+            assert self._target_well is not None
+            submerge_start_point = absolute_point_from_position_reference_and_offset(
+                well=self._target_well,
+                well_volume_difference=0,
+                position_reference=submerge_properties.start_position.position_reference,
+                offset=submerge_properties.start_position.offset,
+                mount=self._instrument.get_mount(),
+            )
+            submerge_start_location = Location(
+                point=submerge_start_point, labware=self._target_location.labware
+            )
+            tx_utils.raise_if_location_inside_liquid(
+                location=submerge_start_location,
                 well_core=self._target_well,
-                force_direct=False,
-                minimum_z_height=None,
-                speed=None,
+                location_check_descriptors=LocationCheckDescriptors(
+                    location_type="submerge start",
+                    pipetting_action=post_submerge_action,
+                ),
+                logger=log,
             )
-            self._remove_air_gap(location=submerge_start_location)
-            if (
-                self._transfer_type != TransferType.MANY_TO_ONE
-                and self._instrument.get_liquid_presence_detection()
-            ):
-                self._instrument.liquid_probe_with_recovery(
-                    well_core=self._target_well, loc=submerge_start_location
-                )
-            # TODO: do volume configuration + prepare for aspirate only if the mode needs to be changed
-            self._instrument.configure_for_volume(volume_for_pipette_mode_configuration)  # type: ignore[arg-type]
-            self._instrument.prepare_to_aspirate()
-        tx_utils.raise_if_location_inside_liquid(
-            location=submerge_start_location,
-            well_location=self._target_location,
-            well_core=self._target_well,
-            location_check_descriptors=LocationCheckDescriptors(
-                location_type="submerge start",
-                pipetting_action=post_submerge_action,
-            ),
-            logger=log,
-        )
+        else:
+            submerge_start_location = self._target_location
+
         self._instrument.move_to(
             location=submerge_start_location,
             well_core=self._target_well,
@@ -205,23 +209,30 @@ class TransferComponentsExecutor:
             minimum_z_height=None,
             speed=None,
         )
-        if not prep_before_moving_to_submerge:
-            self._remove_air_gap(location=submerge_start_location)
-        self._instrument.move_to(
-            location=self._target_location,
-            well_core=self._target_well,
-            force_direct=True,
-            minimum_z_height=None,
-            speed=submerge_properties.speed,
-        )
+        self._remove_air_gap(location=submerge_start_location)
+        if isinstance(self._target_location, Location):
+            self._instrument.move_to(
+                location=self._target_location,
+                well_core=self._target_well,
+                force_direct=True,
+                minimum_z_height=None,
+                speed=submerge_properties.speed,
+            )
+
         if submerge_properties.delay.enabled and submerge_properties.delay.duration:
             self._instrument.delay(submerge_properties.delay.duration)
 
     def aspirate_and_wait(self, volume: float) -> None:
         """Aspirate according to aspirate properties and wait if enabled."""
         # TODO: handle volume correction
+        assert (
+            isinstance(self._target_location, Location)
+            and self._target_well is not None
+        )
         aspirate_props = self._transfer_properties.aspirate
-        correction_volume = aspirate_props.correction_by_volume.get_for_volume(volume)
+        correction_volume = aspirate_props.correction_by_volume.get_for_volume(
+            self._instrument.get_current_volume() + volume
+        )
         self._instrument.aspirate(
             location=self._target_location,
             well_core=None,
@@ -243,8 +254,12 @@ class TransferComponentsExecutor:
         push_out_override: Optional[float],
     ) -> None:
         """Dispense according to dispense properties and wait if enabled."""
+        current_vol = self._instrument.get_current_volume()
+        check_current_volume_before_dispensing(
+            current_volume=current_vol, dispense_volume=volume
+        )
         correction_volume = dispense_properties.correction_by_volume.get_for_volume(
-            volume
+            current_vol - volume
         )
         self._instrument.dispense(
             location=self._target_location,
@@ -275,11 +290,15 @@ class TransferComponentsExecutor:
         NOTE: For most of our built-in definitions, we will keep _mix_ off because it is a very application specific thing.
         We should mention in our docs that users should adjust this property according to their application.
         """
-        if not mix_properties.enabled:
+        if not mix_properties.enabled or not isinstance(
+            self._target_location, Location
+        ):
             return
         # Assertion only for mypy purposes
         assert (
-            mix_properties.repetitions is not None and mix_properties.volume is not None
+            mix_properties.repetitions is not None
+            and mix_properties.volume is not None
+            and self._target_well is not None
         )
         push_out_vol = (
             self._transfer_properties.dispense.push_out_by_volume.get_for_volume(
@@ -325,30 +344,40 @@ class TransferComponentsExecutor:
             - Touch tip to the sides at the specified speed (tip moves back to the center as part of touch tip)
             - Return back to the retract position
         4. Air gap
-            - Air gap volume depends on the amount of liquid in the pipette
-            So if total aspirated volume is 20, use the value for airGapByVolume[20]
-            Flow rate = min(aspirateFlowRate, (airGapByVolume)/sec)
+            - If the retract location is at or above the safe location of
+              AIR_GAP_LOC_Z_OFFSET_FROM_WELL_TOP, then add the air gap at the
+              retract location (where the pipette is already assumed to be).
+            - If the retract location is below the safe location, then move to
+              the safe location and then add the air gap.
+            - Air gap volume depends on the amount of liquid in the pipette.
+              So, if the total aspirated volume is 20, use the value for airGapByVolume[20]
+              Flow rate = max(aspirateFlowRate, (airGapByVolume)/sec)
             - Use post-aspirate delay
 
         Args:
             volume: dispense volume
             add_air_gap: whether to add an air gap before moving away from the current well.
                          This value is True for all retractions, except when retracting
-                         during a multi-dispense.
+                         during a multi-dispense. Value of add_air_gap during multi-dispense
+                         will depend on whether a conditioning volume is used.
         """
-        # TODO: Raise error if retract is below the meniscus
+        assert (
+            isinstance(self._target_location, Location)
+            and self._target_well is not None
+        )
         retract_props = self._transfer_properties.aspirate.retract
         retract_point = absolute_point_from_position_reference_and_offset(
             well=self._target_well,
-            position_reference=retract_props.position_reference,
-            offset=retract_props.offset,
+            well_volume_difference=0,
+            position_reference=retract_props.end_position.position_reference,
+            offset=retract_props.end_position.offset,
+            mount=self._instrument.get_mount(),
         )
         retract_location = Location(
             retract_point, labware=self._target_location.labware
         )
         tx_utils.raise_if_location_inside_liquid(
             location=retract_location,
-            well_location=self._target_location,
             well_core=self._target_well,
             location_check_descriptors=LocationCheckDescriptors(
                 location_type="retract end",
@@ -371,7 +400,7 @@ class TransferComponentsExecutor:
             assert (
                 touch_tip_props.speed is not None
                 and touch_tip_props.z_offset is not None
-                and touch_tip_props.mm_to_edge is not None
+                and touch_tip_props.mm_from_edge is not None
             )
             self._instrument.touch_tip(
                 location=retract_location,
@@ -379,7 +408,7 @@ class TransferComponentsExecutor:
                 radius=1,
                 z_offset=touch_tip_props.z_offset,
                 speed=touch_tip_props.speed,
-                mm_from_edge=touch_tip_props.mm_to_edge,
+                mm_from_edge=touch_tip_props.mm_from_edge,
             )
             self._instrument.move_to(
                 location=retract_location,
@@ -396,6 +425,29 @@ class TransferComponentsExecutor:
         else:
             volume_for_air_gap = volume
         if add_air_gap:
+            # If we need to add air gap, move to a safe location above the well if
+            # the retract location is not already at or above this safe location
+            if (
+                retract_location.point.z
+                < self._target_well.get_top(AIR_GAP_LOC_Z_OFFSET_FROM_WELL_TOP).z
+            ):
+                self._instrument.move_to(
+                    location=Location(
+                        point=Point(
+                            retract_location.point.x,
+                            retract_location.point.y,
+                            self._target_well.get_top(
+                                AIR_GAP_LOC_Z_OFFSET_FROM_WELL_TOP
+                            ).z,
+                        ),
+                        labware=retract_location.labware,
+                    ),
+                    well_core=self._target_well,
+                    force_direct=True,
+                    minimum_z_height=None,
+                    # Full speed because the tip will already be out of the liquid
+                    speed=None,
+                )
             self._add_air_gap(
                 air_gap_volume=self._transfer_properties.aspirate.retract.air_gap_by_volume.get_for_volume(
                     volume_for_air_gap
@@ -431,35 +483,45 @@ class TransferComponentsExecutor:
             - Prepare-to-aspirate (top of well)
             - Do air-gap (top of well)
         7. If drop tip, move to drop tip location, drop tip
-        """
-        # TODO: Raise error if retract is below the meniscus
 
+        If target location is a trash bin or waste chute, the retract movement step is skipped along with touch tip,
+        even if it is enabled.
+        """
         retract_props = self._transfer_properties.dispense.retract
-        retract_point = absolute_point_from_position_reference_and_offset(
-            well=self._target_well,
-            position_reference=retract_props.position_reference,
-            offset=retract_props.offset,
-        )
-        retract_location = Location(
-            retract_point, labware=self._target_location.labware
-        )
-        tx_utils.raise_if_location_inside_liquid(
-            location=retract_location,
-            well_location=self._target_location,
-            well_core=self._target_well,
-            location_check_descriptors=LocationCheckDescriptors(
-                location_type="retract end",
-                pipetting_action="dispense",
-            ),
-            logger=log,
-        )
-        self._instrument.move_to(
-            location=retract_location,
-            well_core=self._target_well,
-            force_direct=True,
-            minimum_z_height=None,
-            speed=retract_props.speed,
-        )
+
+        retract_location: Union[Location, TrashBin, WasteChute]
+        if isinstance(self._target_location, Location):
+            assert self._target_well is not None
+            retract_point = absolute_point_from_position_reference_and_offset(
+                well=self._target_well,
+                well_volume_difference=0,
+                position_reference=retract_props.end_position.position_reference,
+                offset=retract_props.end_position.offset,
+                mount=self._instrument.get_mount(),
+            )
+            retract_location = Location(
+                retract_point, labware=self._target_location.labware
+            )
+            tx_utils.raise_if_location_inside_liquid(
+                location=retract_location,
+                well_core=self._target_well,
+                location_check_descriptors=LocationCheckDescriptors(
+                    location_type="retract end",
+                    pipetting_action="dispense",
+                ),
+                logger=log,
+            )
+            self._instrument.move_to(
+                location=retract_location,
+                well_core=self._target_well,
+                force_direct=True,
+                minimum_z_height=None,
+                speed=retract_props.speed,
+            )
+        else:
+            retract_location = self._target_location
+
+        # TODO should we delay here for a trash despite not having a "retract"?
         retract_delay = retract_props.delay
         if retract_delay.enabled and retract_delay.duration:
             self._instrument.delay(retract_delay.duration)
@@ -485,7 +547,7 @@ class TransferComponentsExecutor:
         # when leaving the dispense well. If this will be the final air gap, i.e,
         # we won't be moving to a Trash or a Source for Blowout after this air gap,
         # then skip the final air gap if we have been told to do so.
-        self._do_touch_tip_and_air_gap(
+        self._do_touch_tip_and_air_gap_after_dispense(
             touch_tip_properties=retract_props.touch_tip,
             location=retract_location,
             well=self._target_well,
@@ -499,7 +561,7 @@ class TransferComponentsExecutor:
             # TODO: no-op touch tip if touch tip is enabled and blowout is in trash/ reservoir/ any labware with touch-tip disabled
             assert blowout_props.flow_rate is not None
             self._instrument.set_flow_rate(blow_out=blowout_props.flow_rate)
-            touch_tip_and_air_gap_location: Optional[Location]
+            touch_tip_and_air_gap_location: Union[Location, TrashBin, WasteChute]
             if blowout_props.location == BlowoutLocation.SOURCE:
                 if source_location is None or source_well is None:
                     raise RuntimeError(
@@ -523,9 +585,7 @@ class TransferComponentsExecutor:
                     well_core=None,
                     in_place=False,
                 )
-                touch_tip_and_air_gap_location = (
-                    trash_location if isinstance(trash_location, Location) else None
-                )
+                touch_tip_and_air_gap_location = trash_location
                 touch_tip_and_air_gap_well = (
                     # We have already established that trash location of `Location` type
                     # has its `labware` as `Well` type.
@@ -540,7 +600,7 @@ class TransferComponentsExecutor:
             self._tip_state.delete_air_gap(last_air_gap)
             self._tip_state.ready_to_aspirate = False
             # Do touch tip and air gap again after blowing out into source well or trash
-            self._do_touch_tip_and_air_gap(
+            self._do_touch_tip_and_air_gap_after_dispense(
                 touch_tip_properties=retract_props.touch_tip,
                 location=touch_tip_and_air_gap_location,
                 well=touch_tip_and_air_gap_well,
@@ -572,22 +632,25 @@ class TransferComponentsExecutor:
         that it handles air gaps differently based on the disposal volume, conditioning volume
         and whether we are moving to another dispense or going back to the source.
         """
-        # TODO: Raise error if retract is below the meniscus
-
+        assert (
+            isinstance(self._target_location, Location)
+            and self._target_well is not None
+        )
         assert self._transfer_properties.multi_dispense is not None
 
         retract_props = self._transfer_properties.multi_dispense.retract
         retract_point = absolute_point_from_position_reference_and_offset(
             well=self._target_well,
-            position_reference=retract_props.position_reference,
-            offset=retract_props.offset,
+            well_volume_difference=0,
+            position_reference=retract_props.end_position.position_reference,
+            offset=retract_props.end_position.offset,
+            mount=self._instrument.get_mount(),
         )
         retract_location = Location(
             retract_point, labware=self._target_location.labware
         )
         tx_utils.raise_if_location_inside_liquid(
             location=retract_location,
-            well_location=self._target_location,
             well_core=self._target_well,
             location_check_descriptors=LocationCheckDescriptors(
                 location_type="retract end",
@@ -662,7 +725,7 @@ class TransferComponentsExecutor:
         # Add an air gap depending on conditioning volume + whether this is
         # the last step of a multi-dispense sequence + whether this is the last step
         # of the entire liquid distribution.
-        self._do_touch_tip_and_air_gap(
+        self._do_touch_tip_and_air_gap_after_dispense(
             touch_tip_properties=retract_props.touch_tip,
             location=retract_location,
             well=self._target_well,
@@ -676,7 +739,7 @@ class TransferComponentsExecutor:
         ):
             assert blowout_props.flow_rate is not None
             self._instrument.set_flow_rate(blow_out=blowout_props.flow_rate)
-            touch_tip_and_air_gap_location: Optional[Location]
+            touch_tip_and_air_gap_location: Union[Location, TrashBin, WasteChute]
             if blowout_props.location == BlowoutLocation.SOURCE:
                 if source_location is None or source_well is None:
                     raise RuntimeError(
@@ -700,9 +763,7 @@ class TransferComponentsExecutor:
                     well_core=None,
                     in_place=False,
                 )
-                touch_tip_and_air_gap_location = (
-                    trash_location if isinstance(trash_location, Location) else None
-                )
+                touch_tip_and_air_gap_location = trash_location
                 touch_tip_and_air_gap_well = (
                     # We have already established that trash location of `Location` type
                     # has its `labware` as `Well` type.
@@ -716,7 +777,7 @@ class TransferComponentsExecutor:
             self._tip_state.ready_to_aspirate = False
 
             # Do touch tip and air gap again after blowing out into source well or trash
-            self._do_touch_tip_and_air_gap(
+            self._do_touch_tip_and_air_gap_after_dispense(
                 touch_tip_properties=retract_props.touch_tip,
                 location=touch_tip_and_air_gap_location,
                 well=touch_tip_and_air_gap_well,
@@ -728,24 +789,35 @@ class TransferComponentsExecutor:
                 ),
             )
 
-    def _do_touch_tip_and_air_gap(
+    def _do_touch_tip_and_air_gap_after_dispense(  # noqa: C901
         self,
         touch_tip_properties: TouchTipProperties,
-        location: Optional[Location],
+        location: Union[Location, TrashBin, WasteChute],
         well: Optional[WellCore],
         add_air_gap: bool,
     ) -> None:
-        """Perform touch tip and air gap as part of post-dispense retract."""
+        """Perform touch tip and air gap as part of post-dispense retract.
+
+        If the retract location is at or above the safe location of
+        AIR_GAP_LOC_Z_OFFSET_FROM_WELL_TOP, then add the air gap at the retract location
+        (where the pipette is already assumed to be at).
+
+        If the retract location is below the safe location, then move to the safe location
+        and then add the air gap.
+
+        Note: if the plunger needs to be adjusted to prepare for aspirate, it will be done
+        at the same location where the air gap will be added.
+        """
         if touch_tip_properties.enabled:
             assert (
                 touch_tip_properties.speed is not None
                 and touch_tip_properties.z_offset is not None
-                and touch_tip_properties.mm_to_edge is not None
+                and touch_tip_properties.mm_from_edge is not None
             )
             # TODO:, check that when blow out is a non-dest-well,
             #  whether the touch tip params from transfer props should be used for
             #  both dest-well touch tip and non-dest-well touch tip.
-            if well is not None and location is not None:
+            if isinstance(location, Location) and well is not None:
                 try:
                     self._instrument.touch_tip(
                         location=location,
@@ -753,7 +825,7 @@ class TransferComponentsExecutor:
                         radius=1,
                         z_offset=touch_tip_properties.z_offset,
                         speed=touch_tip_properties.speed,
-                        mm_from_edge=touch_tip_properties.mm_to_edge,
+                        mm_from_edge=touch_tip_properties.mm_from_edge,
                     )
                 except TouchTipDisabledError:
                     # TODO: log a warning
@@ -768,25 +840,69 @@ class TransferComponentsExecutor:
                     # Full speed because the tip will already be out of the liquid
                     speed=None,
                 )
+        if add_air_gap or not self._tip_state.ready_to_aspirate:
+            # If we need to move the plunger up either to prepare for aspirate or to add air gap,
+            # move to a safe location above the well if the retract location is not already
+            # at or above this safe location
+            if isinstance(location, Location):
+                assert well is not None  # For mypy purposes only
+                if (
+                    location.point.z
+                    < well.get_top(AIR_GAP_LOC_Z_OFFSET_FROM_WELL_TOP).z
+                ):
+                    self._instrument.move_to(
+                        location=Location(
+                            point=Point(
+                                location.point.x,
+                                location.point.y,
+                                well.get_top(AIR_GAP_LOC_Z_OFFSET_FROM_WELL_TOP).z,
+                            ),
+                            labware=location.labware,
+                        ),
+                        well_core=well,
+                        force_direct=True,
+                        minimum_z_height=None,
+                        speed=None,
+                    )
+            else:
+                if (
+                    location.offset.z
+                    < location.top(
+                        x=0, y=0, z=AIR_GAP_LOC_Z_OFFSET_FROM_WELL_TOP
+                    ).offset.z
+                ):
+                    self._instrument.move_to(
+                        location=location.top(
+                            x=location.offset.x,
+                            y=location.offset.y,
+                            z=AIR_GAP_LOC_Z_OFFSET_FROM_WELL_TOP,
+                        ),
+                        well_core=None,
+                        force_direct=True,
+                        minimum_z_height=None,
+                        speed=None,
+                    )
 
-        # TODO: check if it is okay to just do `prepare_to_aspirate` unconditionally
-        if not self._tip_state.ready_to_aspirate:
-            self._instrument.prepare_to_aspirate()
-            self._tip_state.ready_to_aspirate = True
-        if add_air_gap:
-            self._add_air_gap(
-                air_gap_volume=self._transfer_properties.aspirate.retract.air_gap_by_volume.get_for_volume(
-                    0
+            if not self._tip_state.ready_to_aspirate:
+                self._instrument.prepare_to_aspirate()
+                self._tip_state.ready_to_aspirate = True
+            if add_air_gap:
+                self._add_air_gap(
+                    air_gap_volume=self._transfer_properties.aspirate.retract.air_gap_by_volume.get_for_volume(
+                        0
+                    )
                 )
-            )
 
-    def _add_air_gap(self, air_gap_volume: float) -> None:
+    def _add_air_gap(
+        self,
+        air_gap_volume: float,
+    ) -> None:
         """Add an air gap."""
         if air_gap_volume == 0:
             return
         aspirate_props = self._transfer_properties.aspirate
         correction_volume = aspirate_props.correction_by_volume.get_for_volume(
-            air_gap_volume
+            self._instrument.get_current_volume() + air_gap_volume
         )
         # The minimum flow rate should be air_gap_volume per second
         flow_rate = max(
@@ -803,43 +919,33 @@ class TransferComponentsExecutor:
             self._instrument.delay(delay_props.duration)
         self._tip_state.append_air_gap(air_gap_volume)
 
-    def _remove_air_gap(self, location: Location) -> None:
+    def _remove_air_gap(self, location: Union[Location, TrashBin, WasteChute]) -> None:
         """Remove a previously added air gap."""
         last_air_gap = self._tip_state.last_liquid_and_air_gap_in_tip.air_gap
-        if last_air_gap == 0:
-            return
-
         dispense_props = self._transfer_properties.dispense
-        correction_volume = dispense_props.correction_by_volume.get_for_volume(
-            last_air_gap
-        )
-        # The minimum flow rate should be air_gap_volume per second
-        flow_rate = max(
-            dispense_props.flow_rate_by_volume.get_for_volume(last_air_gap),
-            last_air_gap,
-        )
-        self._instrument.dispense(
+        self._instrument.remove_air_gap_during_transfer_with_liquid_class(
+            last_air_gap=last_air_gap,
+            dispense_props=dispense_props,
             location=location,
-            well_core=None,
-            volume=last_air_gap,
-            rate=1,
-            flow_rate=flow_rate,
-            in_place=True,
-            push_out=0,
-            correction_volume=correction_volume,
         )
         self._tip_state.delete_air_gap(last_air_gap)
-        dispense_delay = dispense_props.delay
-        if dispense_delay.enabled and dispense_delay.duration:
-            self._instrument.delay(dispense_delay.duration)
 
 
 def absolute_point_from_position_reference_and_offset(
     well: WellCore,
+    well_volume_difference: float,
     position_reference: PositionReference,
     offset: Coordinate,
+    mount: Mount,
 ) -> Point:
-    """Return the absolute point, given the well, the position reference and offset."""
+    """Return the absolute point, given the well, the position reference and offset.
+
+    If using meniscus as the position reference, well_volume_difference should be specified.
+    `well_volume_difference` is the expected *difference* in well volume we want to consider
+    when estimating the height of the liquid meniscus after an aspirate/ dispense.
+    So, for liquid height estimation after an aspirate, well_volume_difference is
+    expected to be a -ve value while for a dispense, it will be a +ve value.
+    """
     match position_reference:
         case PositionReference.WELL_TOP:
             reference_point = well.get_top(0)
@@ -848,11 +954,17 @@ def absolute_point_from_position_reference_and_offset(
         case PositionReference.WELL_CENTER:
             reference_point = well.get_center()
         case PositionReference.LIQUID_MENISCUS:
-            meniscus_point = well.get_meniscus()
-            if not isinstance(meniscus_point, Point):
-                reference_point = well.get_center()
+            estimated_liquid_height = well.estimate_liquid_height_after_pipetting(
+                mount=mount,
+                operation_volume=well_volume_difference,
+            )
+            if isinstance(estimated_liquid_height, (float, int)):
+                reference_point = well.get_bottom(z_offset=estimated_liquid_height)
             else:
-                reference_point = meniscus_point
+                # If estimated liquid height gives a SimulatedProbeResult then
+                # assume meniscus is at well center.
+                # Will this cause more harm than good? Is there a better alternative to this?
+                reference_point = well.get_center()
         case _:
             raise ValueError(f"Unknown position reference {position_reference}")
     return reference_point + Point(offset.x, offset.y, offset.z)