opentrons 8.1.0a0__py2.py3-none-any.whl → 8.2.0a0__py2.py3-none-any.whl

opentrons/hardware_control/ot3api.py

@@ -143,7 +143,8 @@ from .backends.types import HWStopCondition
 from .backends.flex_protocol import FlexBackend
 from .backends.ot3simulator import OT3Simulator
 from .backends.errors import SubsystemUpdating
-
+from opentrons_hardware.firmware_bindings.constants import SensorId
+from opentrons_hardware.sensors.types import SensorDataType
 
 mod_log = logging.getLogger(__name__)
 
@@ -164,6 +165,7 @@ def _adjust_high_throughput_z_current(func: Wrapped) -> Wrapped:
     A decorator that temproarily and conditionally changes the active current (based on the axis input)
     before a function is executed and the cleans up afterwards
     """
+
     # only home and retract should be wrappeed by this decorator
     @wraps(func)
     async def wrapper(self: Any, axis: Axis, *args: Any, **kwargs: Any) -> Any:
@@ -306,6 +308,12 @@ class OT3API(
         async with self._backend.restore_system_constraints():
             yield
 
+    @contextlib.asynccontextmanager
+    async def grab_pressure(self, mount: OT3Mount) -> AsyncIterator[None]:
+        instrument = self._pipette_handler.get_pipette(mount)
+        async with self._backend.grab_pressure(instrument.channels, mount):
+            yield
+
     def _update_door_state(self, door_state: DoorState) -> None:
         mod_log.info(f"Updating the window switch status: {door_state}")
         self.door_state = door_state
@@ -933,7 +941,6 @@ class OT3API(
             current_pos_float > self._config.safe_home_distance
             and current_pos_float < max_distance
         ):
-
             # move toward home until a safe distance
             await self._backend.tip_action(
                 origin={Axis.Q: current_pos_float},
@@ -1811,7 +1818,8 @@ class OT3API(
         increment: Optional[float] = None,
     ) -> None:
         """This is a slightly more barebones variation of pick_up_tip. This is only the motor routine
-        directly involved in tip pickup, and leaves any state updates and plunger moves to the caller."""
+        directly involved in tip pickup, and leaves any state updates and plunger moves to the caller.
+        """
         realmount = OT3Mount.from_mount(mount)
         instrument = self._pipette_handler.get_pipette(realmount)
 
@@ -1878,12 +1886,10 @@ class OT3API(
 
         With wet tips, the primary concern is leftover droplets inside the tip.
         These droplets ideally only move down and out of the tip, not up into the tip.
-        Therefore, it is preferable to use the "blow-out" speed when moving the
-        plunger down, and the slower "aspirate" speed when moving the plunger up.
-
-        Assume all tips are wet, because we do not differentiate between wet/dry tips.
+        Therefore, it is preferable to use the slower "aspirate" speed when
+        moving the plunger up after a blow-out.
 
-        When no tip is attached, moving at the max speed is preferable, to save time.
+        All other situations, moving at the max speed is preferable, to save time.
         """
         checked_mount = OT3Mount.from_mount(mount)
         instrument = self._pipette_handler.get_pipette(checked_mount)
@@ -1896,21 +1902,22 @@ class OT3API(
             self._current_position,
         )
         pip_ax = Axis.of_main_tool_actuator(checked_mount)
-        # speed depends on if there is a tip, and which direction to move
-        if instrument.has_tip_length:
+        # save time while moving down by using max speed
+        max_speeds = self.config.motion_settings.default_max_speed
+        speed_down = max_speeds[self.gantry_load][OT3AxisKind.P]
+        # upward moves can be max speed, or aspirate speed
+        # use the (slower) aspirate if there is a tip and we're following a blow-out
+        plunger_is_below_bottom_pos = (
+            self._current_position[pip_ax] > instrument.plunger_positions.bottom
+        )
+        if instrument.has_tip_length and plunger_is_below_bottom_pos:
             # using slower aspirate flow-rate, to avoid pulling droplets up
             speed_up = self._pipette_handler.plunger_speed(
                 instrument, instrument.aspirate_flow_rate, "aspirate"
             )
-            # use blow-out flow-rate, so we can push droplets out
-            speed_down = self._pipette_handler.plunger_speed(
-                instrument, instrument.blow_out_flow_rate, "dispense"
-            )
         else:
-            # save time by using max speed
-            max_speeds = self.config.motion_settings.default_max_speed
+            # either no tip, or plunger just homed, so tip is dry
             speed_up = max_speeds[self.gantry_load][OT3AxisKind.P]
-            speed_down = speed_up
         # IMPORTANT: Here is our backlash compensation.
         #            The plunger is pre-loaded in the "aspirate" direction
         backlash_pos = target_pos.copy()
@@ -2229,15 +2236,6 @@ class OT3API(
             )
             await self.home_gear_motors()
 
-    def cache_tip(
-        self, mount: Union[top_types.Mount, OT3Mount], tip_length: float
-    ) -> None:
-        realmount = OT3Mount.from_mount(mount)
-        instrument = self._pipette_handler.get_pipette(realmount)
-
-        instrument.add_tip(tip_length=tip_length)
-        instrument.set_current_volume(0)
-
     async def pick_up_tip(
         self,
         mount: Union[top_types.Mount, OT3Mount],
@@ -2283,17 +2281,10 @@ class OT3API(
         )
         instrument.working_volume = tip_volume
 
-    async def drop_tip(
+    async def tip_drop_moves(
         self, mount: Union[top_types.Mount, OT3Mount], home_after: bool = False
     ) -> None:
-        """Drop tip at the current location."""
         realmount = OT3Mount.from_mount(mount)
-        instrument = self._pipette_handler.get_pipette(realmount)
-
-        def _remove_tips() -> None:
-            instrument.set_current_volume(0)
-            instrument.current_tiprack_diameter = 0.0
-            instrument.remove_tip()
 
         await self._move_to_plunger_bottom(realmount, rate=1.0, check_current_vol=False)
 
@@ -2320,11 +2311,27 @@ class OT3API(
         if home_after:
             await self._home([Axis.by_mount(mount)])
 
-        _remove_tips()
-        # call this in case we're simulating
+        # call this in case we're simulating:
         if isinstance(self._backend, OT3Simulator):
             self._backend._update_tip_state(realmount, False)
 
+    async def drop_tip(
+        self, mount: Union[top_types.Mount, OT3Mount], home_after: bool = False
+    ) -> None:
+        """Drop tip at the current location."""
+        await self.tip_drop_moves(mount=mount, home_after=home_after)
+
+        # todo(mm, 2024-10-17): Ideally, callers would be able to replicate the behavior
+        # of this method via self.drop_tip_moves() plus other public methods. This
+        # currently prevents that: there is no public equivalent for
+        # instrument.set_current_volume().
+        realmount = OT3Mount.from_mount(mount)
+        instrument = self._pipette_handler.get_pipette(realmount)
+        instrument.set_current_volume(0)
+
+        self.set_current_tiprack_diameter(mount, 0.0)
+        self.remove_tip(mount)
+
     async def clean_up(self) -> None:
         """Get the API ready to stop cleanly."""
         await self._backend.clean_up()
@@ -2592,13 +2599,18 @@ class OT3API(
                 starting_nozzle,
             )
 
-    async def add_tip(
+    def add_tip(
+        self, mount: Union[top_types.Mount, OT3Mount], tip_length: float
+    ) -> None:
+        self._pipette_handler.add_tip(OT3Mount.from_mount(mount), tip_length)
+
+    def cache_tip(
         self, mount: Union[top_types.Mount, OT3Mount], tip_length: float
     ) -> None:
-        await self._pipette_handler.add_tip(OT3Mount.from_mount(mount), tip_length)
+        self._pipette_handler.cache_tip(OT3Mount.from_mount(mount), tip_length)
 
-    async def remove_tip(self, mount: Union[top_types.Mount, OT3Mount]) -> None:
-        await self._pipette_handler.remove_tip(OT3Mount.from_mount(mount))
+    def remove_tip(self, mount: Union[top_types.Mount, OT3Mount]) -> None:
+        self._pipette_handler.remove_tip(OT3Mount.from_mount(mount))
 
     def add_gripper_probe(self, probe: GripperProbe) -> None:
         self._gripper_handler.add_probe(probe)
@@ -2607,17 +2619,17 @@ class OT3API(
         self._gripper_handler.remove_probe()
 
     @staticmethod
-    def liquid_probe_non_responsive_z_distance(z_speed: float) -> float:
+    def liquid_probe_non_responsive_z_distance(
+        z_speed: float, samples_for_baselining: int, sample_time_sec: float
+    ) -> float:
         """Calculate the Z distance travelled where the LLD pass will be unresponsive."""
         # NOTE: (sigler) Here lye some magic numbers.
         #       The Z axis probing motion uses the first 20 samples to calculate
         #       a baseline for all following samples, making the very beginning of
         #       that Z motion unable to detect liquid. The sensor is configured for
         #       4ms sample readings, and so we then assume it takes ~80ms to complete.
-        #       If the Z is moving at 5mm/sec, then ~80ms equates to ~0.4
-        baseline_during_z_sample_num = 20  # FIXME: (sigler) shouldn't be defined here?
-        sample_time_sec = 0.004  # FIXME: (sigler) shouldn't be defined here?
-        baseline_duration_sec = baseline_during_z_sample_num * sample_time_sec
+        #       If the Z is moving at 5mm/sec, then ~80ms equates to ~0.4mm
+        baseline_duration_sec = samples_for_baselining * sample_time_sec
         non_responsive_z_mm = baseline_duration_sec * z_speed
         return non_responsive_z_mm
 
@@ -2628,6 +2640,9 @@ class OT3API(
         probe: InstrumentProbeType,
         p_travel: float,
         force_both_sensors: bool = False,
+        response_queue: Optional[
+            asyncio.Queue[Dict[SensorId, List[SensorDataType]]]
+        ] = None,
     ) -> float:
         plunger_direction = -1 if probe_settings.aspirate_while_sensing else 1
         end_z = await self._backend.liquid_probe(
@@ -2637,10 +2652,10 @@ class OT3API(
             (probe_settings.plunger_speed * plunger_direction),
             probe_settings.sensor_threshold_pascals,
             probe_settings.plunger_impulse_time,
-            probe_settings.output_option,
-            probe_settings.data_files,
+            probe_settings.samples_for_baselining,
             probe=probe,
             force_both_sensors=force_both_sensors,
+            response_queue=response_queue,
         )
         machine_pos = await self._backend.update_position()
         machine_pos[Axis.by_mount(mount)] = end_z
@@ -2654,13 +2669,16 @@ class OT3API(
         cp = self.critical_point_for(mount, None)
         return deck_end_z + offset.z + cp.z
 
-    async def liquid_probe(
+    async def liquid_probe(  # noqa: C901
         self,
         mount: Union[top_types.Mount, OT3Mount],
         max_z_dist: float,
         probe_settings: Optional[LiquidProbeSettings] = None,
         probe: Optional[InstrumentProbeType] = None,
         force_both_sensors: bool = False,
+        response_queue: Optional[
+            asyncio.Queue[Dict[SensorId, List[SensorDataType]]]
+        ] = None,
     ) -> float:
         """Search for and return liquid level height.
 
@@ -2697,7 +2715,6 @@ class OT3API(
             probe_settings = deepcopy(self.config.liquid_sense)
 
         # We need to significatly slow down the 96 channel liquid probe
-        # TODO: (sigler) add LLD plunger-speed to pipette definitions
         if self.gantry_load == GantryLoad.HIGH_THROUGHPUT:
             max_plunger_speed = self.config.motion_settings.max_speed_discontinuity[
                 GantryLoad.HIGH_THROUGHPUT
@@ -2706,59 +2723,79 @@ class OT3API(
                 max_plunger_speed, probe_settings.plunger_speed
             )
 
-        probe_start_pos = await self.gantry_position(checked_mount, refresh=True)
+        starting_position = await self.gantry_position(checked_mount, refresh=True)
 
-        # plunger travel distance is from TOP->BOTTOM (minus the backlash distance + impulse)
-        # FIXME: logic for how plunger moves is divided between here and tool_sensors.py
-        p_impulse_mm = (
+        sensor_baseline_plunger_move_mm = (
             probe_settings.plunger_impulse_time * probe_settings.plunger_speed
         )
-        p_total_mm = (
+        total_plunger_axis_mm = (
             instrument.plunger_positions.bottom - instrument.plunger_positions.top
         )
-
-        p_working_mm = p_total_mm - (instrument.backlash_distance + p_impulse_mm)
-
+        max_allowed_plunger_distance_mm = total_plunger_axis_mm - (
+            instrument.backlash_distance + sensor_baseline_plunger_move_mm
+        )
         # height where probe action will begin
-        # TODO: (sigler) add this to pipette's liquid def (per tip)
-        probe_pass_overlap_mm = 0.1
-        non_responsive_z_mm = OT3API.liquid_probe_non_responsive_z_distance(
-            probe_settings.mount_speed
+        sensor_baseline_z_move_mm = OT3API.liquid_probe_non_responsive_z_distance(
+            probe_settings.mount_speed,
+            probe_settings.samples_for_baselining,
+            probe_settings.sample_time_sec,
+        )
+        z_offset_per_pass = (
+            sensor_baseline_z_move_mm + probe_settings.z_overlap_between_passes_mm
         )
-        probe_pass_z_offset_mm = non_responsive_z_mm + probe_pass_overlap_mm
 
         # height that is considered safe to reset the plunger without disturbing liquid
         # this usually needs to at least 1-2mm from liquid, to avoid splashes from air
-        # TODO: (sigler) add this to pipette's liquid def (per tip)
-        probe_safe_reset_mm = max(2.0, probe_pass_z_offset_mm)
+        z_offset_for_plunger_prep = max(
+            probe_settings.plunger_reset_offset, z_offset_per_pass
+        )
+
+        async def prep_plunger_for_probe_move(
+            position: top_types.Point, aspirate_while_sensing: bool
+        ) -> None:
+            # safe distance so we don't accidentally aspirate liquid if we're already close to liquid
+            mount_pos_for_plunger_prep = top_types.Point(
+                position.x,
+                position.y,
+                position.z + z_offset_for_plunger_prep,
+            )
+            # Prep the plunger
+            await self.move_to(checked_mount, mount_pos_for_plunger_prep)
+            if aspirate_while_sensing:
+                await self._move_to_plunger_bottom(checked_mount, rate=1)
+            else:
+                await self._move_to_plunger_top_for_liquid_probe(checked_mount, rate=1)
 
         error: Optional[PipetteLiquidNotFoundError] = None
-        pos = await self.gantry_position(checked_mount, refresh=True)
-        #  probe_start_pos.z + z_distance of pass - pos.z should be < max_z_dist
+        current_position = await self.gantry_position(checked_mount, refresh=True)
+        #  starting_position.z + z_distance of pass - pos.z should be < max_z_dist
         # due to rounding errors this can get caught in an infinite loop when the distance is almost equal
         # so we check to see if they're within 0.01 which is 1/5th the minimum movement distance from move_utils.py
-        while (probe_start_pos.z - pos.z) < (max_z_dist - 0.01):
-            # safe distance so we don't accidentally aspirate liquid if we're already close to liquid
-            safe_plunger_pos = top_types.Point(
-                pos.x, pos.y, pos.z + probe_safe_reset_mm
+        while (starting_position.z - current_position.z) < (max_z_dist - 0.01):
+            await prep_plunger_for_probe_move(
+                position=current_position,
+                aspirate_while_sensing=probe_settings.aspirate_while_sensing,
             )
+
             # overlap amount we want to use between passes
             pass_start_pos = top_types.Point(
-                pos.x, pos.y, pos.z + probe_pass_z_offset_mm
+                current_position.x,
+                current_position.y,
+                current_position.z + z_offset_per_pass,
             )
-            max_z_time = (
-                max_z_dist - probe_start_pos.z + pass_start_pos.z
-            ) / probe_settings.mount_speed
-            p_travel_required_for_z = max_z_time * probe_settings.plunger_speed
-            p_pass_travel = min(p_travel_required_for_z, p_working_mm)
-            # Prep the plunger
-            await self.move_to(checked_mount, safe_plunger_pos)
-            if probe_settings.aspirate_while_sensing:
-                # TODO(cm, 7/8/24): remove p_prep_speed from the rate at some point
-                await self._move_to_plunger_bottom(checked_mount, rate=1)
-            else:
-                await self._move_to_plunger_top_for_liquid_probe(checked_mount, rate=1)
 
+            total_remaining_z_dist = pass_start_pos.z - (
+                starting_position.z - max_z_dist
+            )
+            finish_probe_move_duration = (
+                total_remaining_z_dist / probe_settings.mount_speed
+            )
+            finish_probe_plunger_distance_mm = (
+                finish_probe_move_duration * probe_settings.plunger_speed
+            )
+            plunger_travel_mm = min(
+                finish_probe_plunger_distance_mm, max_allowed_plunger_distance_mm
+            )
             try:
                 # move to where we want to start a pass and run a pass
                 await self.move_to(checked_mount, pass_start_pos)
@@ -2766,17 +2803,19 @@ class OT3API(
                     checked_mount,
                     probe_settings,
                     checked_probe,
-                    p_pass_travel + p_impulse_mm,
+                    plunger_travel_mm + sensor_baseline_plunger_move_mm,
+                    force_both_sensors,
+                    response_queue,
                 )
                 # if we made it here without an error we found the liquid
                 error = None
                 break
             except PipetteLiquidNotFoundError as lnfe:
                 error = lnfe
-            pos = await self.gantry_position(checked_mount, refresh=True)
-        await self.move_to(checked_mount, probe_start_pos + top_types.Point(z=2))
+            current_position = await self.gantry_position(checked_mount, refresh=True)
+        await self.move_to(checked_mount, starting_position + top_types.Point(z=2))
         await self.prepare_for_aspirate(checked_mount)
-        await self.move_to(checked_mount, probe_start_pos)
+        await self.move_to(checked_mount, starting_position)
         if error is not None:
             # if we never found liquid raise an error
             raise error
@@ -2835,8 +2874,6 @@ class OT3API(
             pass_settings.speed_mm_per_s,
             pass_settings.sensor_threshold_pf,
             probe,
-            pass_settings.output_option,
-            pass_settings.data_files,
         )
         end_pos = await self.gantry_position(mount, refresh=True)
         if retract_after:

opentrons/hardware_control/poller.py

@@ -3,6 +3,7 @@ import contextlib
 import logging
 from abc import ABC, abstractmethod
 from typing import AsyncGenerator, List, Optional
+from opentrons.hardware_control.modules.errors import AbsorbanceReaderDisconnectedError
 from opentrons_shared_data.errors.exceptions import ModuleCommunicationError
 
 
@@ -36,21 +37,20 @@ class Poller:
         self._poll_forever_task: Optional["asyncio.Task[None]"] = None
 
     async def start(self) -> None:
-        assert self._poll_forever_task is None, "Poller already started"
-        self._poll_forever_task = asyncio.create_task(self._poll_forever())
-        await self.wait_next_poll()
+        if self._poll_forever_task is None:
+            self._poll_forever_task = asyncio.create_task(self._poll_forever())
+            await self.wait_next_poll()
 
     async def stop(self) -> None:
         """Stop polling."""
         task = self._poll_forever_task
-
-        assert task is not None, "Poller never started"
-
-        async with self._use_read_lock():
-            task.cancel()
-            await asyncio.gather(task, return_exceptions=True)
-        for waiter in self._poll_waiters:
-            waiter.cancel(msg="Module was removed")
+        if task is not None:
+            async with self._use_read_lock():
+                task.cancel()
+                await asyncio.gather(task, return_exceptions=True)
+            for waiter in self._poll_waiters:
+                waiter.cancel(msg="Module was removed")
+            self._poll_forever_task = None
 
     async def wait_next_poll(self) -> None:
         """Wait for the next poll to complete.
@@ -98,6 +98,10 @@ class Poller:
                 await self._reader.read()
         except asyncio.CancelledError:
             raise
+        except AbsorbanceReaderDisconnectedError as e:
+            for waiter in previous_waiters:
+                Poller._set_waiter_complete(waiter, None)
+            self._reader.on_error(e)
         except Exception as e:
             log.exception("Polling exception")
             self._reader.on_error(e)

opentrons/hardware_control/protocols/__init__.py

@@ -58,9 +58,6 @@ class HardwareControlInterface(
     def get_robot_type(self) -> Type[OT2RobotType]:
         return OT2RobotType
 
-    def cache_tip(self, mount: MountArgType, tip_length: float) -> None:
-        ...
-
 
 class FlexHardwareControlInterface(
     PositionEstimator,
@@ -87,12 +84,9 @@ class FlexHardwareControlInterface(
     def get_robot_type(self) -> Type[FlexRobotType]:
         return FlexRobotType
 
-    def cache_tip(self, mount: MountArgType, tip_length: float) -> None:
-        ...
-
 
 __all__ = [
-    "HardwareControlAPI",
+    "HardwareControlInterface",
     "FlexHardwareControlInterface",
     "Simulatable",
     "Stoppable",

opentrons/hardware_control/protocols/instrument_configurer.py

@@ -142,15 +142,27 @@ class InstrumentConfigurer(Protocol[MountArgType]):
         """
         ...
 
-    async def add_tip(self, mount: MountArgType, tip_length: float) -> None:
+    # todo(mm, 2024-10-17): Consider deleting this in favor of cache_tip()
+    # if we can do so without breaking anything.
+    def add_tip(self, mount: MountArgType, tip_length: float) -> None:
         """Inform the hardware that a tip is now attached to a pipette.
 
+        If a tip is already attached, this no-ops.
+
         This changes the critical point of the pipette to make sure that
         the end of the tip is what moves around, and allows liquid handling.
         """
         ...
 
-    async def remove_tip(self, mount: MountArgType) -> None:
+    def cache_tip(self, mount: MountArgType, tip_length: float) -> None:
+        """Inform the hardware that a tip is now attached to a pipette.
+
+        This is like `add_tip()`, except that if a tip is already attached,
+        this replaces it instead of no-opping.
+        """
+        ...
+
+    def remove_tip(self, mount: MountArgType) -> None:
         """Inform the hardware that a tip is no longer attached to a pipette.
 
         This changes the critical point of the system to the end of the

opentrons/hardware_control/protocols/liquid_handler.py

@@ -164,6 +164,11 @@ class LiquidHandler(
         """
         ...
 
+    async def tip_drop_moves(
+        self, mount: MountArgType, home_after: bool = True
+    ) -> None:
+        ...
+
     async def drop_tip(
         self,
         mount: MountArgType,

opentrons/motion_planning/__init__.py

@@ -6,6 +6,7 @@ from .waypoints import (
     MINIMUM_Z_MARGIN,
     get_waypoints,
     get_gripper_labware_movement_waypoints,
+    get_gripper_labware_placement_waypoints,
 )
 
 from .types import Waypoint, MoveType
@@ -27,4 +28,5 @@ __all__ = [
     "ArcOutOfBoundsError",
     "get_waypoints",
     "get_gripper_labware_movement_waypoints",
+    "get_gripper_labware_placement_waypoints",
 ]

opentrons/motion_planning/waypoints.py

@@ -181,3 +181,35 @@ def get_gripper_labware_movement_waypoints(
             )
         )
     return waypoints_with_jaw_status
+
+
+def get_gripper_labware_placement_waypoints(
+    to_labware_center: Point,
+    gripper_home_z: float,
+    drop_offset: Optional[Point],
+) -> List[GripperMovementWaypointsWithJawStatus]:
+    """Get waypoints for placing labware using a gripper."""
+    drop_offset = drop_offset or Point()
+
+    drop_location = to_labware_center + Point(
+        drop_offset.x, drop_offset.y, drop_offset.z
+    )
+
+    post_drop_home_pos = Point(drop_location.x, drop_location.y, gripper_home_z)
+
+    return [
+        GripperMovementWaypointsWithJawStatus(
+            position=Point(drop_location.x, drop_location.y, gripper_home_z),
+            jaw_open=False,
+            dropping=False,
+        ),
+        GripperMovementWaypointsWithJawStatus(
+            position=drop_location, jaw_open=False, dropping=False
+        ),
+        # Gripper ungrips here
+        GripperMovementWaypointsWithJawStatus(
+            position=post_drop_home_pos,
+            jaw_open=True,
+            dropping=True,
+        ),
+    ]

opentrons/protocol_api/__init__.py

@@ -29,7 +29,7 @@ from .module_contexts import (
     AbsorbanceReaderContext,
 )
 from .disposal_locations import TrashBin, WasteChute
-from ._liquid import Liquid
+from ._liquid import Liquid, LiquidClass
 from ._types import OFF_DECK
 from ._nozzle_layout import (
     COLUMN,
@@ -67,6 +67,7 @@ __all__ = [
     "WasteChute",
     "Well",
     "Liquid",
+    "LiquidClass",
     "Parameters",
     "COLUMN",
     "PARTIAL_COLUMN",