From 7ea71d60692b28e025ef1bfc4f07b3a958b40f5b Mon Sep 17 00:00:00 2001 From: Tony Ngumah Date: Tue, 3 Dec 2024 12:05:51 -0500 Subject: [PATCH 1/3] fix(abr_testing): fix to abr12 and abr6 liquid setup protocols --- .../12_KAPA HyperPlus Library Prep.py | 413 ++++-------------- ...APA HyperPlus Library Prep Liquid Setup.py | 63 ++- .../6_Omega_HDQ_DNA_Cells Liquid Setup.py | 92 ++++ 3 files changed, 218 insertions(+), 350 deletions(-) create mode 100644 abr-testing/abr_testing/protocols/liquid_setups/6_Omega_HDQ_DNA_Cells Liquid Setup.py diff --git a/abr-testing/abr_testing/protocols/active_protocols/12_KAPA HyperPlus Library Prep.py b/abr-testing/abr_testing/protocols/active_protocols/12_KAPA HyperPlus Library Prep.py index 79414e13765..2495d6d881e 100644 --- a/abr-testing/abr_testing/protocols/active_protocols/12_KAPA HyperPlus Library Prep.py +++ b/abr-testing/abr_testing/protocols/active_protocols/12_KAPA HyperPlus Library Prep.py @@ -14,7 +14,7 @@ MagneticBlockContext, ThermocyclerContext, ) -from typing import List, Tuple, Optional +from typing import List, Tuple, Dict metadata = { "protocolName": "KAPA HyperPlus Library Preparation", @@ -23,17 +23,6 @@ requirements = {"robotType": "Flex", "apiLevel": "2.21"} -tt_50 = 0 -tt_200 = 0 -p50_rack_count = 0 -p200_rack_count = 0 -tip50 = 50 -tip200 = 200 -p50_racks_ondeck = [] -p200_racks_ondeck = [] -p50_racks_offdeck = [] -p200_racks_offdeck = [] - def add_parameters(parameters: ParameterContext) -> None: """Parameters.""" @@ -56,7 +45,7 @@ def add_parameters(parameters: ParameterContext) -> None: variable_name="num_samples", display_name="number of samples", description="How many samples to be perform for library prep", - default=8, + default=48, minimum=8, maximum=48, ) @@ -73,7 +62,7 @@ def add_parameters(parameters: ParameterContext) -> None: variable_name="Fragmentation_time", display_name="time on thermocycler", description="Fragmentation time in thermocycler", - default=10, + default=30, minimum=10, maximum=30, ) @@ -155,54 +144,36 @@ def run(ctx: ProtocolContext) -> None: samples_2 = sample_plate_2.rows()[0][:num_cols] samples = sample_plate.rows()[0][:num_cols] reservoir = ctx.load_labware("nest_96_wellplate_2ml_deep", "C2") + # Load tipracks + tiprack_50_1 = ctx.load_labware("opentrons_flex_96_tiprack_50ul", "A3") + tiprack_50_2 = ctx.load_labware("opentrons_flex_96_tiprack_50ul", "A2") + + tiprack_200_1 = ctx.load_labware("opentrons_flex_96_tiprack_200ul", "C1") + tiprack_200_2 = ctx.load_labware("opentrons_flex_96_tiprack_200ul", "C3") + + if trash_tips: + ctx.load_waste_chute() - trash = ctx.load_waste_chute() unused_lids: List[Labware] = [] # Load TC Lids if disposable_lid: - unused_lids = helpers.load_disposable_lids(ctx, 5, ["C3"], deck_riser) + unused_lids = helpers.load_disposable_lids(ctx, 5, ["C4"], deck_riser) # Import Global Variables global tip50 global tip200 global p50_rack_count global p200_rack_count - global tt_50 - global tt_200 - - p200 = ctx.load_instrument("flex_8channel_1000", pipette_1000_mount) - p50 = ctx.load_instrument("flex_8channel_50", pipette_50_mount) - - Available_on_deck_slots = ["A2", "A3", "B3"] - Available_off_deck_slots = ["A4", "B4"] - p50_racks_to_dump = [] - p200_racks_to_dump = [] - - if REUSE_RSB_TIPS: - Available_on_deck_slots.remove("A3") - tip50_reuse = ctx.load_labware("opentrons_flex_96_tiprack_50ul", "A3") - RSB_tip = [] - p50_rack_count += 1 - tt_50 += 12 - p50.tip_racks.append(tip50_reuse) - ctx.comment(f"Adding 50 ul tip rack #{p50_rack_count}") - for x in range(num_cols): - RSB_tip.append(tip50_reuse.wells()[8 * x]) - tt_50 -= 1 - p50.starting_tip = tip50_reuse.wells()[(len(RSB_tip)) * 8] - - if REUSE_REMOVE_TIPS: - Available_on_deck_slots.remove("A2") - tip200_reuse = ctx.load_labware("opentrons_flex_96_tiprack_200ul", "A2") - RemoveSup_tip = [] - p200_rack_count += 1 - tt_200 += 12 - p200.tip_racks.append(tip200_reuse) - ctx.comment(f"Adding 200 ul tip rack #{p200_rack_count}") - for x in range(num_cols): - RemoveSup_tip.append(tip200_reuse.wells()[8 * x]) - tt_200 -= 1 - p200.starting_tip = tip200_reuse.wells()[(len(RemoveSup_tip)) * 8] + tip_count = {1000: 0, 50: 0} + + p200 = ctx.load_instrument( + "flex_8channel_1000", + pipette_1000_mount, + tip_racks=[tiprack_200_1, tiprack_200_2], + ) + p50 = ctx.load_instrument( + "flex_8channel_50", pipette_50_mount, tip_racks=[tiprack_50_1, tiprack_50_2] + ) # Load Reagent Locations in Reservoirs lib_amplification_wells: List[Well] = temp_plate.columns()[num_cols + 3] @@ -226,53 +197,23 @@ def run(ctx: ProtocolContext) -> None: etoh2 = reservoir.columns()[5] etoh2_res = etoh2[0] - liquid_vols_and_wells = { - "Samples": [ - {"well": sample_plate.wells()[: 8 * num_cols], "volume": sample_vol} - ], + liquid_vols_and_wells: Dict[str, List[Dict[str, Well | List[Well] | float]]] = { + "Samples": [{"well": sample_plate.wells()[: 8 * num_cols], "volume": 35.0}], "Final Library": [ - {"well": sample_plate_2.wells()[: 8 * num_cols], "volume": elution_vol_2} + {"well": sample_plate_2.wells()[: 8 * num_cols], "volume": 17.0} ], - "Adapters": [{"well": adapters, "volume": adapter_vol * 2.0}], + "Adapters": [{"well": adapters, "volume": 10.0}], "End Repair Mix": [ - { - "well": end_repair_cols, - "volume": (end_repair_vol * num_cols) + (0.1 * end_repair_vol), - } - ], - "Fragmentation Mix": [ - {"well": frag, "volume": (frag_vol * num_cols) + (0.1 * frag_vol)} - ], - "Ligation Mix": [ - { - "well": ligation, - "volume": (ligation_vol * num_cols) + (0.1 * ligation_vol), - } - ], - "Amplification Mix": [ - { - "well": lib_amplification_wells, - "volume": (amplification_vol * num_cols) + (0.1 * amplification_vol), - } - ], - "Ampure Beads": [ - { - "well": bead, - "volume": (bead_vol * num_cols) + (0.1 * bead_vol * num_cols), - } - ], - "Resuspension Buffer": [ - {"well": rsb, "volume": (rsb_vol * num_cols) + (0.1 * rsb_vol * num_cols)} + {"well": temp_plate.wells()[: 8 * num_cols], "volume": 61.0} ], + "Fragmentation Mix": [{"well": frag, "volume": 91.5}], + "Ligation Mix": [{"well": ligation, "volume": 200.0}], + "Amplification Mix": [{"well": lib_amplification_wells, "volume": 183.0}], + "Ampure Beads": [{"well": bead, "volume": 910.8}], + "Resuspension Buffer": [{"well": rsb, "volume": 297.0}], "Ethanol 80%": [ - { - "well": etoh1, - "volume": (etoh_vol * num_cols) + (0.1 * etoh_vol * num_cols), - }, - { - "well": etoh2, - "volume": (etoh_vol * num_cols) + (0.1 * etoh_vol * num_cols), - }, + {"well": etoh1, "volume": 2000.0}, + {"well": etoh2, "volume": 2000.0}, ], } waste1 = reservoir.columns()[6] @@ -281,213 +222,24 @@ def run(ctx: ProtocolContext) -> None: waste2 = reservoir.columns()[7] waste2_res = waste2[0] - def tiptrack(rack: int, reuse_col: Optional[int], reuse: bool = False) -> None: - """Tip Track.""" - global tt_50 - global tt_200 - global p50_racks_ondeck - global p200_racks_ondeck - global p50_racks_offdeck - global p200_racks_offdeck - global p50_rack_count - global p200_rack_count - - if rack == tip50: - if ( - tt_50 == 0 and not reuse - ): # If this is the first column of tip box and these aren't reused tips - ctx.comment("Troubleshoot") - if len(Available_on_deck_slots) > 0: - avail_slot = Available_on_deck_slots[0] - p50_rack_count += 1 - tt_50 += 12 - addtiprack = ctx.load_labware( - "opentrons_flex_96_tiprack_50ul", - avail_slot, - f"50 ul Tip Rack #{p50_rack_count}", - ) - ctx.comment( - f"Add 50 ul tip rack #{p50_rack_count} to slot {avail_slot}." - ) - Available_on_deck_slots.pop(0) - p50_racks_ondeck.append(addtiprack) - p50_racks_to_dump.append(addtiprack) - p50.tip_racks.append(addtiprack) - elif ( - len(Available_on_deck_slots) == 0 - and len(Available_off_deck_slots) > 0 - ): - p50_rack_count += 1 - tt_50 += 12 - addtiprack = ctx.load_labware( - "opentrons_flex_96_tiprack_50ul", - Available_off_deck_slots[0], - f"50 ul Tip Rack #{p50_rack_count}", - ) - Available_off_deck_slots.pop( - 0 - ) # Load rack into staging area slot to be moved on deck - ctx.comment(f"Adding 50 ul tip rack #{p50_rack_count}") - p50_racks_offdeck.append( - addtiprack - ) # used in TipSwap then deleted once it is moved - p50.tip_racks.append( - addtiprack - ) # lets pipette know it can use this rack now - TipSwap( - 50 - ) # Throw first tip box out and replace with a box from staging area - elif ( - len(Available_on_deck_slots) == 0 - and len(Available_off_deck_slots) == 0 - ): # If there are no tip racks on deck or in staging area to use - ctx.pause("Please place a new 50ul Tip Rack in slot A4") - p50_rack_count += 1 - tt_50 += 12 - addtiprack = ctx.load_labware( - "opentrons_flex_96_tiprack_50ul", - "A4", - f"50 ul Tip Rack #{p50_rack_count}", - ) - ctx.comment(f"Adding 50 ul tip rack #{p50_rack_count}") - p50_racks_offdeck.append( - addtiprack - ) # used in TipSwap, then deleted once it is moved - p50.tip_racks.append( - addtiprack - ) # lets pipette know it can use this rack now - TipSwap( - 50 - ) # Throw first tip box out and replace with a box from staging area - # Call where tips will actually be picked up - if reuse and REUSE_RSB_TIPS and reuse_col: - p50.pick_up_tip(tip50_reuse.wells()[8 * reuse_col]) - else: - tt_50 -= 1 - ctx.comment("Column " + str(12 - tt_50)) - ctx.comment( - "Available On Deck Slots:" + str(len(Available_on_deck_slots)) - ) - ctx.comment( - "Available Off Deck Slots:" + str(len(Available_off_deck_slots)) - ) - p50.pick_up_tip() - - if rack == tip200: - if ( - tt_200 == 0 and not reuse - ): # If this is the first column of tip box and these aren't reused tips - if len(Available_on_deck_slots) > 0: - avail_slot = Available_on_deck_slots[0] - p200_rack_count += 1 - tt_200 += 12 - addtiprack = ctx.load_labware( - "opentrons_flex_96_tiprack_200ul", - avail_slot, - f"200 ul Tip Rack #{p200_rack_count}", - ) - ctx.comment( - f"Adding 200 ul tip rack #{p200_rack_count} to slot {avail_slot}" - ) - Available_on_deck_slots.pop(0) - p200_racks_ondeck.append(addtiprack) - p200_racks_to_dump.append(addtiprack) - p200.tip_racks.append(addtiprack) - elif ( - len(Available_on_deck_slots) == 0 - and len(Available_off_deck_slots) > 0 - ): - p200_rack_count += 1 - tt_200 += 12 - addtiprack = ctx.load_labware( - "opentrons_flex_96_tiprack_200ul", - Available_off_deck_slots[0], - f"200 ul Tip Rack #{p200_rack_count}", - ) - Available_off_deck_slots.pop( - 0 - ) # Load rack into staging area slot to be moved on deck - ctx.comment(f"Adding 200 ul tip rack #{p200_rack_count}") - p200_racks_offdeck.append( - addtiprack - ) # used in TipSwap then deleted once it is moved - p200.tip_racks.append( - addtiprack - ) # lets pipette know it can use this rack now - TipSwap( - 200 - ) # Throw first tip box out and replace with a box from staging area - elif ( - len(Available_on_deck_slots) == 0 - and len(Available_off_deck_slots) == 0 - ): # If there are no tip racks on deck or in staging area to use - ctx.pause("Please place a new 200ul Tip Rack in slot B4") - p200_rack_count += 1 - tt_200 += 12 - addtiprack = ctx.load_labware( - "opentrons_flex_96_tiprack_200ul", - "B4", - f"200 ul Tip Rack #{p200_rack_count}", - ) - ctx.comment(f"Adding 200 ul tip rack #{p200_rack_count}") - p200_racks_offdeck.append( - addtiprack - ) # used in TipSwap, then deleted once it is moved - p200.tip_racks.append( - addtiprack - ) # lets pipette know it can use this rack now - TipSwap( - 200 - ) # Throw first tip box out and replace with a box from staging area - # Call where tips will actually be picked up - if reuse and REUSE_REMOVE_TIPS and reuse_col: - p200.pick_up_tip(tip200_reuse.wells()[8 * reuse_col]) - else: - tt_200 -= 1 - ctx.comment("Column " + str(12 - tt_200)) - ctx.comment( - "Available On Deck Slots:" + str(len(Available_on_deck_slots)) - ) - ctx.comment( - "Available Off Deck Slots:" + str(len(Available_off_deck_slots)) - ) - p200.pick_up_tip() - - tiptrack(tip50, None, reuse=False) - p50.return_tip() helpers.find_liquid_height_of_loaded_liquids(ctx, liquid_vols_and_wells, p50) - def TipSwap(tipvol: int) -> None: - """Tip swap.""" - if tipvol == 50: - rack_to_dispose = p50_racks_to_dump[0] - rack_to_add = p50_racks_offdeck[0] - deck_slot = p50_racks_to_dump[0].parent - p50_racks_ondeck.append(rack_to_add) - p50_racks_to_dump.pop(0) - p50_racks_to_dump.append(rack_to_add) - p50_racks_ondeck.pop(0) - p50_racks_offdeck.pop(0) - - if tipvol == 200: - rack_to_dispose = p200_racks_to_dump[0] - rack_to_add = p200_racks_offdeck[0] - deck_slot = p200_racks_to_dump[0].parent - p200_racks_ondeck.append(rack_to_add) - p200_racks_to_dump.pop(0) - p200_racks_to_dump.append(rack_to_add) - p200_racks_ondeck.pop(0) - p200_racks_offdeck.pop(0) - - ctx.move_labware( - labware=rack_to_dispose, new_location=trash, use_gripper=USE_GRIPPER - ) - ctx.move_labware( - labware=rack_to_add, new_location=deck_slot, use_gripper=USE_GRIPPER - ) - ctx.comment( - f"Threw out: {rack_to_dispose} and placed {rack_to_add} to {deck_slot}" - ) + def tip_track(pipette: InstrumentContext, tip_count: Dict) -> None: + """Track tip usage.""" + # Get the current tip count for the pipette + current_tips = tip_count[pipette.max_volume] + + # Check if tip count exceeds the maximum tips per rack + if current_tips >= (96 * 2): + tip_count[pipette.max_volume] = 0 + pipette.reset_tipracks() + + # Pick up a new tip and update the count + if not pipette._has_tip: + pipette.pick_up_tip() + tip_count[ + pipette.max_volume + ] += 8 # Adjust increment based on multi-channel pipette def run_tag_profile( unused_lids: List[Labware], used_lids: List[Labware] @@ -517,7 +269,7 @@ def run_tag_profile( if disposable_lid: if len(used_lids) <= 1: - ctx.move_labware(lid_on_plate, "C4", use_gripper=True) + ctx.move_labware(lid_on_plate, "D4", use_gripper=True) else: ctx.move_labware(lid_on_plate, used_lids[-2], use_gripper=True) # #Move Plate to H-S @@ -691,7 +443,8 @@ def mix_beads( loc8 = res.bottom().move(types.Point(x=move / 2, y=-move / 2, z=5)) loc = [loc_center_d, loc1, loc5, loc2, loc6, loc3, loc7, loc4, loc8] - + if not pip._has_tip: + tip_track(pip, tip_count) pip.aspirate( mix_vol, res.bottom().move(types.Point(x=0, y=0, z=10)) ) # Blow bubbles to start @@ -712,8 +465,8 @@ def remove_supernatant(well: Well, vol: float, waste_: Well, column: int) -> Non p200.flow_rate.aspirate = 15 num_trans = math.ceil(vol / 190) vol_per_trans = vol / num_trans + tip_track(p200, tip_count) for x in range(num_trans): - tiptrack(tip200, column, reuse=True if REUSE_REMOVE_TIPS else False) p200.aspirate(vol_per_trans / 2, well.bottom(0.2)) ctx.delay(seconds=1) p200.aspirate(vol_per_trans / 2, well.bottom(0.2)) @@ -742,8 +495,8 @@ def Fragmentation( ctx.comment("Mixing and Transfering beads to column " + str(i + 1)) - tiptrack(tip50, None, reuse=False) p50.flow_rate.dispense = 15 + tip_track(p50, tip_count) p50.aspirate(frag_vol, frag_res) p50.dispense(p50.current_volume, samples[i]) p50.flow_rate.dispense = 150 @@ -779,8 +532,8 @@ def end_repair( "**** Mixing and Transfering beads to column " + str(i + 1) + " ****" ) - tiptrack(tip50, None, reuse=False) p50.flow_rate.dispense = 15 + tip_track(p50, tip_count) p50.aspirate(end_repair_vol, er_res) p50.dispense(p50.current_volume, samples[i]) p50.flow_rate.dispense = 150 @@ -813,7 +566,7 @@ def index_ligation( ctx.comment("-------Ligating Indexes-------") ctx.comment("-------Adding and Mixing ELM-------") for i in samples: - tiptrack(tip50, None, reuse=False) + tip_track(p50, tip_count) p50.aspirate(ligation_vol, ligation_res) p50.dispense(p50.current_volume, i) for x in range(10 if not dry_run else 1): @@ -834,7 +587,7 @@ def index_ligation( # Add and mix adapters ctx.comment("-------Adding and Mixing Adapters-------") for i_well, x_well in zip(samples, adapters): - tiptrack(tip50, None, reuse=False) + tip_track(p50, tip_count) p50.aspirate(adapter_vol, x_well) p50.dispense(p50.current_volume, i_well) for y in range(10 if not dry_run else 1): @@ -867,7 +620,6 @@ def lib_cleanup() -> None: ctx.move_labware(FLP_plate, tc_mod, use_gripper=USE_GRIPPER) for x, i in enumerate(samples): - tiptrack(tip200, None, reuse=False) mix_beads(p200, bead_res, bead_vol_1, 7 if x == 0 else 2, x) p200.aspirate(bead_vol_1, bead_res) p200.dispense(bead_vol_1, i) @@ -914,11 +666,7 @@ def lib_cleanup() -> None: else: # Second Wash this_res = etoh2_res this_waste_res = waste2_res - if REUSE_ETOH_TIPS: - tiptrack(tip200, None, reuse=False) - for i in samp_list: - if not REUSE_ETOH_TIPS: - tiptrack(tip200, None, reuse=False) + tip_track(p200, tip_count) p200.aspirate(150, this_res) p200.air_gap(10) p200.dispense(p200.current_volume, i.top()) @@ -930,11 +678,7 @@ def lib_cleanup() -> None: ctx.delay(seconds=10) # Remove the ethanol wash for x, i in enumerate(samp_list): - if REUSE_ETOH_TIPS: - if x != 0: - tiptrack(tip200, None, reuse=False) - if not REUSE_ETOH_TIPS: - tiptrack(tip200, None, reuse=False) + tip_track(p200, tip_count) p200.aspirate(155, i) p200.air_gap(10) p200.dispense(p200.current_volume, this_waste_res) @@ -962,7 +706,7 @@ def lib_cleanup() -> None: for col, i in enumerate(samp_list): ctx.comment(f"****Adding RSB to Columns: {col+1}****") - tiptrack(tip50, col, reuse=True if REUSE_RSB_TIPS else False) + tip_track(p50, tip_count) p50.aspirate(rsb_vol_1, rsb_res) p50.air_gap(5) p50.dispense(p50.current_volume, i) @@ -997,7 +741,7 @@ def lib_cleanup() -> None: p200.flow_rate.aspirate = 10 for i_int, (s, e) in enumerate(zip(samp_list, samples_2)): - tiptrack(tip50, i_int, reuse=True if REUSE_RSB_TIPS else False) + tip_track(p50, tip_count) p50.aspirate(elution_vol, s) p50.air_gap(5) p50.dispense(p50.current_volume, e.bottom(1), push_out=3) @@ -1031,12 +775,11 @@ def lib_amplification( ctx.comment( "**** Mixing and Transfering beads to column " + str(i + 1) + " ****" ) - - tiptrack(tip50, None, reuse=False) mix_beads( p50, amplification_res, amplification_vol, 7 if i == 0 else 2, i ) # 5 reps for first mix in reservoir p50.flow_rate.dispense = 15 + tip_track(p50, tip_count) p50.aspirate(amplification_vol, amplification_res) p50.dispense(p50.current_volume, samples_2[i]) p50.flow_rate.dispense = 150 @@ -1065,10 +808,11 @@ def lib_cleanup_2() -> None: ctx.comment("-------Starting Cleanup-------") ctx.comment("-------Adding and Mixing Cleanup Beads-------") for x, i in enumerate(samples_2): - tiptrack(tip200, None, reuse=False) mix_beads(p200, bead_res, bead_vol_2, 7 if x == 0 else 2, x) + tip_track(p200, tip_count) p200.aspirate(bead_vol_2, bead_res) p200.dispense(bead_vol_2, i) + p200.return_tip() mix_beads(p200, i, bead_vol_2, 7 if not dry_run else 1, num_cols - 1) for x in range(10 if not dry_run else 1): if x == 9: @@ -1112,11 +856,7 @@ def lib_cleanup_2() -> None: else: # Second Wash this_res = etoh2_res this_waste_res = waste2_res - if REUSE_ETOH_TIPS: - tiptrack(tip200, None, reuse=False) - for i in samp_list_2: - if not REUSE_ETOH_TIPS: - tiptrack(tip200, None, reuse=False) + tip_track(p200, tip_count) p200.aspirate(150, this_res) p200.air_gap(10) p200.dispense(p200.current_volume, i.top()) @@ -1128,11 +868,7 @@ def lib_cleanup_2() -> None: ctx.delay(seconds=10) # Remove the ethanol wash for x, i in enumerate(samp_list_2): - if REUSE_ETOH_TIPS: - if x != 0: - tiptrack(tip200, None, reuse=False) - if not REUSE_ETOH_TIPS: - tiptrack(tip200, None, reuse=False) + tip_track(p200, tip_count) p200.aspirate(155, i) p200.air_gap(10) p200.dispense(p200.current_volume, this_waste_res) @@ -1159,7 +895,7 @@ def lib_cleanup_2() -> None: for col, i in enumerate(samp_list_2): ctx.comment(f"****Adding RSB to Columns: {col+1}****") - tiptrack(tip50, col, reuse=True if REUSE_RSB_TIPS else False) + tip_track(p50, tip_count) p50.aspirate(rsb_vol_2, rsb_res) p50.air_gap(5) p50.dispense(p50.current_volume, i) @@ -1194,7 +930,7 @@ def lib_cleanup_2() -> None: p200.flow_rate.aspirate = 10 for i_int, (s, e) in enumerate(zip(samp_list_2, samples_flp)): - tiptrack(tip50, i_int, reuse=True if REUSE_RSB_TIPS else False) + tip_track(p50, tip_count) p50.aspirate(elution_vol_2, s) p50.air_gap(5) p50.dispense(p50.current_volume, e.bottom(1), push_out=3) @@ -1215,5 +951,14 @@ def lib_cleanup_2() -> None: lib_cleanup() unused_lids, used_lids = lib_amplification(unused_lids, used_lids) lib_cleanup_2() + + # Probe liquid waste + reservoir.label = "Liquid Waste" # type: ignore[attr-defined] + waste1 = reservoir.columns()[6] + waste1_res = waste1[0] + + waste2 = reservoir.columns()[7] + waste2_res = waste2[0] + end_probed_wells = [waste1_res, waste2_res] helpers.find_liquid_height_of_all_wells(ctx, p50, end_probed_wells) diff --git a/abr-testing/abr_testing/protocols/liquid_setups/12_KAPA HyperPlus Library Prep Liquid Setup.py b/abr-testing/abr_testing/protocols/liquid_setups/12_KAPA HyperPlus Library Prep Liquid Setup.py index b4282397baf..753934622bf 100644 --- a/abr-testing/abr_testing/protocols/liquid_setups/12_KAPA HyperPlus Library Prep Liquid Setup.py +++ b/abr-testing/abr_testing/protocols/liquid_setups/12_KAPA HyperPlus Library Prep Liquid Setup.py @@ -38,46 +38,77 @@ def run(protocol: protocol_api.ProtocolContext) -> None: # Sample Plate 1 Prep: dispense 17 ul into column 1 total 136 ul p1000.transfer( - volume=136, - source=source_reservoir["A1"].bottom(z=0.5), - dest=sample_plate_1["A1"], + volume=[35, 35, 35, 35, 35, 35], + source=source_reservoir["A1"].bottom(z=2), + dest=[ + sample_plate_1["A1"].top(), + sample_plate_1["A2"].top(), + sample_plate_1["A3"].top(), + sample_plate_1["A4"].top(), + sample_plate_1["A5"].top(), + sample_plate_1["A6"].top(), + ], blow_out=True, blowout_location="source well", + new_tip="once", trash=False, ) # Sample Plate 2 Prep: dispense 17 ul into column 1 total 136 ul p1000.transfer( - volume=136, - source=source_reservoir["A1"].bottom(z=0.5), - dest=sample_plate_2["A1"], + volume=[17, 17, 17, 17, 17, 17], + source=source_reservoir["A1"].bottom(z=2), + dest=[ + sample_plate_2["A1"].top(), + sample_plate_2["A2"].top(), + sample_plate_2["A3"].top(), + sample_plate_2["A4"].top(), + sample_plate_2["A5"].top(), + sample_plate_2["A6"].top(), + ], blow_out=True, blowout_location="source well", + new_tip="once", trash=False, ) # Reservoir Plate Prep: p1000.transfer( - volume=[1214.4, 396, 352, 352], - source=source_reservoir["A1"].bottom(z=0.5), - dest=[reservoir["A1"], reservoir["A4"], reservoir["A5"], reservoir["A6"]], + volume=[910.8, 297, 2000, 2000], + source=source_reservoir["A1"].bottom(z=2), + dest=[ + reservoir["A1"].top(), + reservoir["A4"].top(), + reservoir["A5"].top(), + reservoir["A6"].top(), + ], blow_out=True, blowout_location="source well", + new_tip="once", trash=False, ) # Temp Module Res Prep: dispense 30 and 200 ul into columns 1 and 3 - total 1840 ul + # adapters + + # Rest of liquids p1000.transfer( - volume=[80, 88, 132, 200, 200], - source=source_reservoir["A1"].bottom(z=0.5), + volume=[10, 10, 10, 10, 10, 10, 61, 91.5, 200, 183], + source=source_reservoir["A1"].bottom(z=2), dest=[ - temp_module_res["A1"], - temp_module_res["A2"], - temp_module_res["A3"], - temp_module_res["A4"], - temp_module_res["A5"], + temp_module_res["A1"].top(), + temp_module_res["A2"].top(), + temp_module_res["A3"].top(), + temp_module_res["A4"].top(), + temp_module_res["A5"].top(), + temp_module_res["A6"].top(), + temp_module_res["A7"].top(), + temp_module_res["A8"].top(), + temp_module_res["A9"].top(), + temp_module_res["A10"].top(), ], blow_out=True, blowout_location="source well", + new_tip="once", trash=False, ) diff --git a/abr-testing/abr_testing/protocols/liquid_setups/6_Omega_HDQ_DNA_Cells Liquid Setup.py b/abr-testing/abr_testing/protocols/liquid_setups/6_Omega_HDQ_DNA_Cells Liquid Setup.py new file mode 100644 index 00000000000..02a1a207351 --- /dev/null +++ b/abr-testing/abr_testing/protocols/liquid_setups/6_Omega_HDQ_DNA_Cells Liquid Setup.py @@ -0,0 +1,92 @@ +"""Plate Filler Protocol for Omega HDQ DNA Cell Protocol.""" +from opentrons import protocol_api +from abr_testing.protocols.helpers import ( + load_common_liquid_setup_labware_and_instruments, +) + +metadata = { + "protocolName": "DVT2ABR6: Omega HDQ DNA Cells Protocol", + "author": "Rhyann clarke ", + "source": "Protocol Library", +} + +requirements = { + "robotType": "Flex", + "apiLevel": "2.21", +} + + +def run(protocol: protocol_api.ProtocolContext) -> None: + """Protocol.""" + # Initiate Labware + ( + source_reservoir, + tip_rack, + p1000, + ) = load_common_liquid_setup_labware_and_instruments(protocol) + deepwell_type = "nest_96_wellplate_2ml_deep" + + lysis_reservoir = protocol.load_labware(deepwell_type, "D2", "Lysis reservoir") + bind_reservoir = protocol.load_labware( + deepwell_type, "D3", "Beads and binding reservoir" + ) + wash1_reservoir = protocol.load_labware(deepwell_type, "C3", "Wash 1 and 2 Buffer") + wash2_reservoir = protocol.load_labware(deepwell_type, "B3", "Wash 3 Buffer") + sample_plate = protocol.load_labware(deepwell_type, "B2", "Sample Plate") + elution_plate = protocol.load_labware( + "armadillo_96_wellplate_200ul_pcr_full_skirt", "B1", "Elution Plate" + ) + p1000.transfer( + volume=350, + source=source_reservoir["A1"].bottom(z=2), + dest=lysis_reservoir.wells(), + blow_out=True, + blowout_location="source well", + new_tip="once", + trash=False, + ) + p1000.transfer( + 440, + source=source_reservoir["A1"].bottom(z=2), + dest=bind_reservoir.wells(), + blow_out=True, + blowout_location="source well", + new_tip="once", + trash=False, + ) + p1000.transfer( + 1300, + source_reservoir["A1"].bottom(z=2), + wash1_reservoir.wells(), + blow_out=True, + blowout_location="source well", + new_tip="once", + trash=False, + ) + p1000.transfer( + 700, + source_reservoir["A1"].bottom(z=2), + wash2_reservoir.wells(), + blow_out=True, + blowout_location="source well", + new_tip="once", + trash=False, + ) + p1000.transfer( + 180, + source_reservoir["A1"].bottom(z=2), + sample_plate.wells(), + blow_out=True, + blowout_location="source well", + new_tip="once", + trash=False, + ) + p1000.transfer( + 100, + source_reservoir["A1"].bottom(z=2), + elution_plate.wells(), + blow_out=True, + blowout_location="source well", + new_tip="once", + trash=False, + ) From a02c9d5a0de219181b10a5b197f26e3e4b0c2f8d Mon Sep 17 00:00:00 2001 From: Tony Ngumah Date: Tue, 3 Dec 2024 14:45:16 -0500 Subject: [PATCH 2/3] fix(abr_testing): Modified labware names of liquid setup to match its respective labware name in the protocol. --- .../12_KAPA HyperPlus Library Prep.py | 8 +- .../6_Omega_HDQ_DNA_Cells-Flex_96_channel.py | 351 ++++++++++++++++++ ...APA HyperPlus Library Prep Liquid Setup.py | 34 +- .../6_Omega_HDQ_DNA_Cells Liquid Setup.py | 6 +- 4 files changed, 378 insertions(+), 21 deletions(-) create mode 100644 abr-testing/abr_testing/protocols/active_protocols/6_Omega_HDQ_DNA_Cells-Flex_96_channel.py diff --git a/abr-testing/abr_testing/protocols/active_protocols/12_KAPA HyperPlus Library Prep.py b/abr-testing/abr_testing/protocols/active_protocols/12_KAPA HyperPlus Library Prep.py index 2495d6d881e..34d92b0ebc8 100644 --- a/abr-testing/abr_testing/protocols/active_protocols/12_KAPA HyperPlus Library Prep.py +++ b/abr-testing/abr_testing/protocols/active_protocols/12_KAPA HyperPlus Library Prep.py @@ -135,15 +135,17 @@ def run(ctx: ProtocolContext) -> None: samples_flp = FLP_plate.rows()[0][:num_cols] sample_plate = ctx.load_labware( - "armadillo_96_wellplate_200ul_pcr_full_skirt", "D1", "Sample Pate" + "armadillo_96_wellplate_200ul_pcr_full_skirt", "D1", "Sample Plate 1" ) sample_plate_2 = ctx.load_labware( - "armadillo_96_wellplate_200ul_pcr_full_skirt", "B2", "Sample Pate" + "armadillo_96_wellplate_200ul_pcr_full_skirt", "B2", "Sample Plate 2" ) samples_2 = sample_plate_2.rows()[0][:num_cols] samples = sample_plate.rows()[0][:num_cols] - reservoir = ctx.load_labware("nest_96_wellplate_2ml_deep", "C2") + reservoir = ctx.load_labware( + "nest_96_wellplate_2ml_deep", "C2", "Beads + Buffer + Ethanol" + ) # Load tipracks tiprack_50_1 = ctx.load_labware("opentrons_flex_96_tiprack_50ul", "A3") tiprack_50_2 = ctx.load_labware("opentrons_flex_96_tiprack_50ul", "A2") diff --git a/abr-testing/abr_testing/protocols/active_protocols/6_Omega_HDQ_DNA_Cells-Flex_96_channel.py b/abr-testing/abr_testing/protocols/active_protocols/6_Omega_HDQ_DNA_Cells-Flex_96_channel.py new file mode 100644 index 00000000000..89f643729fb --- /dev/null +++ b/abr-testing/abr_testing/protocols/active_protocols/6_Omega_HDQ_DNA_Cells-Flex_96_channel.py @@ -0,0 +1,351 @@ +"""Omega Bio-tek Mag-Bind Blood & Tissue DNA HDQ - Bacteria.""" +from typing import List, Dict +from abr_testing.protocols import helpers +from opentrons.protocol_api import ( + ProtocolContext, + ParameterContext, + Well, + InstrumentContext, +) +from opentrons.protocol_api.module_contexts import ( + HeaterShakerContext, + MagneticBlockContext, + TemperatureModuleContext, +) +from opentrons import types +import numpy as np + +metadata = { + "author": "Zach Galluzzo ", + "protocolName": "Omega Bio-tek Mag-Bind Blood & Tissue DNA HDQ - Bacteria", +} + +requirements = { + "robotType": "Flex", + "apiLevel": "2.21", +} + + +def add_parameters(parameters: ParameterContext) -> None: + """Parameters.""" + helpers.create_dot_bottom_parameter(parameters) + + +# Start protocol +def run(ctx: ProtocolContext) -> None: + """Protocol.""" + dot_bottom = ctx.params.dot_bottom # type: ignore[attr-defined] + + dry_run = False + tip_mixing = False + + wash_vol = 600.0 + AL_vol = 230.0 + bind_vol = 320.0 + sample_vol = 180.0 + elution_vol = 100.0 + + # Same for all HDQ Extractions + deepwell_type = "nest_96_wellplate_2ml_deep" + if not dry_run: + settling_time = 2.0 + num_washes = 3 + if dry_run: + settling_time = 0.5 + num_washes = 1 + bead_vol = PK_vol = 20.0 + inc_temp = 55.0 + AL_total_vol = AL_vol + PK_vol + binding_buffer_vol = bead_vol + bind_vol + starting_vol = AL_total_vol + sample_vol + + h_s: HeaterShakerContext = ctx.load_module(helpers.hs_str, "D1") # type: ignore[assignment] + sample_plate, h_s_adapter = helpers.load_hs_adapter_and_labware( + deepwell_type, h_s, "Sample Plate" + ) + h_s.close_labware_latch() + samples_m = sample_plate.wells()[0] + + # NOTE: MAG BLOCK will be on slot 6 + + temp: TemperatureModuleContext = ctx.load_module( + helpers.temp_str, "A3" + ) # type: ignore[assignment] + elutionplate, tempblock = helpers.load_temp_adapter_and_labware( + "armadillo_96_wellplate_200ul_pcr_full_skirt", temp, "Elution Plate/Reservoir" + ) + + magblock: MagneticBlockContext = ctx.load_module( + "magneticBlockV1", "C1" + ) # type: ignore[assignment] + liquid_waste = ctx.load_labware("nest_1_reservoir_195ml", "B3", "Liquid Waste") + waste = liquid_waste.wells()[0].top() + + lysis_reservoir = ctx.load_labware(deepwell_type, "D2", "Lysis reservoir") + lysis_res = lysis_reservoir.wells()[0] + bind_reservoir = ctx.load_labware( + deepwell_type, "C2", "Beads and binding reservoir" + ) + bind_res = bind_reservoir.wells()[0] + wash1_reservoir = ctx.load_labware(deepwell_type, "C3", "Wash 1 reservoir") + wash1_res = wash1_reservoir.wells()[0] + wash2_reservoir = ctx.load_labware(deepwell_type, "B1", "Wash 2 reservoir") + wash2_res = wash2_reservoir.wells()[0] + elution_res = elutionplate.wells()[0] + # Load Pipette and tip racks + # Load tips + tiprack_1 = ctx.load_labware( + "opentrons_flex_96_tiprack_1000ul", + "A1", + adapter="opentrons_flex_96_tiprack_adapter", + ) + tips = tiprack_1.wells()[0] + + tiprack_2 = ctx.load_labware( + "opentrons_flex_96_tiprack_1000ul", + "A2", + adapter="opentrons_flex_96_tiprack_adapter", + ) + tips1 = tiprack_2.wells()[0] + # load 96 channel pipette + pip: InstrumentContext = ctx.load_instrument( + "flex_96channel_1000", mount="left", tip_racks=[tiprack_1, tiprack_2] + ) + # Load Liquids and probe + liquid_vols_and_wells: Dict[str, List[Dict[str, Well | List[Well] | float]]] = { + "Lysis Buffer": [{"well": lysis_reservoir.wells(), "volume": AL_vol + 92.0}], + "PK Buffer": [{"well": lysis_reservoir.wells(), "volume": PK_vol + 8.0}], + "Binding Buffer": [{"well": bind_reservoir.wells(), "volume": bind_vol + 91.5}], + "Magnetic Beads": [{"well": bind_reservoir.wells(), "volume": bead_vol + 8.5}], + "Wash 1 and 2 Buffer": [ + {"well": wash1_reservoir.wells(), "volume": (wash_vol * 2.0) + 100.0} + ], + "Wash 3 Buffer": [ + {"well": wash2_reservoir.wells(), "volume": wash_vol + 100.0} + ], + "Elution Buffer": [{"well": elutionplate.wells(), "volume": elution_vol + 5}], + "Samples": [{"well": sample_plate.wells(), "volume": sample_vol}], + } + + helpers.find_liquid_height_of_loaded_liquids(ctx, liquid_vols_and_wells, pip) + + pip.flow_rate.aspirate = 50 + pip.flow_rate.dispense = 150 + pip.flow_rate.blow_out = 300 + + def resuspend_pellet(vol: float, plate: Well, reps: int = 3) -> None: + """Re-suspend pellets.""" + pip.flow_rate.aspirate = 200 + pip.flow_rate.dispense = 300 + + loc1 = plate.bottom().move(types.Point(x=1, y=0, z=1)) + loc2 = plate.bottom().move(types.Point(x=0.75, y=0.75, z=1)) + loc3 = plate.bottom().move(types.Point(x=0, y=1, z=1)) + loc4 = plate.bottom().move(types.Point(x=-0.75, y=0.75, z=1)) + loc5 = plate.bottom().move(types.Point(x=-1, y=0, z=1)) + loc6 = plate.bottom().move(types.Point(x=-0.75, y=0 - 0.75, z=1)) + loc7 = plate.bottom().move(types.Point(x=0, y=-1, z=1)) + loc8 = plate.bottom().move(types.Point(x=0.75, y=-0.75, z=1)) + + if vol > 1000: + vol = 1000 + + mixvol = vol * 0.9 + + for _ in range(reps): + pip.aspirate(mixvol, loc1) + pip.dispense(mixvol, loc1) + pip.aspirate(mixvol, loc2) + pip.dispense(mixvol, loc2) + pip.aspirate(mixvol, loc3) + pip.dispense(mixvol, loc3) + pip.aspirate(mixvol, loc4) + pip.dispense(mixvol, loc4) + pip.aspirate(mixvol, loc5) + pip.dispense(mixvol, loc5) + pip.aspirate(mixvol, loc6) + pip.dispense(mixvol, loc6) + pip.aspirate(mixvol, loc7) + pip.dispense(mixvol, loc7) + pip.aspirate(mixvol, loc8) + pip.dispense(mixvol, loc8) + if _ == reps - 1: + pip.flow_rate.aspirate = 50 + pip.flow_rate.dispense = 30 + pip.aspirate(mixvol, loc8) + pip.dispense(mixvol, loc8) + + pip.flow_rate.aspirate = 150 + pip.flow_rate.dispense = 200 + + def bead_mix(vol: float, plate: Well, reps: int = 5) -> None: + """Bead mix.""" + pip.flow_rate.aspirate = 200 + pip.flow_rate.dispense = 300 + + loc1 = plate.bottom().move(types.Point(x=0, y=0, z=1)) + loc2 = plate.bottom().move(types.Point(x=0, y=0, z=8)) + loc3 = plate.bottom().move(types.Point(x=0, y=0, z=16)) + loc4 = plate.bottom().move(types.Point(x=0, y=0, z=24)) + + if vol > 1000: + vol = 1000 + + mixvol = vol * 0.9 + + for _ in range(reps): + pip.aspirate(mixvol, loc1) + pip.dispense(mixvol, loc1) + pip.aspirate(mixvol, loc1) + pip.dispense(mixvol, loc2) + pip.aspirate(mixvol, loc1) + pip.dispense(mixvol, loc3) + pip.aspirate(mixvol, loc1) + pip.dispense(mixvol, loc4) + if _ == reps - 1: + pip.flow_rate.aspirate = 50 + pip.flow_rate.dispense = 30 + pip.aspirate(mixvol, loc1) + pip.dispense(mixvol, loc1) + + pip.flow_rate.aspirate = 150 + pip.flow_rate.dispense = 200 + + # Start Protocol + temp.set_temperature(inc_temp) + # Transfer and mix lysis + pip.pick_up_tip(tips) + pip.aspirate(AL_total_vol, lysis_res) + pip.dispense(AL_total_vol, samples_m) + resuspend_pellet(400, samples_m, reps=4 if not dry_run else 1) + if not tip_mixing: + pip.return_tip() + + # Mix, then heat + ctx.comment("Lysis Mixing") + helpers.set_hs_speed(ctx, h_s, 1800, 10, False) + if not dry_run: + h_s.set_and_wait_for_temperature(55) + ctx.delay( + minutes=10 if not dry_run else 0.25, + msg="Please allow another 10 minutes of 55C incubation to complete lysis.", + ) + h_s.deactivate_shaker() + + # Transfer and mix bind&beads + pip.pick_up_tip(tips) + bead_mix(binding_buffer_vol, bind_res, reps=4 if not dry_run else 1) + pip.aspirate(binding_buffer_vol, bind_res) + pip.dispense(binding_buffer_vol, samples_m) + bead_mix(binding_buffer_vol + starting_vol, samples_m, reps=4 if not dry_run else 1) + if not tip_mixing: + pip.return_tip() + pip.home() + + # Shake for binding incubation + ctx.comment("Binding incubation") + helpers.set_hs_speed(ctx, h_s, 1800, 10, True) + + # Transfer plate to magnet + helpers.move_labware_from_hs_to_destination(ctx, sample_plate, h_s, magblock) + + ctx.delay( + minutes=settling_time, + msg="Please wait " + str(settling_time) + " minute(s) for beads to pellet.", + ) + + # Remove Supernatant and move off magnet + pip.pick_up_tip(tips) + pip.aspirate(1000, samples_m.bottom(dot_bottom)) + pip.dispense(1000, waste) + if starting_vol + binding_buffer_vol > 1000: + pip.aspirate(1000, samples_m.bottom(dot_bottom)) + pip.dispense(1000, waste) + pip.return_tip() + + # Transfer plate from magnet to H/S + helpers.move_labware_to_hs(ctx, sample_plate, h_s, h_s_adapter) + + # Washes + for i in range(num_washes if not dry_run else 1): + if i == 0 or i == 1: + wash_res = wash1_res + else: + wash_res = wash2_res + + pip.pick_up_tip(tips) + pip.aspirate(wash_vol, wash_res) + pip.dispense(wash_vol, samples_m) + if not tip_mixing: + pip.return_tip() + helpers.set_hs_speed(ctx, h_s, 1800, 5, True) + + # Transfer plate to magnet + helpers.move_labware_from_hs_to_destination(ctx, sample_plate, h_s, magblock) + + ctx.delay( + minutes=settling_time, + msg="Please wait " + str(settling_time) + " minute(s) for beads to pellet.", + ) + + # Remove Supernatant and move off magnet + pip.pick_up_tip(tips) + pip.aspirate(1000, samples_m.bottom(dot_bottom)) + pip.dispense(1000, bind_res.top()) + if wash_vol > 1000: + pip.aspirate(1000, samples_m.bottom(dot_bottom)) + pip.dispense(1000, bind_res.top()) + pip.return_tip() + + # Transfer plate from magnet to H/S + helpers.move_labware_to_hs(ctx, sample_plate, h_s, h_s_adapter) + + # Dry beads + if dry_run: + drybeads = 0.5 + else: + drybeads = 10 + # Number of minutes you want to dry for + for beaddry in np.arange(drybeads, 0, -0.5): + ctx.delay( + minutes=0.5, + msg="There are " + str(beaddry) + " minutes left in the drying step.", + ) + + # Elution + pip.pick_up_tip(tips1) + pip.aspirate(elution_vol, elution_res) + pip.dispense(elution_vol, samples_m) + resuspend_pellet(elution_vol, samples_m, reps=3 if not dry_run else 1) + if not tip_mixing: + pip.return_tip() + pip.home() + + helpers.set_hs_speed(ctx, h_s, 2000, 5, True) + + # Transfer plate to magnet + helpers.move_labware_from_hs_to_destination(ctx, sample_plate, h_s, magblock) + + ctx.delay( + minutes=settling_time, + msg="Please wait " + str(settling_time) + " minute(s) for beads to pellet.", + ) + + pip.pick_up_tip(tips1) + pip.aspirate(elution_vol, samples_m) + pip.dispense(elution_vol, elutionplate.wells()[0]) + pip.return_tip() + + pip.home() + pip.reset_tipracks() + + # Empty Plates + pip.pick_up_tip() + pip.aspirate(1000, samples_m) + pip.dispense(1000, liquid_waste["A1"].top()) + pip.aspirate(1000, wash1_res) + pip.dispense(1000, liquid_waste["A1"].top()) + pip.aspirate(1000, wash2_res) + pip.dispense(1000, liquid_waste["A1"].top()) + pip.return_tip() + helpers.find_liquid_height_of_all_wells(ctx, pip, [liquid_waste["A1"]]) diff --git a/abr-testing/abr_testing/protocols/liquid_setups/12_KAPA HyperPlus Library Prep Liquid Setup.py b/abr-testing/abr_testing/protocols/liquid_setups/12_KAPA HyperPlus Library Prep Liquid Setup.py index 753934622bf..2575caecf6e 100644 --- a/abr-testing/abr_testing/protocols/liquid_setups/12_KAPA HyperPlus Library Prep Liquid Setup.py +++ b/abr-testing/abr_testing/protocols/liquid_setups/12_KAPA HyperPlus Library Prep Liquid Setup.py @@ -25,15 +25,19 @@ def run(protocol: protocol_api.ProtocolContext) -> None: p1000, ) = load_common_liquid_setup_labware_and_instruments(protocol) - reservoir = protocol.load_labware("nest_96_wellplate_2ml_deep", "D2") # Reservoir - temp_module_res = protocol.load_labware( - "opentrons_96_wellplate_200ul_pcr_full_skirt", "B3" + reservoir = protocol.load_labware( + "nest_96_wellplate_2ml_deep", "D2", "Beads + Buffer + Ethanol" + ) # Reservoir + temp_plate = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", + "B3", + "Temp Module Reservoir Plate", ) sample_plate_1 = protocol.load_labware( - "opentrons_96_wellplate_200ul_pcr_full_skirt", "D3" + "opentrons_96_wellplate_200ul_pcr_full_skirt", "D3", "Sample Plate 1" ) # Sample Plate sample_plate_2 = protocol.load_labware( - "opentrons_96_wellplate_200ul_pcr_full_skirt", "C3" + "opentrons_96_wellplate_200ul_pcr_full_skirt", "C3", "Sample Plate 2" ) # Sample Plate # Sample Plate 1 Prep: dispense 17 ul into column 1 total 136 ul @@ -96,16 +100,16 @@ def run(protocol: protocol_api.ProtocolContext) -> None: volume=[10, 10, 10, 10, 10, 10, 61, 91.5, 200, 183], source=source_reservoir["A1"].bottom(z=2), dest=[ - temp_module_res["A1"].top(), - temp_module_res["A2"].top(), - temp_module_res["A3"].top(), - temp_module_res["A4"].top(), - temp_module_res["A5"].top(), - temp_module_res["A6"].top(), - temp_module_res["A7"].top(), - temp_module_res["A8"].top(), - temp_module_res["A9"].top(), - temp_module_res["A10"].top(), + temp_plate["A1"].top(), + temp_plate["A2"].top(), + temp_plate["A3"].top(), + temp_plate["A4"].top(), + temp_plate["A5"].top(), + temp_plate["A6"].top(), + temp_plate["A7"].top(), + temp_plate["A8"].top(), + temp_plate["A9"].top(), + temp_plate["A10"].top(), ], blow_out=True, blowout_location="source well", diff --git a/abr-testing/abr_testing/protocols/liquid_setups/6_Omega_HDQ_DNA_Cells Liquid Setup.py b/abr-testing/abr_testing/protocols/liquid_setups/6_Omega_HDQ_DNA_Cells Liquid Setup.py index 02a1a207351..da40b983a1d 100644 --- a/abr-testing/abr_testing/protocols/liquid_setups/6_Omega_HDQ_DNA_Cells Liquid Setup.py +++ b/abr-testing/abr_testing/protocols/liquid_setups/6_Omega_HDQ_DNA_Cells Liquid Setup.py @@ -30,11 +30,11 @@ def run(protocol: protocol_api.ProtocolContext) -> None: bind_reservoir = protocol.load_labware( deepwell_type, "D3", "Beads and binding reservoir" ) - wash1_reservoir = protocol.load_labware(deepwell_type, "C3", "Wash 1 and 2 Buffer") - wash2_reservoir = protocol.load_labware(deepwell_type, "B3", "Wash 3 Buffer") + wash1_reservoir = protocol.load_labware(deepwell_type, "C3", "Wash 1 reservoir") + wash2_reservoir = protocol.load_labware(deepwell_type, "B3", "Wash 2 reservoir") sample_plate = protocol.load_labware(deepwell_type, "B2", "Sample Plate") elution_plate = protocol.load_labware( - "armadillo_96_wellplate_200ul_pcr_full_skirt", "B1", "Elution Plate" + "armadillo_96_wellplate_200ul_pcr_full_skirt", "B1", "Elution Plate/ reservoir" ) p1000.transfer( volume=350, From bf51e7bbd954ed045c7186843d09e39f84c599c2 Mon Sep 17 00:00:00 2001 From: Tony Ngumah Date: Tue, 3 Dec 2024 17:03:24 -0500 Subject: [PATCH 3/3] lint fix --- .../active_protocols/12_KAPA HyperPlus Library Prep.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/abr-testing/abr_testing/protocols/active_protocols/12_KAPA HyperPlus Library Prep.py b/abr-testing/abr_testing/protocols/active_protocols/12_KAPA HyperPlus Library Prep.py index 34d92b0ebc8..75658f11438 100644 --- a/abr-testing/abr_testing/protocols/active_protocols/12_KAPA HyperPlus Library Prep.py +++ b/abr-testing/abr_testing/protocols/active_protocols/12_KAPA HyperPlus Library Prep.py @@ -93,7 +93,7 @@ def run(ctx: ProtocolContext) -> None: num_cols = math.ceil(num_samples / 8) # Pre-set parameters - sample_vol = 35.0 + # sample_vol = 35.0 frag_vol = 15.0 end_repair_vol = 10.0 adapter_vol = 5.0 @@ -101,14 +101,14 @@ def run(ctx: ProtocolContext) -> None: amplification_vol = 30.0 bead_vol_1 = 88.0 bead_vol_2 = 50.0 - bead_vol = bead_vol_1 + bead_vol_2 + # bead_vol = bead_vol_1 + bead_vol_2 bead_inc = 2.0 rsb_vol_1 = 25.0 rsb_vol_2 = 20.0 - rsb_vol = rsb_vol_1 + rsb_vol_2 + # rsb_vol = rsb_vol_1 + rsb_vol_2 elution_vol = 20.0 elution_vol_2 = 17.0 - etoh_vol = 400.0 + # etoh_vol = 400.0 # Importing Labware, Modules and Instruments magblock: MagneticBlockContext = ctx.load_module(