@opentrons/shared-data 0.1.2-alpha.2 → 0.1.2

package/js/helpers/getAddressableAreasInProtocol.ts

@@ -1,98 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,118 +0,0 @@
-// 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

@@ -1,13 +0,0 @@
-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

@@ -1,183 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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
-}