@opentrons/shared-data 0.1.1 → 0.1.2-alpha.1

package/js/helpers/getAddressableAreasInProtocol.ts

@@ -0,0 +1,98 @@
+import { MOVABLE_TRASH_A3_ADDRESSABLE_AREA } from '../constants'
+import { getAddressableAreaFromSlotId } from '../fixtures'
+import type { AddressableAreaName } from '../../deck'
+import type { ProtocolAnalysisOutput } from '../../protocol'
+import type { CompletedProtocolAnalysis, DeckDefinition } from '../types'
+
+export function getAddressableAreasInProtocol(
+  protocolAnalysis: CompletedProtocolAnalysis | ProtocolAnalysisOutput,
+  deckDef: DeckDefinition
+): AddressableAreaName[] {
+  const { commands, labware } = protocolAnalysis
+
+  const addressableAreasFromCommands = commands.reduce<AddressableAreaName[]>(
+    (acc, command) => {
+      if (
+        command.commandType === 'moveLabware' &&
+        command.params.newLocation !== 'offDeck' &&
+        'slotName' in command.params.newLocation &&
+        !acc.includes(
+          command.params.newLocation.slotName as AddressableAreaName
+        )
+      ) {
+        const addressableAreaName = getAddressableAreaFromSlotId(
+          command.params.newLocation.slotName,
+          deckDef
+        )?.id
+
+        if (addressableAreaName == null) {
+          return acc
+        } else {
+          return [...acc, addressableAreaName]
+        }
+      } else if (
+        command.commandType === 'moveLabware' &&
+        command.params.newLocation !== 'offDeck' &&
+        'addressableAreaName' in command.params.newLocation &&
+        !acc.includes(command.params.newLocation.addressableAreaName)
+      ) {
+        return [...acc, command.params.newLocation.addressableAreaName]
+      } else if (
+        (command.commandType === 'loadLabware' ||
+          command.commandType === 'loadModule') &&
+        command.params.location !== 'offDeck' &&
+        'slotName' in command.params.location &&
+        !acc.includes(command.params.location.slotName as AddressableAreaName)
+      ) {
+        const addressableAreaName = getAddressableAreaFromSlotId(
+          command.params.location.slotName,
+          deckDef
+        )?.id
+
+        // do not add addressable area name for legacy trash labware
+        if (
+          addressableAreaName == null ||
+          ('loadName' in command.params &&
+            command.params.loadName === 'opentrons_1_trash_3200ml_fixed')
+        ) {
+          return acc
+        } else {
+          return [...acc, addressableAreaName]
+        }
+      } else if (
+        command.commandType === 'loadLabware' &&
+        command.params.location !== 'offDeck' &&
+        'addressableAreaName' in command.params.location &&
+        !acc.includes(command.params.location.addressableAreaName)
+      ) {
+        return [...acc, command.params.location.addressableAreaName]
+      } else if (
+        command.commandType === 'moveToAddressableArea' &&
+        !acc.includes(command.params.addressableAreaName)
+      ) {
+        return [...acc, command.params.addressableAreaName]
+      } else if (
+        command.commandType === 'moveToAddressableAreaForDropTip' &&
+        !acc.includes(command.params.addressableAreaName)
+      ) {
+        return [...acc, command.params.addressableAreaName]
+      } else {
+        return acc
+      }
+    },
+    []
+  )
+
+  // special-case the Flex trash labware load name in A3 for back compatibility with the legacy fixed trash load labware command
+  const legacyTrashAddressableArea = labware.some(
+    ({ loadName, location }) =>
+      loadName === 'opentrons_1_trash_3200ml_fixed' &&
+      location !== 'offDeck' &&
+      'slotName' in location &&
+      location.slotName === 'A3'
+  )
+    ? MOVABLE_TRASH_A3_ADDRESSABLE_AREA
+    : []
+
+  return addressableAreasFromCommands.concat(legacyTrashAddressableArea)
+}

package/js/helpers/getLoadedLabwareDefinitionsByUri.ts

@@ -0,0 +1,30 @@
+import { getLabwareDefURI } from '.'
+import type { RunTimeCommand, LabwareDefinition2 } from '..'
+
+export interface LabwareDefinitionsByUri {
+  [defURI: string]: LabwareDefinition2
+}
+
+export function getLoadedLabwareDefinitionsByUri(
+  commands: RunTimeCommand[]
+): LabwareDefinitionsByUri {
+  return commands.reduce((acc, command) => {
+    if (command.commandType === 'loadLabware') {
+      const labwareDef: LabwareDefinition2 | undefined =
+        command.result?.definition
+      if (labwareDef == null) {
+        console.warn(
+          `could not find a labware definition in the results of load labware command: ${JSON.stringify(
+            command
+          )}`
+        )
+        return acc
+      } else {
+        const definitionUri = getLabwareDefURI(labwareDef)
+        return { ...acc, [definitionUri]: labwareDef }
+      }
+    } else {
+      return acc
+    }
+  }, {})
+}

package/js/helpers/getModuleVizDims.ts

@@ -0,0 +1,118 @@
+// NOTE: Ian 2019-10-24 these are by-eye numbers that intentionally
+// ignore the real-life data to emphasize overhangs etc
+import {
+  MAGNETIC_MODULE_TYPE,
+  TEMPERATURE_MODULE_TYPE,
+  THERMOCYCLER_MODULE_TYPE,
+  HEATERSHAKER_MODULE_TYPE,
+  STD_SLOT_X_DIM as SLOT_X,
+  STD_SLOT_Y_DIM as SLOT_Y,
+  STD_SLOT_DIVIDER_WIDTH as DIVIDER,
+  SPAN7_8_10_11_SLOT,
+  MAGNETIC_BLOCK_TYPE,
+} from '../constants'
+import { ModuleType, ModuleOrientation } from '../types'
+// NOTE: all dims are in 'left' orientation. Rotate & transform to obtain 'right' orientation.
+
+export interface ModuleVizDims {
+  xOffset: number
+  yOffset: number
+  xDimension: number
+  yDimension: number
+  childXOffset: number
+  childYOffset: number
+  childXDimension: number
+  childYDimension: number
+}
+const MODULE_VIZ_DIMS: Record<ModuleType, ModuleVizDims> = {
+  [MAGNETIC_MODULE_TYPE]: {
+    xOffset: -1 * (SLOT_X * 0.2 + DIVIDER),
+    yOffset: -1 * DIVIDER,
+    xDimension: SLOT_X * 1.2 + DIVIDER * 2,
+    yDimension: SLOT_Y + DIVIDER * 2,
+    childXOffset: 0,
+    childYOffset: 0,
+    childXDimension: SLOT_X,
+    childYDimension: SLOT_Y,
+  },
+  [TEMPERATURE_MODULE_TYPE]: {
+    xOffset: -1 * (SLOT_X * 0.4 + DIVIDER),
+    yOffset: -1 * DIVIDER,
+    xDimension: SLOT_X * 1.4 + DIVIDER * 2,
+    yDimension: SLOT_Y + DIVIDER * 2,
+    childXOffset: 0,
+    childYOffset: 0,
+    childXDimension: SLOT_X,
+    childYDimension: SLOT_Y,
+  },
+  [THERMOCYCLER_MODULE_TYPE]: {
+    xOffset: -8,
+    yOffset: 0,
+    xDimension: SLOT_X + DIVIDER + 32,
+    yDimension: SLOT_Y * 2.4,
+    childXOffset: 12,
+    childYOffset: SLOT_Y,
+    childXDimension: SLOT_X,
+    childYDimension: SLOT_Y,
+  },
+  // TODO(sh, 2022-02-28): This is stubbed out using magdeck dimensions, all of this logic should be deprecated
+  [HEATERSHAKER_MODULE_TYPE]: {
+    xOffset: -1 * (SLOT_X * 0.2 + DIVIDER),
+    yOffset: -1 * DIVIDER,
+    xDimension: SLOT_X * 1.2 + DIVIDER * 2,
+    yDimension: SLOT_Y + DIVIDER * 2,
+    childXOffset: 0,
+    childYOffset: 0,
+    childXDimension: SLOT_X,
+    childYDimension: SLOT_Y,
+  },
+  // TODO(sh, 2022-02-28): This is stubbed out using magdeck dimensions, all of this logic should be deprecated
+  [MAGNETIC_BLOCK_TYPE]: {
+    xOffset: -1 * (SLOT_X * 0.2 + DIVIDER),
+    yOffset: -1 * DIVIDER,
+    xDimension: SLOT_X * 1.2 + DIVIDER * 2,
+    yDimension: SLOT_Y + DIVIDER * 2,
+    childXOffset: 0,
+    childYOffset: 0,
+    childXDimension: SLOT_X,
+    childYDimension: SLOT_Y,
+  },
+}
+export const getModuleVizDims = (
+  orientation: ModuleOrientation,
+  moduleType: ModuleType
+): ModuleVizDims => {
+  const dims = MODULE_VIZ_DIMS[moduleType]
+  if (orientation === 'left') return dims
+  // if orientation is 'right', get origins by rotating 180 about slot center
+  return {
+    ...dims,
+    xOffset: SLOT_X - dims.xOffset - dims.xDimension,
+    yOffset: SLOT_Y - dims.yOffset - dims.yDimension,
+    childXOffset: SLOT_X - dims.childXOffset - dims.childXDimension,
+    childYOffset: SLOT_Y - dims.childYOffset - dims.childYDimension,
+  }
+}
+type DeckSlot = string
+const LEFT_SIDE_SLOTS: DeckSlot[] = ['1', '4', '7', '10', SPAN7_8_10_11_SLOT]
+export const inferModuleOrientationFromSlot = (
+  slot: DeckSlot
+): ModuleOrientation => {
+  // NOTE: defaults to 'left' even for center slots and spanning slots.
+  // That's consistent with non-rotatable modules (thermocycler) being
+  // considered as 'left' all the time, like we do in MODULE_VIZ_DIMS.
+  if (!LEFT_SIDE_SLOTS.includes(slot)) {
+    return 'right'
+  }
+
+  return 'left'
+}
+
+export const inferModuleOrientationFromXCoordinate = (
+  xCoordinate: number
+): ModuleOrientation => {
+  if (xCoordinate === 0) {
+    return 'left'
+  }
+  return 'right'
+}

package/js/helpers/getOccludedSlotCountForModule.ts

@@ -0,0 +1,13 @@
+import { OT2_ROBOT_TYPE, THERMOCYCLER_MODULE_TYPE } from '..'
+import type { ModuleType, RobotType } from '..'
+
+export function getOccludedSlotCountForModule(
+  moduleType: ModuleType,
+  robotType: RobotType
+): number {
+  if (moduleType === THERMOCYCLER_MODULE_TYPE) {
+    return robotType === OT2_ROBOT_TYPE ? 4 : 2
+  } else {
+    return 1
+  }
+}

package/js/helpers/getSimplestFlexDeckConfig.ts

@@ -0,0 +1,183 @@
+import { FLEX_ROBOT_TYPE } from '../constants'
+import { getAddressableAreaFromSlotId } from '../fixtures'
+import { getAddressableAreasInProtocol, getDeckDefFromRobotType } from '.'
+
+import type { AddressableAreaName, CutoutId } from '../../deck'
+import type { ProtocolAnalysisOutput } from '../../protocol'
+import type {
+  CutoutConfig,
+  CutoutFixture,
+  DeckDefinition,
+  DeckConfiguration,
+  CompletedProtocolAnalysis,
+} from '../types'
+
+export interface CutoutConfigProtocolSpec extends CutoutConfig {
+  requiredAddressableAreas: AddressableAreaName[]
+}
+
+export const FLEX_SIMPLEST_DECK_CONFIG: DeckConfiguration = [
+  { cutoutId: 'cutoutA1', cutoutFixtureId: 'singleLeftSlot' },
+  { cutoutId: 'cutoutB1', cutoutFixtureId: 'singleLeftSlot' },
+  { cutoutId: 'cutoutC1', cutoutFixtureId: 'singleLeftSlot' },
+  { cutoutId: 'cutoutD1', cutoutFixtureId: 'singleLeftSlot' },
+  { cutoutId: 'cutoutA2', cutoutFixtureId: 'singleCenterSlot' },
+  { cutoutId: 'cutoutB2', cutoutFixtureId: 'singleCenterSlot' },
+  { cutoutId: 'cutoutC2', cutoutFixtureId: 'singleCenterSlot' },
+  { cutoutId: 'cutoutD2', cutoutFixtureId: 'singleCenterSlot' },
+  { cutoutId: 'cutoutA3', cutoutFixtureId: 'singleRightSlot' },
+  { cutoutId: 'cutoutB3', cutoutFixtureId: 'singleRightSlot' },
+  { cutoutId: 'cutoutC3', cutoutFixtureId: 'singleRightSlot' },
+  { cutoutId: 'cutoutD3', cutoutFixtureId: 'singleRightSlot' },
+]
+
+export const FLEX_SIMPLEST_DECK_CONFIG_PROTOCOL_SPEC: CutoutConfigProtocolSpec[] = FLEX_SIMPLEST_DECK_CONFIG.map(
+  config => ({ ...config, requiredAddressableAreas: [] })
+)
+
+export function getSimplestDeckConfigForProtocol(
+  protocolAnalysis: CompletedProtocolAnalysis | ProtocolAnalysisOutput | null
+): CutoutConfigProtocolSpec[] {
+  // TODO(BC, 2023-11-06): abstract out the robot type
+  const deckDef = getDeckDefFromRobotType(FLEX_ROBOT_TYPE)
+
+  const addressableAreas =
+    protocolAnalysis != null
+      ? getAddressableAreasInProtocol(protocolAnalysis, deckDef)
+      : []
+  const simplestDeckConfig = addressableAreas.reduce<
+    CutoutConfigProtocolSpec[]
+  >((acc, addressableArea) => {
+    const cutoutFixturesForAddressableArea = getCutoutFixturesForAddressableAreas(
+      [addressableArea],
+      deckDef.cutoutFixtures
+    )
+    const cutoutIdForAddressableArea = getCutoutIdForAddressableArea(
+      addressableArea,
+      cutoutFixturesForAddressableArea
+    )
+    const cutoutFixturesForCutoutId =
+      cutoutIdForAddressableArea != null
+        ? getCutoutFixturesForCutoutId(
+            cutoutIdForAddressableArea,
+            deckDef.cutoutFixtures
+          )
+        : null
+
+    const existingCutoutConfig = acc.find(
+      cutoutConfig => cutoutConfig.cutoutId === cutoutIdForAddressableArea
+    )
+
+    if (
+      existingCutoutConfig != null &&
+      cutoutFixturesForCutoutId != null &&
+      cutoutIdForAddressableArea != null
+    ) {
+      const indexOfExistingFixture = cutoutFixturesForCutoutId.findIndex(
+        ({ id }) => id === existingCutoutConfig.cutoutFixtureId
+      )
+      const accIndex = acc.findIndex(
+        ({ cutoutId }) => cutoutId === cutoutIdForAddressableArea
+      )
+      const previousRequiredAAs = acc[accIndex]?.requiredAddressableAreas
+      const allNextRequiredAddressableAreas = previousRequiredAAs.includes(
+        addressableArea
+      )
+        ? previousRequiredAAs
+        : [...previousRequiredAAs, addressableArea]
+      const nextCompatibleCutoutFixture = getSimplestFixtureForAddressableAreas(
+        cutoutIdForAddressableArea,
+        allNextRequiredAddressableAreas,
+        cutoutFixturesForCutoutId
+      )
+      const indexOfCurrentFixture = cutoutFixturesForCutoutId.findIndex(
+        ({ id }) => id === nextCompatibleCutoutFixture?.id
+      )
+
+      if (
+        nextCompatibleCutoutFixture != null &&
+        indexOfCurrentFixture > indexOfExistingFixture
+      ) {
+        return [
+          ...acc.slice(0, accIndex),
+          {
+            cutoutId: cutoutIdForAddressableArea,
+            cutoutFixtureId: nextCompatibleCutoutFixture.id,
+            requiredAddressableAreas: allNextRequiredAddressableAreas,
+          },
+          ...acc.slice(accIndex + 1),
+        ]
+      }
+    }
+    return acc
+  }, FLEX_SIMPLEST_DECK_CONFIG_PROTOCOL_SPEC)
+
+  return simplestDeckConfig
+}
+
+export function getCutoutFixturesForAddressableAreas(
+  addressableAreas: AddressableAreaName[],
+  cutoutFixtures: CutoutFixture[]
+): CutoutFixture[] {
+  return cutoutFixtures.filter(cutoutFixture =>
+    Object.values(cutoutFixture.providesAddressableAreas).some(providedAAs =>
+      addressableAreas.every(aa => providedAAs.includes(aa))
+    )
+  )
+}
+
+export function getCutoutFixturesForCutoutId(
+  cutoutId: CutoutId,
+  cutoutFixtures: CutoutFixture[]
+): CutoutFixture[] {
+  return cutoutFixtures.filter(cutoutFixture =>
+    cutoutFixture.mayMountTo.some(mayMountTo => mayMountTo.includes(cutoutId))
+  )
+}
+
+export function getCutoutIdForSlotName(
+  slotName: string,
+  deckDef: DeckDefinition
+): CutoutId | null {
+  const addressableArea = getAddressableAreaFromSlotId(slotName, deckDef)
+  const cutoutIdForSlotName =
+    addressableArea != null
+      ? getCutoutIdForAddressableArea(
+          addressableArea.id,
+          deckDef.cutoutFixtures
+        )
+      : null
+
+  return cutoutIdForSlotName
+}
+
+export function getCutoutIdForAddressableArea(
+  addressableArea: AddressableAreaName,
+  cutoutFixtures: CutoutFixture[]
+): CutoutId | null {
+  return cutoutFixtures.reduce<CutoutId | null>((acc, cutoutFixture) => {
+    const [cutoutId] =
+      Object.entries(
+        cutoutFixture.providesAddressableAreas
+      ).find(([_cutoutId, providedAAs]) =>
+        providedAAs.includes(addressableArea)
+      ) ?? []
+    return (cutoutId as CutoutId) ?? acc
+  }, null)
+}
+
+export function getSimplestFixtureForAddressableAreas(
+  cutoutId: CutoutId,
+  requiredAddressableAreas: AddressableAreaName[],
+  allCutoutFixtures: CutoutFixture[]
+): CutoutFixture | null {
+  const cutoutFixturesForCutoutId = getCutoutFixturesForCutoutId(
+    cutoutId,
+    allCutoutFixtures
+  )
+  const nextCompatibleCutoutFixtures = getCutoutFixturesForAddressableAreas(
+    requiredAddressableAreas,
+    cutoutFixturesForCutoutId
+  )
+  return nextCompatibleCutoutFixtures?.[0] ?? null
+}

package/js/helpers/getVectorDifference.ts

@@ -0,0 +1,12 @@
+import type { Coordinates } from '../types'
+
+export function getVectorDifference(
+  pointA: Coordinates,
+  pointB: Coordinates
+): Coordinates {
+  return {
+    x: pointA.x - pointB.x,
+    y: pointA.y - pointB.y,
+    z: pointA.z - pointB.z,
+  }
+}

package/js/helpers/getVectorSum.ts

@@ -0,0 +1,12 @@
+import type { Coordinates } from '../types'
+
+export function getVectorSum(
+  pointA: Coordinates,
+  pointB: Coordinates
+): Coordinates {
+  return {
+    x: pointA.x + pointB.x,
+    y: pointA.y + pointB.y,
+    z: pointA.z + pointB.z,
+  }
+}

package/js/helpers/getWellNamePerMultiTip.ts

@@ -0,0 +1,86 @@
+import range from 'lodash/range'
+import { get96Channel384WellPlateWells } from './get96Channel384WellPlateWells'
+import { getLabwareHasQuirk, orderWells, sortWells } from './index'
+import type { LabwareDefinition2 } from '../types'
+
+// TODO Ian 2018-03-13 pull pipette offsets/positions from some pipette definitions data
+const OFFSET_8_CHANNEL = 9 // offset in mm between tips
+
+const MULTICHANNEL_TIP_SPAN = OFFSET_8_CHANNEL * (8 - 1) // length in mm from first to last tip of multichannel
+
+export function findWellAt(
+  labwareDef: LabwareDefinition2,
+  x: number,
+  y: number
+): string | null | undefined {
+  return Object.keys(labwareDef.wells)
+    .sort(sortWells)
+    .find((wellName: string) => {
+      const well = labwareDef.wells[wellName]
+
+      if (well.shape === 'circular') {
+        return (
+          Math.sqrt(Math.pow(x - well.x, 2) + Math.pow(y - well.y, 2)) <
+          well.diameter / 2
+        )
+      }
+
+      // Not circular, must be a rectangular well
+      // For rectangular wells, (x, y) is at the center.
+      return (
+        Math.abs(x - well.x) < well.xDimension / 2 &&
+        Math.abs(y - well.y) < well.yDimension / 2
+      )
+    })
+}
+
+// "topWellName" means well at the "top" of the column we're accessing: usually A row, or B row for 384-format
+export function getWellNamePerMultiTip(
+  labwareDef: LabwareDefinition2,
+  topWellName: string,
+  channels: 8 | 96
+): string[] | null {
+  const topWell = labwareDef.wells[topWellName]
+  if (!topWell) {
+    console.warn(
+      `well "${topWellName}" does not exist in labware ${labwareDef?.namespace}/${labwareDef?.parameters?.loadName}, cannot getWellNamePerMultiTip`
+    )
+    return null
+  }
+
+  const { x, y } = topWell
+  let offsetYTipPositions: number[] = range(0, 8).map(
+    tipNo => y - tipNo * OFFSET_8_CHANNEL
+  )
+  const orderedWells = orderWells(labwareDef.ordering, 't2b', 'l2r')
+
+  if (getLabwareHasQuirk(labwareDef, 'centerMultichannelOnWells')) {
+    // move multichannel up in Y by half the pipette's tip span to center it in the well
+    offsetYTipPositions = offsetYTipPositions.map(
+      tipPosY => tipPosY + MULTICHANNEL_TIP_SPAN / 2
+    )
+  }
+  // Return null for containers with any undefined wells
+  const wellsAccessed = offsetYTipPositions.reduce(
+    (acc: string[] | null, tipPosY) => {
+      const wellForTip = findWellAt(labwareDef, x, tipPosY)
+      if (acc === null || !wellForTip) {
+        return null
+      }
+      return acc.concat(wellForTip)
+    },
+    []
+  )
+
+  let ninetySixChannelWells = orderedWells
+  //  special casing 384 well plates to be every other well
+  //  both on the x and y ases.
+  if (orderedWells.length === 384) {
+    ninetySixChannelWells = get96Channel384WellPlateWells(
+      orderedWells,
+      topWellName
+    )
+  }
+
+  return channels === 8 ? wellsAccessed : ninetySixChannelWells
+}

package/js/helpers/getWellTotalVolume.ts

@@ -0,0 +1,16 @@
+import type { LabwareDefinition2 } from '../types'
+export const getWellTotalVolume = (
+  labwareDef: LabwareDefinition2,
+  wellName: string
+): number | null | undefined => {
+  const well = labwareDef.wells[wellName]
+
+  if (!well) {
+    console.warn(
+      `No well "${wellName}" found for labware ${labwareDef?.namespace}/${labwareDef?.parameters?.loadName}/${labwareDef?.version}"`
+    )
+    return null
+  }
+
+  return well.totalLiquidVolume
+}