From c7ef04e0a13664290bbf5f039a2c2f74b7c57fa9 Mon Sep 17 00:00:00 2001 From: rclarke0 Date: Fri, 31 Jan 2025 10:42:49 -0500 Subject: [PATCH 01/10] error fixes and 96 lv protocol draft --- .../data_collection/abr_robot_error.py | 27 +- .../data_collection/get_run_logs.py | 5 +- abr-testing/abr_testing/protocols/helpers.py | 2 +- .../protocols/test_protocols/miseq_library.py | 354 ++++++++++++++++++ 4 files changed, 384 insertions(+), 4 deletions(-) create mode 100644 abr-testing/abr_testing/protocols/test_protocols/miseq_library.py diff --git a/abr-testing/abr_testing/data_collection/abr_robot_error.py b/abr-testing/abr_testing/data_collection/abr_robot_error.py index ec1dfdcadf7..0f9e7ec7478 100644 --- a/abr-testing/abr_testing/data_collection/abr_robot_error.py +++ b/abr-testing/abr_testing/data_collection/abr_robot_error.py @@ -17,13 +17,29 @@ from abr_testing.tools import plate_reader +def retrieve_version_file( + robot_ip: str, + storage: str, +) -> Path | str: + """Retrieve Version file.""" + version_file_path = "/etc/VERSION.json" + save_dir = Path(f"{storage}") + print(save_dir) + command = ["scp", "-r", f"root@{robot_ip}:{version_file_path}", save_dir] + try: + subprocess.run(command, check=True) + return os.path.join(save_dir, "VERSION.json") + except subprocess.CalledProcessError as e: + print(f"Error during file transfer: {e}") + + def retrieve_protocol_file( protocol_id: str, robot_ip: str, storage: str, ) -> Path | str: """Find and copy protocol file on robot with error.""" - protocol_dir = f"/var/lib/opentrons-robot-server/7.1/protocols/{protocol_id}" + protocol_dir = f"/var/lib/opentrons-robot-server/8/protocols/{protocol_id}" # Copy protocol file found in robot onto host computer save_dir = Path(f"{storage}") command = ["scp", "-r", f"root@{robot_ip}:{protocol_dir}", save_dir] @@ -366,6 +382,8 @@ def get_run_error_info_from_robot( description = dict() # get run information results = get_run_logs.get_run_data(one_run, ip) + # Get version file + # save run information to local directory as .json file saved_file_path = read_robot_logs.save_run_log_to_json( ip, results, storage_directory @@ -545,6 +563,8 @@ def get_run_error_info_from_robot( except requests.exceptions.InvalidURL: print("Invalid IP address.") sys.exit() + version_file_dir = retrieve_version_file(robot_ip=ip, storage=storage_directory) + version_file_path = os.path.join(storage_directory, version_file_dir) if len(run_or_other) < 1: # Retrieve the most recently run protocol file protocol_folder = retrieve_protocol_file( @@ -611,12 +631,15 @@ def get_run_error_info_from_robot( # OPEN TICKET issue_url = ticket.open_issue(issue_key) # MOVE FILES TO ERROR FOLDER. + print(version_file_path) + print(run_log_file_path) error_files = [ saved_file_path_calibration, run_log_file_path, protocol_file_path, + version_file_path, ] + file_paths - + input("-------") error_folder_path = os.path.join(storage_directory, issue_key) os.makedirs(error_folder_path, exist_ok=True) for source_file in error_files: diff --git a/abr-testing/abr_testing/data_collection/get_run_logs.py b/abr-testing/abr_testing/data_collection/get_run_logs.py index fe89f9f1543..7975578d68b 100644 --- a/abr-testing/abr_testing/data_collection/get_run_logs.py +++ b/abr-testing/abr_testing/data_collection/get_run_logs.py @@ -36,7 +36,10 @@ def get_run_data(one_run: Any, ip: str) -> Dict[str, Any]: params={"cursor": 0, "pageLength": 0}, ) data = response.json() - command_count = data["meta"]["totalLength"] + try: + command_count = data["meta"]["totalLength"] + except KeyError: + command_count = 0 page_length = 100 commands = list() run = dict() diff --git a/abr-testing/abr_testing/protocols/helpers.py b/abr-testing/abr_testing/protocols/helpers.py index 31a1d1a9244..07670022403 100644 --- a/abr-testing/abr_testing/protocols/helpers.py +++ b/abr-testing/abr_testing/protocols/helpers.py @@ -215,7 +215,7 @@ def create_disposable_lid_parameter(parameters: ParameterContext) -> None: variable_name="disposable_lid", display_name="Disposable Lid", description="True means use lid.", - default=True, + default=False, ) diff --git a/abr-testing/abr_testing/protocols/test_protocols/miseq_library.py b/abr-testing/abr_testing/protocols/test_protocols/miseq_library.py new file mode 100644 index 00000000000..6e86b04f0ae --- /dev/null +++ b/abr-testing/abr_testing/protocols/test_protocols/miseq_library.py @@ -0,0 +1,354 @@ +"""MiSeq Library Preparation Protocol.""" +from opentrons.protocol_api import ( + ProtocolContext, + ParameterContext, + InstrumentContext, + Well, + Liquid, +) +from typing import Tuple, Optional +from opentrons.protocol_api import COLUMN, ALL +from abr_testing.protocols import helpers +from opentrons.protocol_api.module_contexts import ( + HeaterShakerContext, + ThermocyclerContext, + TemperatureModuleContext, +) + +metadata = { + "protocolName": "MiSeq Library Preparation Protocol - No column pick up", + "author": "Anurag Kanase ", + "description": "Two-step PCR protocol for Illumina MiSeq library prep.", +} + + +requirements = {"robotType": "Flex", "apiLevel": "2.21"} + + +def add_parameters(parameters: ParameterContext) -> None: + """Parameters.""" + helpers.create_dot_bottom_parameter(parameters) + helpers.create_deactivate_modules_parameter(parameters) + helpers.create_disposable_lid_parameter(parameters) + + +def run(protocol: ProtocolContext) -> None: + """Protocol.""" + # Load Parameters + dot_bottom = protocol.params.dot_bottom # type: ignore[attr-defined] + deactivate_modules_bool = protocol.params.deactivate_modules # type: ignore[attr-defined] + disposable_lid = protocol.params.disposable_lid # type: ignore[attr-defined] + if disposable_lid: + lids = helpers.load_disposable_lids( + protocol=protocol, num_of_lids=2, deck_slot=["A2"], deck_riser=False + ) + + def transfer( + pipette: InstrumentContext, + volume: float, + source: Well, + dest: Well, + mix_after: Optional[Tuple] = None, + ) -> None: + """ + Custom transfer function combining aspirate and dispense with optional mixing and flow rate control + + Args: + pipette: The pipette object to use + volume: Volume to transfer in µL + source: Source well/location + dest: Destination well/location + mix_after: Tuple of (mix_count, mix_volume) for mixing after dispense + aspirate_flow_rate: Optional custom flow rate for aspiration + dispense_flow_rate: Optional custom flow rate for dispensing + """ + # Store original flow rates + original_asp_rate = pipette.flow_rate.aspirate + original_disp_rate = pipette.flow_rate.dispense + + # Perform transfer + pipette.aspirate(volume, source.bottom(1)) + pipette.move_to(source.top(), speed=5) + pipette.dispense(volume, dest.bottom(dot_bottom)) + pipette.move_to(dest.top(), speed=5) + + # Mix if specified + if mix_after: + mix_count, mix_volume = mix_after + pipette.mix(mix_count, mix_volume) + + # Restore original flow rates + pipette.flow_rate.aspirate = original_asp_rate + pipette.flow_rate.dispense = original_disp_rate + + # Load modules + waste_chute = protocol.load_waste_chute() + thermocycler: ThermocyclerContext = protocol.load_module("thermocyclerModuleV2") # type: ignore[assignment] + temp_module: TemperatureModuleContext = protocol.load_module("temperatureModuleV2", "C1") # type: ignore[assignment] + reagent_block = temp_module.load_adapter("opentrons_96_well_aluminum_block") + heater_shaker: HeaterShakerContext = protocol.load_module("heaterShakerModuleV1", "D1") # type: ignore[assignment] + hs_adapter = heater_shaker.load_adapter("opentrons_96_pcr_adapter") + + # Load labware + pcr_reagents_plate = reagent_block.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", label="PCR Master Mix" + ) + pcr1_plate = thermocycler.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", label="PCR1" + ) + dna_plate = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", "A3", label="DNA" + ) + indices_plate = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", "C3", label="Indices" + ) + pcr1_dilution_plate = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", "A4", label="PCR1 Dilution" + ) + pcr2_dilution_plate = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", "C4", label="PCR2 Dilution" + ) + reservoir = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", "D2", label="Water Reservoir" + ) + eppendorf_384 = protocol.load_labware( + "appliedbiosystemsmicroamp_384_wellplate_40ul", + "B4", + label="Applied Biosystems 384", + ) + pcr2_plate = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", "D4", label="PCR2 Plate" + ) + + # Load tips + tiprack_adapter = protocol.load_adapter("opentrons_flex_96_tiprack_adapter", "B3") + tiprack_1 = tiprack_adapter.load_labware("opentrons_flex_96_tiprack_50ul") + partial_tiprack = protocol.load_labware("opentrons_flex_96_tiprack_50ul", "C2") + + # Load pipette + p96 = protocol.load_instrument("flex_96channel_200", "left") + + def column(pipette: InstrumentContext = p96) -> None: + pipette.configure_nozzle_layout(style=COLUMN, start="A1") + + def all(pipette: InstrumentContext = p96) -> None: + pipette.configure_nozzle_layout(style=ALL) + + def add_liquid( + name: str, color: str, well: Well, volume: float + ) -> Tuple[Liquid, Well]: + liquid = protocol.define_liquid( + name=name, description="generic", display_color=color + ) + well.load_liquid(liquid=liquid, volume=volume) + return liquid, well + + # liquids + color_hex_codes = [ + "#9400D3", + "#FFC0CB", # Light pink + "#00CED1", # Light blue + "#7CFC00", # Lime green + "#FF4500", # Orange + "#9400D3", # Violet + "#bd5338", + ] + + pcr_mm1 = pcr_reagents_plate["A1"] + pcr_mm2 = pcr_reagents_plate["A2"] + water = reservoir["A1"] + for well in reservoir.wells(): + add_liquid("water", color_hex_codes[0], well, 150) + for well in pcr_reagents_plate.columns()[0]: + add_liquid("pcr_mm1", color_hex_codes[1], well, 100) + for well in pcr_reagents_plate.columns()[1]: + add_liquid("pcr_mm2", color_hex_codes[2], well, 100) + for well in indices_plate.wells(): + add_liquid("Index", color_hex_codes[3], well, 100) + for well in dna_plate.wells(): + add_liquid("DNA", color_hex_codes[4], well, 100) + + # Protocol steps + protocol.comment("Starting MiSeq library preparation protocol") + + # Step 1-2: Set temperatures + thermocycler.open_lid() + temp_module.set_temperature(8) + thermocycler.set_block_temperature(8) + + column_tips = partial_tiprack.rows()[0][::-1] + print(column_tips) + + # Step 3: Dispense PCR1 master mix (avoiding multidispense to maintian accuracy) + # column() + # protocol.comment("Dispensing PCR1 master mix") + # p96.pick_up_tip(column_tips.pop(0)) + # for col in range(12): + # print(col) + # transfer(p96, 7.5, pcr_mm1, pcr1_plate.rows()[0][col]) + # p96.drop_tip() + + # Step 4: Transfer DNA samples + all() + protocol.comment("Transferring DNA samples") + p96.pick_up_tip(tiprack_1["A1"]) + transfer(p96, 5, dna_plate["A1"], pcr1_plate["A1"]) + p96.return_tip() + + # Step 5: Shake + protocol.comment("Shaking PCR1 plate") + heater_shaker.open_labware_latch() + protocol.move_labware(pcr1_plate, hs_adapter, use_gripper=True) + heater_shaker.close_labware_latch() + heater_shaker.set_and_wait_for_shake_speed(500) + protocol.delay(seconds=30) + heater_shaker.deactivate_shaker() + heater_shaker.open_labware_latch() + + # Step 6: PCR1 thermal cycling + protocol.comment("Starting PCR1 thermal cycling") + protocol.move_labware(pcr1_plate, thermocycler, use_gripper=True) + heater_shaker.close_labware_latch() + if disposable_lid: + protocol.move_labware(lids[0], pcr1_plate, use_gripper=True) + thermocycler.close_lid() + thermocycler.set_lid_temperature(105) + + # Initial denaturation + thermocycler.execute_profile( + steps=[{"temperature": 95, "hold_time_seconds": 180}], repetitions=1 + ) + + # 35 cycles + thermocycler.execute_profile( + steps=[ + {"temperature": 95, "hold_time_seconds": 30}, + {"temperature": 60, "hold_time_seconds": 15}, + {"temperature": 72, "hold_time_seconds": 15}, + ], + repetitions=35, + ) + + # Final extension + thermocycler.execute_profile( + steps=[ + {"temperature": 72, "hold_time_seconds": 300}, + {"temperature": 20, "hold_time_seconds": 60}, + ], + repetitions=1, + ) + + thermocycler.set_block_temperature(8) + thermocycler.open_lid() + if disposable_lid: + protocol.move_labware(lids[0], waste_chute, use_gripper=True) + lids.pop(0) + # Steps 7-8: Move plates + protocol.comment("Setting up PCR2") + protocol.move_labware(pcr1_plate, "B2", use_gripper=True) + + protocol.move_labware(pcr2_plate, thermocycler, use_gripper=True) + # Step 9: Dispense PCR2 master mix + protocol.comment("Dispensing PCR2 master mix") + # column() + # p96.pick_up_tip(column_tips.pop(0)) + # for col in range(12): + # transfer(p96, 6, pcr_mm2, pcr2_plate.rows()[0][col]) + # p96.drop_tip() + + protocol.comment("Rearranging Deck for Dilutions") + heater_shaker.open_labware_latch() + protocol.move_labware(pcr_reagents_plate, hs_adapter, use_gripper=True) + protocol.move_labware(partial_tiprack, "D4", use_gripper=True) + protocol.move_labware(pcr1_dilution_plate, reagent_block, use_gripper=True) + protocol.move_labware(pcr2_dilution_plate, "C2", use_gripper=True) + heater_shaker.close_labware_latch() + # Step 10: Transfer indices + protocol.comment("Transferring indices") + all() + p96.pick_up_tip(tiprack_1["A1"]) + transfer(p96, 5, indices_plate["A1"], pcr2_plate["A1"]) + # p96.return_tip() + + # Steps 11-12: PCR1 dilution setup + protocol.comment("Setting up PCR1 dilution") + # p96.pick_up_tip() + transfer(p96, 40, reservoir["A1"], pcr1_dilution_plate["A1"]) + transfer(p96, 5, pcr1_plate["A1"], pcr1_dilution_plate["A1"], mix_after=(10, 45)) + + # Step 13: Transfer diluted PCR1 to PCR2 + protocol.comment("Transferring diluted PCR1 to PCR2") + transfer(p96, 5, pcr1_dilution_plate["A1"], pcr2_plate["A1"], mix_after=(10, 45)) + p96.return_tip() + + # Step 14: PCR2 thermal cycling + protocol.comment("Starting PCR2 thermal cycling") + if disposable_lid: + protocol.move_labware(lids[0], pcr2_plate, use_gripper=True) + thermocycler.close_lid() + thermocycler.set_lid_temperature(105) + # Initial denaturation + thermocycler.execute_profile( + steps=[{"temperature": 95, "hold_time_seconds": 180}], repetitions=1 + ) + + # 12 cycles + thermocycler.execute_profile( + steps=[ + {"temperature": 95, "hold_time_seconds": 20}, + {"temperature": 72, "hold_time_seconds": 15}, + ], + repetitions=12, + ) + + # Final extension + thermocycler.execute_profile( + steps=[ + {"temperature": 72, "hold_time_seconds": 300}, + {"temperature": 20, "hold_time_seconds": 60}, + ], + repetitions=1, + ) + + thermocycler.open_lid() + if disposable_lid: + protocol.move_labware(lids[0], waste_chute, use_gripper=True) + + # Step 15: Move PCR2 plate + protocol.comment("Moving PCR2 plate") + protocol.move_labware(pcr1_dilution_plate, "A2", use_gripper=True) + protocol.move_labware(pcr2_plate, reagent_block, use_gripper=True) + + # Steps 16-17: PCR2 dilution + protocol.comment("Setting up PCR2 dilution") + p96.pick_up_tip(tiprack_1["A1"]) + transfer(p96, 25, reservoir["A1"], pcr2_dilution_plate["A1"]) + transfer(p96, 5, pcr2_plate["A1"], pcr2_dilution_plate["A1"], mix_after=(10, 45)) + p96.return_tip() + protocol.move_labware(reservoir, "A4", use_gripper=True) + protocol.move_labware(eppendorf_384, "D2", use_gripper=True) + + # Step 18: Optional transfer to 384-well plate + protocol.comment("Optional: Transferring to 384-well plate") + p96.pick_up_tip(tiprack_1["A1"]) + for well_name in ["A1", "A2", "B1", "B2"]: + transfer(p96, 15, pcr2_dilution_plate["A1"], eppendorf_384[well_name]) + p96.drop_tip() + + # Final steps + protocol.comment("Protocol complete through PCR2 dilution") + protocol.comment("Please remove plates for quantification") + protocol.comment("Keep PCR2 dilution plate on deck if continuing with pooling") + + # Deactivate temperature modules + if deactivate_modules_bool: + temp_module.deactivate() + thermocycler.deactivate_lid() + thermocycler.deactivate_block() + + # Pause for plate removal + protocol.pause( + "Remove plates for quantification. Keep PCR2 dilution plate if continuing with pooling." + ) + + protocol.comment("Protocol complete!") From ee49bc98d5d36f9aac7ceec50aa61324c7aaeb94 Mon Sep 17 00:00:00 2001 From: rclarke0 Date: Thu, 6 Feb 2025 15:54:29 -0500 Subject: [PATCH 02/10] lengthen 96ch lv protocols --- .../protocols/test_protocols/miseq_library.py | 42 +++-- .../protocols/test_protocols/quick.py | 168 ++++++++++++++++++ 2 files changed, 192 insertions(+), 18 deletions(-) create mode 100644 abr-testing/abr_testing/protocols/test_protocols/quick.py diff --git a/abr-testing/abr_testing/protocols/test_protocols/miseq_library.py b/abr-testing/abr_testing/protocols/test_protocols/miseq_library.py index 6e86b04f0ae..4d1581beb0f 100644 --- a/abr-testing/abr_testing/protocols/test_protocols/miseq_library.py +++ b/abr-testing/abr_testing/protocols/test_protocols/miseq_library.py @@ -16,7 +16,7 @@ ) metadata = { - "protocolName": "MiSeq Library Preparation Protocol - No column pick up", + "protocolName": "MiSeq Library Preparation Protocol", "author": "Anurag Kanase ", "description": "Two-step PCR protocol for Illumina MiSeq library prep.", } @@ -30,6 +30,11 @@ def add_parameters(parameters: ParameterContext) -> None: helpers.create_dot_bottom_parameter(parameters) helpers.create_deactivate_modules_parameter(parameters) helpers.create_disposable_lid_parameter(parameters) + parameters.add_bool( + variable_name = "perform_column_tip_pickup", + display_name = "Perform Column Tip Pickup", + default = True + ) def run(protocol: ProtocolContext) -> None: @@ -38,9 +43,10 @@ def run(protocol: ProtocolContext) -> None: dot_bottom = protocol.params.dot_bottom # type: ignore[attr-defined] deactivate_modules_bool = protocol.params.deactivate_modules # type: ignore[attr-defined] disposable_lid = protocol.params.disposable_lid # type: ignore[attr-defined] + perform_column_tip_pick_up = protocol.params.perform_column_tip_pickup # type: ignore[attr-defined] if disposable_lid: lids = helpers.load_disposable_lids( - protocol=protocol, num_of_lids=2, deck_slot=["A2"], deck_riser=False + protocol=protocol, num_of_lids=3, deck_slot=["A2"], deck_riser=False ) def transfer( @@ -177,16 +183,15 @@ def add_liquid( thermocycler.set_block_temperature(8) column_tips = partial_tiprack.rows()[0][::-1] - print(column_tips) - - # Step 3: Dispense PCR1 master mix (avoiding multidispense to maintian accuracy) - # column() - # protocol.comment("Dispensing PCR1 master mix") - # p96.pick_up_tip(column_tips.pop(0)) - # for col in range(12): - # print(col) - # transfer(p96, 7.5, pcr_mm1, pcr1_plate.rows()[0][col]) - # p96.drop_tip() + if perform_column_tip_pick_up: + #Step 3: Dispense PCR1 master mix (avoiding multidispense to maintian accuracy) + column() + protocol.comment("Dispensing PCR1 master mix") + p96.pick_up_tip(column_tips.pop(0)) + for col in range(12): + print(col) + transfer(p96, 7.5, pcr_mm1, pcr1_plate.rows()[0][col]) + p96.drop_tip() # Step 4: Transfer DNA samples all() @@ -250,11 +255,12 @@ def add_liquid( protocol.move_labware(pcr2_plate, thermocycler, use_gripper=True) # Step 9: Dispense PCR2 master mix protocol.comment("Dispensing PCR2 master mix") - # column() - # p96.pick_up_tip(column_tips.pop(0)) - # for col in range(12): - # transfer(p96, 6, pcr_mm2, pcr2_plate.rows()[0][col]) - # p96.drop_tip() + if perform_column_tip_pick_up: + column() + p96.pick_up_tip(column_tips.pop(0)) + for col in range(12): + transfer(p96, 6, pcr_mm2, pcr2_plate.rows()[0][col]) + p96.drop_tip() protocol.comment("Rearranging Deck for Dilutions") heater_shaker.open_labware_latch() @@ -333,7 +339,7 @@ def add_liquid( p96.pick_up_tip(tiprack_1["A1"]) for well_name in ["A1", "A2", "B1", "B2"]: transfer(p96, 15, pcr2_dilution_plate["A1"], eppendorf_384[well_name]) - p96.drop_tip() + p96.return_tip() # Final steps protocol.comment("Protocol complete through PCR2 dilution") diff --git a/abr-testing/abr_testing/protocols/test_protocols/quick.py b/abr-testing/abr_testing/protocols/test_protocols/quick.py new file mode 100644 index 00000000000..9c80910f6b4 --- /dev/null +++ b/abr-testing/abr_testing/protocols/test_protocols/quick.py @@ -0,0 +1,168 @@ +metadata = { + 'protocolName': 'QUiCKR V2 kit - part 2 ', + 'author': 'Opentrons' +} +requirements = { + 'robotType': 'Flex', + 'apiLevel': '2.20' +} + + +def add_parameters(parameters): + + parameters.add_int( + variable_name="num_plate_pairs", + display_name="Number of 96-384 pairs", + description="Number of 96-384 pairs", + default=2, + choices=[ + {"display_name": "1", "value": 1}, + {"display_name": "2", "value": 2}, + {"display_name": "3", "value": 3} + ] +) + + +def run(ctx): + + num_plate_pairs = ctx.params.num_plate_pairs + + # deck layout + plate_384_slots = ['C1', 'B1', 'A1'] + plate_384_name = ['Assay Plate #1', 'Assay Plate #2', 'Assay Plate #3'] + plate_96_slots = ['C2', 'B2', 'A2'] + plate_96_name = ['Sample Plate #1', 'Sample Plate #2', 'Sample Plate #3'] + + plate_384 = [ctx.load_labware('biorad_384_wellplate_50ul', slot, name) + for slot, name in zip(plate_384_slots[:num_plate_pairs], plate_384_name[:num_plate_pairs])] + plate_96 = [ctx.load_labware('opentrons_96_wellplate_200ul_pcr_full_skirt', slot, name) + for slot, name in zip(plate_96_slots[:num_plate_pairs], plate_96_name[:num_plate_pairs])] + + if num_plate_pairs == 1: + deck_slots_50 = ['C3', 'B3'] + tiprack_adapter = [ctx.load_adapter('opentrons_flex_96_tiprack_adapter', slot) + for slot in deck_slots_50] + + tiprack_50 = [tiprack_adapter[i].load_labware('opentrons_flex_96_tiprack_50ul', slot) + for i, slot in enumerate(deck_slots_50)] + + tips = [tiprack_50[0], tiprack_50[1]] + + elif num_plate_pairs == 2: + deck_slots_50 = ['C3', 'B3', 'A3'] + tiprack_adapter = [ctx.load_adapter('opentrons_flex_96_tiprack_adapter', slot) + for slot in deck_slots_50] + + tiprack_50 = [tiprack_adapter[i].load_labware('opentrons_flex_96_tiprack_50ul', slot) + for i, slot in enumerate(deck_slots_50)] + + extra_50 = ['C4'] + tiprack_50_refill = [ctx.load_labware('opentrons_flex_96_tiprack_50ul', slot) + for slot in extra_50] + + tips = [tiprack_50[0], tiprack_50[1], tiprack_50[2], tiprack_50_refill[0]] + + elif num_plate_pairs == 3: + deck_slots_50 = ['C3', 'B3', 'A3'] + tiprack_adapter = [ctx.load_adapter('opentrons_flex_96_tiprack_adapter', slot) + for slot in deck_slots_50] + + tiprack_50 = [tiprack_adapter[i].load_labware('opentrons_flex_96_tiprack_50ul', slot) + for i, slot in enumerate(deck_slots_50)] + + extra_50 = ['C4', 'B4', 'A4'] + tiprack_50_refill = [ctx.load_labware('opentrons_flex_96_tiprack_50ul', slot) + for slot in extra_50] + + tips = [tiprack_50[0], tiprack_50[1], tiprack_50[2], tiprack_50_refill[0], tiprack_50_refill[1], tiprack_50_refill[2]] + + # pipette setting + p = ctx.load_instrument("flex_96channel_200", tip_racks=tiprack_50[:3]) + p.flow_rate.aspirate = 7 + p.flow_rate.dispense = 7 * 2 + + + # liquid info + sample_liq = ctx.define_liquid(name="Samples", description="Samples (diluted)", display_color="#7EFF42") + for plate in plate_96: + for col in [0, 4]: + [plate.rows()[row][col].load_liquid(liquid=sample_liq, volume=40) + for row in range(8)] + [plate.rows()[row][8].load_liquid(liquid=sample_liq, volume=40) + for row in range(7)] + for col in [1,2,5,6]: + [plate.rows()[row][col].load_liquid(liquid=sample_liq, volume=40) + for row in range(8)] + for col in [3,7]: + [plate.rows()[row][col].load_liquid(liquid=sample_liq, volume=60) + for row in range(8)] + for col in [9,10]: + [plate.rows()[row][col].load_liquid(liquid=sample_liq, volume=40) + for row in range(7)] + [plate.rows()[row][11].load_liquid(liquid=sample_liq, volume=60) + for row in range(7)] + + control_liq = ctx.define_liquid(name="Controls", description="Controls", display_color="#FF4F4F") + for plate in plate_96: + [plate.wells()[well].load_liquid(liquid=control_liq, volume=40) + for well in [71, 79, 87, 95]] + + + for i in range(num_plate_pairs): + + if i == 1: + ctx.move_labware(labware = tiprack_50[0], + new_location = "D4", + use_gripper=True, + ) + ctx.move_labware(labware = tiprack_50_refill[0], + new_location = tiprack_adapter[0], + use_gripper=True, + ) + elif i == 2: + ctx.move_labware(labware = tiprack_50[1], + new_location = "A1", + use_gripper=True, + ) + ctx.move_labware(labware = tiprack_50_refill[1], + new_location = tiprack_adapter[1], + use_gripper=True, + ) + ctx.move_labware(labware = tiprack_50[2], + new_location = "A2", + use_gripper=True, + ) + ctx.move_labware(labware = tiprack_50_refill[2], + new_location = tiprack_adapter[2], + use_gripper=True, + ) + for n in range(12): + p.tip_racks = [tips[i*2]] + p.pick_up_tip() + p.aspirate(7*2, plate_96[i]['A1'].bottom(z=2)) + ctx.delay(seconds=1) + p.dispense(7, plate_384[i]['A1'].bottom(z=2)) + ctx.delay(seconds=1) + p.dispense(7, plate_384[i]['A2'].bottom(z=2)) + ctx.delay(seconds=1) + p.mix(5, 7, plate_384[i]['A2'].bottom(z=2)) + p.blow_out(plate_384[i]['A2'].top()) + p.mix(5, 7, plate_384[i]['A1'].bottom(z=2)) + p.blow_out(plate_384[i]['A1'].top()) + p.return_tip() + p.reset_tipracks() + p.tip_racks = [tips[i*2+1]] + p.pick_up_tip() + p.aspirate(7*2, plate_96[i]['A1'].bottom(z=2)) + ctx.delay(seconds=1) + p.dispense(7, plate_384[i]['B1'].bottom(z=2)) + ctx.delay(seconds=1) + p.dispense(7, plate_384[i]['B2'].bottom(z=2)) + ctx.delay(seconds=1) + p.mix(5, 7, plate_384[i]['B2'].bottom(z=2)) + p.blow_out(plate_384[i]['B2'].top()) + p.mix(5, 7, plate_384[i]['B1'].bottom(z=2)) + p.blow_out(plate_384[i]['B1'].top()) + p.return_tip() + p.reset_tipracks() + From 0a293e2bdab65d2bb6b799ba73c0f38588e6a8f2 Mon Sep 17 00:00:00 2001 From: rclarke0 Date: Fri, 7 Feb 2025 16:33:34 -0500 Subject: [PATCH 03/10] 96ch lv liquid setups and protocols --- .../data_collection/abr_robot_error.py | 3 +- ...omplex protocol with single tip Pick Up.py | 418 ----------------- .../5_MiSeq Library Preparation.py} | 105 ++--- .../6_Omega_HDQ_DNA_Cells-Flex_96_channel.py | 433 ----------------- .../6_QUiCKR_Kit_Part1and2.py | 248 ++++++++++ .../8_Illumina and Plate Reader.py | 2 - abr-testing/abr_testing/protocols/helpers.py | 2 +- .../liquid_setups/All_Liquid_Set_ups.py | 443 ++++++++++++++++++ .../protocols/test_protocols/quick.py | 168 ------- 9 files changed, 736 insertions(+), 1086 deletions(-) delete mode 100644 abr-testing/abr_testing/protocols/active_protocols/5_96ch complex protocol with single tip Pick Up.py rename abr-testing/abr_testing/protocols/{test_protocols/miseq_library.py => active_protocols/5_MiSeq Library Preparation.py} (79%) delete mode 100644 abr-testing/abr_testing/protocols/active_protocols/6_Omega_HDQ_DNA_Cells-Flex_96_channel.py create mode 100644 abr-testing/abr_testing/protocols/active_protocols/6_QUiCKR_Kit_Part1and2.py create mode 100644 abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py delete mode 100644 abr-testing/abr_testing/protocols/test_protocols/quick.py diff --git a/abr-testing/abr_testing/data_collection/abr_robot_error.py b/abr-testing/abr_testing/data_collection/abr_robot_error.py index 0f9e7ec7478..0b581f046c1 100644 --- a/abr-testing/abr_testing/data_collection/abr_robot_error.py +++ b/abr-testing/abr_testing/data_collection/abr_robot_error.py @@ -27,10 +27,11 @@ def retrieve_version_file( print(save_dir) command = ["scp", "-r", f"root@{robot_ip}:{version_file_path}", save_dir] try: - subprocess.run(command, check=True) + subprocess.run(command, check=True) # type: ignore return os.path.join(save_dir, "VERSION.json") except subprocess.CalledProcessError as e: print(f"Error during file transfer: {e}") + return "" def retrieve_protocol_file( diff --git a/abr-testing/abr_testing/protocols/active_protocols/5_96ch complex protocol with single tip Pick Up.py b/abr-testing/abr_testing/protocols/active_protocols/5_96ch complex protocol with single tip Pick Up.py deleted file mode 100644 index ca7506cf6f0..00000000000 --- a/abr-testing/abr_testing/protocols/active_protocols/5_96ch complex protocol with single tip Pick Up.py +++ /dev/null @@ -1,418 +0,0 @@ -"""96 ch Test Single Tip and Gripper Moves.""" -from opentrons.protocol_api import ( - COLUMN, - SINGLE, - ALL, - ParameterContext, - ProtocolContext, - Labware, -) -from opentrons.protocol_api.module_contexts import ( - HeaterShakerContext, - ThermocyclerContext, - TemperatureModuleContext, -) -from abr_testing.protocols import helpers -from typing import List - -metadata = { - "protocolName": "96ch protocol with modules gripper moves and SINGLE tip pickup", - "author": "Derek Maggio ", -} - -requirements = { - "robotType": "Flex", - "apiLevel": "2.21", -} - - -# prefer to move off deck, instead of waste chute disposal, if possible -PREFER_MOVE_OFF_DECK = False - - -PCR_PLATE_96_NAME = "armadillo_96_wellplate_200ul_pcr_full_skirt" -RESERVOIR_NAME = "nest_96_wellplate_2ml_deep" -TIPRACK_96_ADAPTER_NAME = "opentrons_flex_96_tiprack_adapter" -PIPETTE_96_CHANNEL_NAME = "flex_96channel_1000" - -USING_GRIPPER = True -RESET_AFTER_EACH_MOVE = True - - -def add_parameters(parameters: ParameterContext) -> None: - """Parameters.""" - helpers.create_tip_size_parameter(parameters) - helpers.create_dot_bottom_parameter(parameters) - helpers.create_disposable_lid_parameter(parameters) - helpers.create_tc_lid_deck_riser_parameter(parameters) - helpers.create_deactivate_modules_parameter(parameters) - - -def run(protocol: ProtocolContext) -> None: - """Protocol.""" - b = protocol.params.dot_bottom # type: ignore[attr-defined] - TIPRACK_96_NAME = protocol.params.tip_size # type: ignore[attr-defined] - disposable_lid = protocol.params.disposable_lid # type: ignore[attr-defined] - deck_riser = protocol.params.deck_riser # type: ignore[attr-defined] - deactivate_modules_bool = protocol.params.deactivate_modules # type: ignore[attr-defined] - - waste_chute = protocol.load_waste_chute() - helpers.comment_protocol_version(protocol, "01") - - thermocycler: ThermocyclerContext = protocol.load_module( - helpers.tc_str - ) # type: ignore[assignment] - h_s: HeaterShakerContext = protocol.load_module( - helpers.hs_str, "D1" - ) # type: ignore[assignment] - temperature_module: TemperatureModuleContext = protocol.load_module( - helpers.temp_str, "C1" - ) # type: ignore[assignment] - if disposable_lid: - unused_lids = helpers.load_disposable_lids(protocol, 3, ["A2"], deck_riser) - used_lids: List[Labware] = [] - thermocycler.open_lid() - h_s.open_labware_latch() - - temperature_module_adapter = temperature_module.load_adapter( - "opentrons_96_well_aluminum_block" - ) - h_s_adapter = h_s.load_adapter("opentrons_96_pcr_adapter") - - adapters = [temperature_module_adapter, h_s_adapter] - - source_reservoir = protocol.load_labware(RESERVOIR_NAME, "D2") - dest_pcr_plate = protocol.load_labware(PCR_PLATE_96_NAME, "C2") - liquid_waste = protocol.load_labware("nest_1_reservoir_195ml", "B2", "Liquid Waste") - - tip_rack_1 = protocol.load_labware( - TIPRACK_96_NAME, "A3", adapter="opentrons_flex_96_tiprack_adapter" - ) - tip_rack_2 = protocol.load_labware(TIPRACK_96_NAME, "C3") - tip_rack_3 = protocol.load_labware(TIPRACK_96_NAME, "C4") - - tip_racks = [ - tip_rack_1, - tip_rack_2, - tip_rack_3, - ] - - pipette_96_channel = protocol.load_instrument( - PIPETTE_96_CHANNEL_NAME, - mount="left", - tip_racks=tip_racks, - liquid_presence_detection=True, - ) - - water = protocol.define_liquid( - name="water", description="H₂O", display_color="#42AB2D" - ) - source_reservoir.wells_by_name()["A1"].load_liquid(liquid=water, volume=29000) - - def run_moves( - labware: Labware, move_sequences: List, reset_location: str, use_gripper: bool - ) -> None: - """Perform a series of moves for a given labware using specified move sequences. - - Will perform 2 versions of the moves: - 1.Moves to each location, resetting to the reset location after each move. - 2.Moves to each location, resetting to the reset location after all moves. - """ - - def move_to_locations( - labware_to_move: Labware, - move_locations: List, - reset_after_each_move: bool, - use_gripper: bool, - reset_location: str, - ) -> None: - """Move labware to specific destinations.""" - - def reset_labware() -> None: - """Reset the labware to the reset location.""" - protocol.move_labware( - labware_to_move, reset_location, use_gripper=use_gripper - ) - - if len(move_locations) == 0: - return - - for location in move_locations: - protocol.move_labware( - labware_to_move, location, use_gripper=use_gripper - ) - - if reset_after_each_move: - reset_labware() - - if not reset_after_each_move: - reset_labware() - - for move_sequence in move_sequences: - move_to_locations( - labware, - move_sequence, - RESET_AFTER_EACH_MOVE, - use_gripper, - reset_location, - ) - move_to_locations( - labware, - move_sequence, - not RESET_AFTER_EACH_MOVE, - use_gripper, - reset_location, - ) - - def test_gripper_moves() -> None: - """Function to test the movement of the gripper in various locations.""" - - def deck_moves(labware: Labware, reset_location: str) -> None: - """Function to perform the movement of labware.""" - deck_move_sequence = [ - ["B3"], # Deck Moves - ["C3"], # Staging Area Slot 3 Moves - ["C4", "D4"], # Staging Area Slot 4 Moves - [ - thermocycler, - temperature_module_adapter, - h_s_adapter, - ], # Module Moves - ] - - run_moves(labware, deck_move_sequence, reset_location, USING_GRIPPER) - - def staging_area_slot_3_moves(labware: Labware, reset_location: str) -> None: - """Function to perform the movement of labware, starting w/ staging area slot 3.""" - staging_area_slot_3_move_sequence = [ - ["B3", "C2"], # Deck Moves - [], # Don't have Staging Area Slot 3 open - ["C4", "D4"], # Staging Area Slot 4 Moves - [ - thermocycler, - temperature_module_adapter, - h_s_adapter, - ], # Module Moves - ] - - run_moves( - labware, - staging_area_slot_3_move_sequence, - reset_location, - USING_GRIPPER, - ) - - def staging_area_slot_4_moves(labware: Labware, reset_location: str) -> None: - """Function to perform the movement of labware, starting with staging area slot 4.""" - staging_area_slot_4_move_sequence = [ - ["C2", "B3"], # Deck Moves - ["C3"], # Staging Area Slot 3 Moves - ["C4"], # Staging Area Slot 4 Moves - [ - thermocycler, - temperature_module_adapter, - h_s_adapter, - ], # Module Moves - ] - - run_moves( - labware, - staging_area_slot_4_move_sequence, - reset_location, - USING_GRIPPER, - ) - - def module_moves(labware: Labware, module_locations: List) -> None: - """Function to perform the movement of labware, starting on a module.""" - module_move_sequence = [ - ["C2", "B3"], # Deck Moves - ["C3"], # Staging Area Slot 3 Moves - ["C4", "D4"], # Staging Area Slot 4 Moves - ] - - for module_starting_location in module_locations: - labware_move_to_locations = module_locations.copy() - labware_move_to_locations.remove(module_starting_location) - all_sequences = module_move_sequence.copy() - all_sequences.append(labware_move_to_locations) - protocol.move_labware( - labware, module_starting_location, use_gripper=USING_GRIPPER - ) - run_moves( - labware, all_sequences, module_starting_location, USING_GRIPPER - ) - - DECK_MOVE_RESET_LOCATION = "C2" - STAGING_AREA_SLOT_3_RESET_LOCATION = "C3" - STAGING_AREA_SLOT_4_RESET_LOCATION = "D4" - - deck_moves(dest_pcr_plate, DECK_MOVE_RESET_LOCATION) - - protocol.move_labware( - dest_pcr_plate, - STAGING_AREA_SLOT_3_RESET_LOCATION, - use_gripper=USING_GRIPPER, - ) - staging_area_slot_3_moves(dest_pcr_plate, STAGING_AREA_SLOT_3_RESET_LOCATION) - - protocol.move_labware( - dest_pcr_plate, - STAGING_AREA_SLOT_4_RESET_LOCATION, - use_gripper=USING_GRIPPER, - ) - staging_area_slot_4_moves(dest_pcr_plate, STAGING_AREA_SLOT_4_RESET_LOCATION) - - module_locations = [thermocycler] + adapters - module_moves(dest_pcr_plate, module_locations) - protocol.move_labware(dest_pcr_plate, thermocycler, use_gripper=USING_GRIPPER) - - def test_manual_moves() -> None: - """Test manual moves.""" - protocol.move_labware(source_reservoir, "D4", use_gripper=USING_GRIPPER) - - def test_pipetting() -> None: - """Test pipetting.""" - - def test_single_tip_pickup_usage() -> None: - """Test Single Tip Pick Up.""" - pipette_96_channel.configure_nozzle_layout(style=SINGLE, start="H12") - pipette_96_channel.liquid_presence_detection = True - tip_count = 0 # Tip counter to ensure proper tip usage - rows = ["A", "B", "C", "D", "E", "F", "G", "H"] # 8 rows - columns = range(1, 13) # 12 columns - for row in rows: - for col in columns: - well_position = f"{row}{col}" - pipette_96_channel.pick_up_tip(tip_rack_2) - - pipette_96_channel.aspirate(45, source_reservoir[well_position]) - pipette_96_channel.air_gap(5) - - pipette_96_channel.dispense( - 25, dest_pcr_plate[well_position].bottom(b) - ) - pipette_96_channel.blow_out(location=liquid_waste["A1"]) - pipette_96_channel.drop_tip() - tip_count += 1 - # leave this dropping in waste chute, do not use get_disposal_preference - # want to test partial drop - protocol.move_labware(tip_rack_2, waste_chute, use_gripper=USING_GRIPPER) - - def test_column_tip_rack_usage() -> None: - """Column Tip Pick Up.""" - list_of_columns = list(range(1, 13)) - pipette_96_channel.configure_nozzle_layout( - style=COLUMN, start="A12", tip_racks=[tip_rack_3] - ) - protocol.comment("------------------------------") - protocol.comment(f"channels {pipette_96_channel.active_channels}") - protocol.move_labware(tip_rack_3, "C3", use_gripper=USING_GRIPPER) - for well in list_of_columns: - tiprack_well = "A" + str(well) - well_name = "A" + str(well) - pipette_96_channel.liquid_presence_detection = True - pipette_96_channel.pick_up_tip(tip_rack_3[tiprack_well]) - pipette_96_channel.aspirate(45, source_reservoir[well_name]) - pipette_96_channel.liquid_presence_detection = False - pipette_96_channel.air_gap(5) - pipette_96_channel.dispense(25, dest_pcr_plate[tiprack_well].bottom(b)) - pipette_96_channel.blow_out(location=liquid_waste["A1"]) - pipette_96_channel.drop_tip() - protocol.move_labware(tip_rack_3, waste_chute, use_gripper=USING_GRIPPER) - - def test_full_tip_rack_usage() -> None: - """Full Tip Pick Up.""" - pipette_96_channel.configure_nozzle_layout( - style=ALL, tip_racks=[tip_rack_1] - ) - protocol.comment(f"channels {pipette_96_channel.active_channels}") - pipette_96_channel.liquid_presence_detection = True - pipette_96_channel.pick_up_tip() - pipette_96_channel.aspirate(45, source_reservoir["A1"]) - pipette_96_channel.liquid_presence_detection = False - pipette_96_channel.air_gap(5) - pipette_96_channel.dispense(25, dest_pcr_plate["A1"].bottom(b)) - pipette_96_channel.blow_out(location=liquid_waste["A1"]) - pipette_96_channel.return_tip() - pipette_96_channel.reset_tipracks() - - test_single_tip_pickup_usage() - test_column_tip_rack_usage() - test_full_tip_rack_usage() - - def test_module_usage(unused_lids: List[Labware], used_lids: List[Labware]) -> None: - """Test Module Use.""" - - def test_thermocycler( - unused_lids: List[Labware], used_lids: List[Labware] - ) -> None: - if disposable_lid: - ( - lid_on_plate, - unused_lids, - used_lids, - ) = helpers.use_disposable_lid_with_tc( - protocol, unused_lids, used_lids, dest_pcr_plate, thermocycler - ) - thermocycler.set_block_temperature(4) - thermocycler.set_lid_temperature(105) - # Close lid - thermocycler.close_lid() - helpers.perform_pcr( - protocol, - thermocycler, - initial_denature_time_sec=45, - denaturation_time_sec=30, - anneal_time_sec=30, - extension_time_sec=10, - cycle_repetitions=30, - final_extension_time_min=5, - ) - # Cool to 4° - thermocycler.set_block_temperature(4) - thermocycler.set_lid_temperature(105) - # Open lid - thermocycler.open_lid() - if disposable_lid: - if len(used_lids) <= 1: - protocol.move_labware(lid_on_plate, waste_chute, use_gripper=True) - else: - protocol.move_labware(lid_on_plate, used_lids[-2], use_gripper=True) - thermocycler.deactivate() - - def test_h_s() -> None: - """Tests heatershaker.""" - h_s.open_labware_latch() - h_s.close_labware_latch() - - h_s.set_target_temperature(75.0) - h_s.set_and_wait_for_shake_speed(1000) - h_s.wait_for_temperature() - - h_s.deactivate_heater() - h_s.deactivate_shaker() - - def test_temperature_module() -> None: - """Tests temperature module.""" - temperature_module.set_temperature(80) - temperature_module.set_temperature(10) - temperature_module.deactivate() - - test_thermocycler(unused_lids, used_lids) - test_h_s() - test_temperature_module() - - test_pipetting() - test_gripper_moves() - test_module_usage(unused_lids, used_lids) - test_manual_moves() - protocol.move_labware(source_reservoir, "C2", use_gripper=True) - helpers.clean_up_plates( - pipette_96_channel, [dest_pcr_plate, source_reservoir], liquid_waste["A1"], 50 - ) - pipette_96_channel.reset_tipracks() - helpers.find_liquid_height_of_all_wells( - protocol, pipette_96_channel, [liquid_waste["A1"]] - ) - if deactivate_modules_bool: - helpers.deactivate_modules(protocol) diff --git a/abr-testing/abr_testing/protocols/test_protocols/miseq_library.py b/abr-testing/abr_testing/protocols/active_protocols/5_MiSeq Library Preparation.py similarity index 79% rename from abr-testing/abr_testing/protocols/test_protocols/miseq_library.py rename to abr-testing/abr_testing/protocols/active_protocols/5_MiSeq Library Preparation.py index 4d1581beb0f..eaa2627f13c 100644 --- a/abr-testing/abr_testing/protocols/test_protocols/miseq_library.py +++ b/abr-testing/abr_testing/protocols/active_protocols/5_MiSeq Library Preparation.py @@ -4,7 +4,6 @@ ParameterContext, InstrumentContext, Well, - Liquid, ) from typing import Tuple, Optional from opentrons.protocol_api import COLUMN, ALL @@ -14,6 +13,7 @@ ThermocyclerContext, TemperatureModuleContext, ) +from typing import List, Dict metadata = { "protocolName": "MiSeq Library Preparation Protocol", @@ -22,7 +22,7 @@ } -requirements = {"robotType": "Flex", "apiLevel": "2.21"} +requirements = {"robotType": "Flex", "apiLevel": "2.23"} def add_parameters(parameters: ParameterContext) -> None: @@ -31,9 +31,9 @@ def add_parameters(parameters: ParameterContext) -> None: helpers.create_deactivate_modules_parameter(parameters) helpers.create_disposable_lid_parameter(parameters) parameters.add_bool( - variable_name = "perform_column_tip_pickup", - display_name = "Perform Column Tip Pickup", - default = True + variable_name="column_tip_pickup", + display_name="Perform Column Tip Pickup", + default=True, ) @@ -43,11 +43,9 @@ def run(protocol: ProtocolContext) -> None: dot_bottom = protocol.params.dot_bottom # type: ignore[attr-defined] deactivate_modules_bool = protocol.params.deactivate_modules # type: ignore[attr-defined] disposable_lid = protocol.params.disposable_lid # type: ignore[attr-defined] - perform_column_tip_pick_up = protocol.params.perform_column_tip_pickup # type: ignore[attr-defined] + column_tip_pick_up = protocol.params.column_tip_pickup # type: ignore[attr-defined] if disposable_lid: - lids = helpers.load_disposable_lids( - protocol=protocol, num_of_lids=3, deck_slot=["A2"], deck_riser=False - ) + lids = protocol.load_lid_stack("opentrons_tough_pcr_auto_sealing_lid", "A2", 3) def transfer( pipette: InstrumentContext, @@ -56,8 +54,7 @@ def transfer( dest: Well, mix_after: Optional[Tuple] = None, ) -> None: - """ - Custom transfer function combining aspirate and dispense with optional mixing and flow rate control + """Custom transfer function combining asp and dsp with optional mixing and flow rate control. Args: pipette: The pipette object to use @@ -89,10 +86,16 @@ def transfer( # Load modules waste_chute = protocol.load_waste_chute() - thermocycler: ThermocyclerContext = protocol.load_module("thermocyclerModuleV2") # type: ignore[assignment] - temp_module: TemperatureModuleContext = protocol.load_module("temperatureModuleV2", "C1") # type: ignore[assignment] + thermocycler: ThermocyclerContext = protocol.load_module( + "thermocyclerModuleV2" + ) # type: ignore[assignment] + temp_module: TemperatureModuleContext = protocol.load_module( + "temperatureModuleV2", "C1" + ) # type: ignore[assignment] reagent_block = temp_module.load_adapter("opentrons_96_well_aluminum_block") - heater_shaker: HeaterShakerContext = protocol.load_module("heaterShakerModuleV1", "D1") # type: ignore[assignment] + heater_shaker: HeaterShakerContext = protocol.load_module( + "heaterShakerModuleV1", "D1" + ) # type: ignore[assignment] hs_adapter = heater_shaker.load_adapter("opentrons_96_pcr_adapter") # Load labware @@ -132,7 +135,7 @@ def transfer( partial_tiprack = protocol.load_labware("opentrons_flex_96_tiprack_50ul", "C2") # Load pipette - p96 = protocol.load_instrument("flex_96channel_200", "left") + p96 = protocol.load_instrument("flex_96channel_200", "left", tip_racks=[tiprack_1]) def column(pipette: InstrumentContext = p96) -> None: pipette.configure_nozzle_layout(style=COLUMN, start="A1") @@ -140,40 +143,22 @@ def column(pipette: InstrumentContext = p96) -> None: def all(pipette: InstrumentContext = p96) -> None: pipette.configure_nozzle_layout(style=ALL) - def add_liquid( - name: str, color: str, well: Well, volume: float - ) -> Tuple[Liquid, Well]: - liquid = protocol.define_liquid( - name=name, description="generic", display_color=color - ) - well.load_liquid(liquid=liquid, volume=volume) - return liquid, well - - # liquids - color_hex_codes = [ - "#9400D3", - "#FFC0CB", # Light pink - "#00CED1", # Light blue - "#7CFC00", # Lime green - "#FF4500", # Orange - "#9400D3", # Violet - "#bd5338", - ] - + # Load liquids and probe. + liquid_vols_and_wells: Dict[str, List[Dict[str, Well | List[Well] | float]]] = { + "Water": [{"well": reservoir.wells(), "volume": 150}], + "pcr_mm1": [{"well": pcr_reagents_plate.columns()[0], "volume": 100}], + "pcr_mm2": [{"well": pcr_reagents_plate.columns()[1], "volume": 100}], + "Index": [{"well": indices_plate.wells(), "volume": 100}], + "DNA": [{"well": dna_plate.wells(), "volume": 100}], + } pcr_mm1 = pcr_reagents_plate["A1"] pcr_mm2 = pcr_reagents_plate["A2"] - water = reservoir["A1"] - for well in reservoir.wells(): - add_liquid("water", color_hex_codes[0], well, 150) - for well in pcr_reagents_plate.columns()[0]: - add_liquid("pcr_mm1", color_hex_codes[1], well, 100) - for well in pcr_reagents_plate.columns()[1]: - add_liquid("pcr_mm2", color_hex_codes[2], well, 100) - for well in indices_plate.wells(): - add_liquid("Index", color_hex_codes[3], well, 100) - for well in dna_plate.wells(): - add_liquid("DNA", color_hex_codes[4], well, 100) - + helpers.load_wells_with_custom_liquids( + protocol, liquid_vols_and_wells=liquid_vols_and_wells + ) + helpers.find_liquid_height_of_loaded_liquids( + protocol, liquid_vols_and_wells=liquid_vols_and_wells, pipette=p96 + ) # Protocol steps protocol.comment("Starting MiSeq library preparation protocol") @@ -183,13 +168,12 @@ def add_liquid( thermocycler.set_block_temperature(8) column_tips = partial_tiprack.rows()[0][::-1] - if perform_column_tip_pick_up: - #Step 3: Dispense PCR1 master mix (avoiding multidispense to maintian accuracy) + if column_tip_pick_up: + # Step 3: Dispense PCR1 master mix (avoiding multidispense to maintian accuracy) column() protocol.comment("Dispensing PCR1 master mix") p96.pick_up_tip(column_tips.pop(0)) for col in range(12): - print(col) transfer(p96, 7.5, pcr_mm1, pcr1_plate.rows()[0][col]) p96.drop_tip() @@ -215,7 +199,8 @@ def add_liquid( protocol.move_labware(pcr1_plate, thermocycler, use_gripper=True) heater_shaker.close_labware_latch() if disposable_lid: - protocol.move_labware(lids[0], pcr1_plate, use_gripper=True) + print(lids) + protocol.move_lid(lids, pcr1_plate, use_gripper=True) thermocycler.close_lid() thermocycler.set_lid_temperature(105) @@ -246,8 +231,7 @@ def add_liquid( thermocycler.set_block_temperature(8) thermocycler.open_lid() if disposable_lid: - protocol.move_labware(lids[0], waste_chute, use_gripper=True) - lids.pop(0) + protocol.move_lid(pcr1_plate, waste_chute, use_gripper=True) # Steps 7-8: Move plates protocol.comment("Setting up PCR2") protocol.move_labware(pcr1_plate, "B2", use_gripper=True) @@ -255,7 +239,7 @@ def add_liquid( protocol.move_labware(pcr2_plate, thermocycler, use_gripper=True) # Step 9: Dispense PCR2 master mix protocol.comment("Dispensing PCR2 master mix") - if perform_column_tip_pick_up: + if column_tip_pick_up: column() p96.pick_up_tip(column_tips.pop(0)) for col in range(12): @@ -290,7 +274,7 @@ def add_liquid( # Step 14: PCR2 thermal cycling protocol.comment("Starting PCR2 thermal cycling") if disposable_lid: - protocol.move_labware(lids[0], pcr2_plate, use_gripper=True) + protocol.move_lid(lids, pcr2_plate, use_gripper=True) thermocycler.close_lid() thermocycler.set_lid_temperature(105) # Initial denaturation @@ -318,11 +302,11 @@ def add_liquid( thermocycler.open_lid() if disposable_lid: - protocol.move_labware(lids[0], waste_chute, use_gripper=True) + protocol.move_lid(pcr2_plate, waste_chute, use_gripper=True) # Step 15: Move PCR2 plate protocol.comment("Moving PCR2 plate") - protocol.move_labware(pcr1_dilution_plate, "A2", use_gripper=True) + protocol.move_labware(pcr1_dilution_plate, "A4", use_gripper=True) protocol.move_labware(pcr2_plate, reagent_block, use_gripper=True) # Steps 16-17: PCR2 dilution @@ -331,7 +315,7 @@ def add_liquid( transfer(p96, 25, reservoir["A1"], pcr2_dilution_plate["A1"]) transfer(p96, 5, pcr2_plate["A1"], pcr2_dilution_plate["A1"], mix_after=(10, 45)) p96.return_tip() - protocol.move_labware(reservoir, "A4", use_gripper=True) + protocol.move_labware(reservoir, "C4", use_gripper=True) protocol.move_labware(eppendorf_384, "D2", use_gripper=True) # Step 18: Optional transfer to 384-well plate @@ -351,10 +335,5 @@ def add_liquid( temp_module.deactivate() thermocycler.deactivate_lid() thermocycler.deactivate_block() - # Pause for plate removal - protocol.pause( - "Remove plates for quantification. Keep PCR2 dilution plate if continuing with pooling." - ) - protocol.comment("Protocol complete!") 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 deleted file mode 100644 index a3fd6251a43..00000000000 --- a/abr-testing/abr_testing/protocols/active_protocols/6_Omega_HDQ_DNA_Cells-Flex_96_channel.py +++ /dev/null @@ -1,433 +0,0 @@ -"""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) - helpers.create_deactivate_modules_parameter(parameters) - parameters.add_int( - variable_name="number_of_runs", - display_name="Number of Runs", - default=4, - minimum=1, - maximum=4, - ) - - -# Start protocol -def run(protocol: ProtocolContext) -> None: - """Protocol.""" - dot_bottom = protocol.params.dot_bottom # type: ignore[attr-defined] - deactivate_modules = protocol.params.deactivate_modules # type: ignore[attr-defined] - number_of_runs = protocol.params.number_of_runs # type: ignore[attr-defined] - dry_run = False - tip_mixing = False - - wash_vol = 600.0 - AL_vol = 230.0 - bind_vol = 300.0 - sample_vol = 180.0 - elution_vol = 100.0 - helpers.comment_protocol_version(protocol, "02") - # 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 = protocol.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] - - temp: TemperatureModuleContext = protocol.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 = protocol.load_module( - "magneticBlockV1", "C1" - ) # type: ignore[assignment] - liquid_waste = protocol.load_labware("nest_1_reservoir_290ml", "B3", "Liquid Waste") - waste = liquid_waste.wells()[0].top() - - lysis_reservoir = protocol.load_labware(deepwell_type, "D2", "Lysis reservoir") - lysis_res = lysis_reservoir.wells()[0] - bind_reservoir = protocol.load_labware( - deepwell_type, "C2", "Beads and binding reservoir" - ) - bind_res = bind_reservoir.wells()[0] - wash1_reservoir = protocol.load_labware(deepwell_type, "C3", "Wash 1 reservoir") - wash1_res = wash1_reservoir.wells()[0] - wash2_reservoir = protocol.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 = protocol.load_labware( - "opentrons_flex_96_tiprack_1000ul", - "A1", - adapter="opentrons_flex_96_tiprack_adapter", - ) - tips = tiprack_1.wells()[0] - - tiprack_2 = protocol.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 = protocol.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(protocol, 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 - - def protocol_function() -> None: - # 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(200, samples_m, reps=4 if not dry_run else 1) - if not tip_mixing: - pip.return_tip() - - # Mix, then heat - protocol.comment("Lysis Mixing") - helpers.set_hs_speed(protocol, h_s, 1800, 10, False) - if not dry_run: - h_s.set_and_wait_for_temperature(55) - protocol.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 - protocol.comment("Binding incubation") - helpers.set_hs_speed(protocol, h_s, 1800, 10, True) - - # Transfer plate to magnet - helpers.move_labware_from_hs_to_destination( - protocol, sample_plate, h_s, magblock - ) - - protocol.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(550, samples_m.bottom(dot_bottom)) - pip.dispense(550, waste) - if starting_vol + binding_buffer_vol > 1000: - pip.aspirate(550, samples_m.bottom(dot_bottom)) - pip.dispense(550, waste) - pip.return_tip() - - # Transfer plate from magnet to H/S - helpers.move_labware_to_hs(protocol, 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(protocol, h_s, 1800, 5, True) - - # Transfer plate to magnet - helpers.move_labware_from_hs_to_destination( - protocol, sample_plate, h_s, magblock - ) - - protocol.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(473, samples_m.bottom(dot_bottom)) - pip.dispense(473, bind_res.top()) - if wash_vol > 1000: - pip.aspirate(473, samples_m.bottom(dot_bottom)) - pip.dispense(473, bind_res.top()) - pip.return_tip() - - # Transfer plate from magnet to H/S - helpers.move_labware_to_hs(protocol, 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): - protocol.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(protocol, h_s, 2000, 5, True) - - # Transfer plate to magnet - helpers.move_labware_from_hs_to_destination( - protocol, sample_plate, h_s, magblock - ) - - protocol.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(500, samples_m) - pip.dispense(500, liquid_waste["A1"].top()) - pip.aspirate(500, wash1_res) - pip.dispense(500, liquid_waste["A1"].top()) - pip.aspirate(500, wash2_res) - pip.dispense(500, liquid_waste["A1"].top()) - pip.return_tip() - helpers.find_liquid_height_of_all_wells(protocol, pip, [liquid_waste["A1"]]) - helpers.move_labware_to_hs(protocol, sample_plate, h_s, h_s_adapter) - - def setup() -> None: - pip.pick_up_tip() - pip.transfer( - volume=250, - source=liquid_waste["A1"].bottom(z=2), - dest=lysis_reservoir["A1"], - blow_out=True, - blowout_location="source well", - new_tip="never", - trash=False, - ) - pip.transfer( - 1700, - liquid_waste["A1"].bottom(z=2), - wash1_reservoir["A1"], - blow_out=True, - blowout_location="source well", - new_tip="never", - trash=False, - ) - pip.transfer( - 1100, - bind_reservoir["A1"].bottom(z=2), - wash2_reservoir["A1"], - blow_out=True, - blowout_location="source well", - new_tip="never", - trash=False, - ) - pip.transfer( - 100, - liquid_waste["A1"].bottom(z=2), - sample_plate["A1"], - blow_out=True, - blowout_location="source well", - new_tip="never", - trash=False, - ) - pip.return_tip() - - def clean() -> None: - plates_to_clean = [ - sample_plate, - elutionplate, - wash2_reservoir, - wash1_reservoir, - ] - helpers.clean_up_plates(pip, plates_to_clean, liquid_waste["A1"], 1000) - - for i in range(number_of_runs): - protocol_function() - - pip.reset_tipracks() - if i < number_of_runs - 1: - setup() - pip.reset_tipracks() - clean() - if deactivate_modules: - helpers.deactivate_modules(protocol) - helpers.find_liquid_height_of_all_wells(protocol, pip, [liquid_waste["A1"]]) diff --git a/abr-testing/abr_testing/protocols/active_protocols/6_QUiCKR_Kit_Part1and2.py b/abr-testing/abr_testing/protocols/active_protocols/6_QUiCKR_Kit_Part1and2.py new file mode 100644 index 00000000000..67b17f89067 --- /dev/null +++ b/abr-testing/abr_testing/protocols/active_protocols/6_QUiCKR_Kit_Part1and2.py @@ -0,0 +1,248 @@ +"""QUiCKR V2 Kit Part 1 & 2.""" +from opentrons.protocol_api import ProtocolContext, COLUMN, ALL, ParameterContext, Well +from abr_testing.protocols import helpers +from typing import List, Dict + +metadata = {"protocolName": "QUiCKR V2 kit - part 1 and 2", "author": "Opentrons"} +requirements = {"robotType": "Flex", "apiLevel": "2.20"} + + +def add_parameters(parameters: ParameterContext) -> None: + """Parameters.""" + parameters.add_bool( + variable_name="buffer_filling", + display_name="Fill the buffer on deck", + default=True, + ) + parameters.add_int( + variable_name="num_plate_pairs", + display_name="Number of 96-384 pairs", + description="Number of 96-384 pairs", + default=2, + choices=[ + {"display_name": "1", "value": 1}, + {"display_name": "2", "value": 2}, + ], + ) + + +def run(protocol: ProtocolContext) -> None: + """Quick V2 Kit Part 1 and 2.""" + num_plate_pairs = protocol.params.num_plate_pairs # type: ignore[attr-defined] + buffer_filling = protocol.params.buffer_filling # type: ignore[attr-defined] + # deck layout + plate_384_slots = ["C1", "B1", "A1"] + plate_384_name = ["Assay Plate #1", "Assay Plate #2", "Assay Plate #3"] + plate_96_slots = ["C2", "B2", "A2"] + plate_96_name = ["Sample Plate #1", "Sample Plate #2", "Sample Plate #3"] + protocol.load_waste_chute() + plate_384 = [ + protocol.load_labware("biorad_384_wellplate_50ul", slot, name) + for slot, name in zip( + plate_384_slots[:num_plate_pairs], plate_384_name[:num_plate_pairs] + ) + ] + plate_96 = [ + protocol.load_labware("opentrons_96_wellplate_200ul_pcr_full_skirt", slot, name) + for slot, name in zip( + plate_96_slots[:num_plate_pairs], plate_96_name[:num_plate_pairs] + ) + ] + # Initial sample location + sample_wells: List[Well] = [] + for plate in plate_96: + for col in [0, 4, 8]: + for row in range(8): + sample_wells.append(plate.rows()[row][col]) + # Initial Control location + control_wells: List[Well] = [] + for plate in plate_96: + for well in [71, 79, 87, 95]: + control_wells.append(plate.wells()[well]) + if buffer_filling: + reagent_res = protocol.load_labware( + "nest_12_reservoir_15ml", "D1", "Assay Buffer" + ) + buffer_96 = reagent_res.wells()[11] + tiprack_200 = protocol.load_labware("opentrons_flex_96_tiprack_200ul", "D2") + liquid_waste = protocol.load_labware("nest_1_reservoir_195ml", "A2") + if num_plate_pairs == 1: + deck_slots_50 = ["C3", "B3"] + tiprack_adapter = [ + protocol.load_adapter("opentrons_flex_96_tiprack_adapter", slot) + for slot in deck_slots_50 + ] + + tiprack_50 = [ + tiprack_adapter[i].load_labware("opentrons_flex_96_tiprack_50ul", slot) + for i, slot in enumerate(deck_slots_50) + ] + + tips = [tiprack_50[0], tiprack_50[1]] + + elif num_plate_pairs == 2: + deck_slots_50 = ["C3", "B3", "A3"] + tiprack_adapter = [ + protocol.load_adapter("opentrons_flex_96_tiprack_adapter", slot) + for slot in deck_slots_50 + ] + + tiprack_50 = [ + tiprack_adapter[i].load_labware("opentrons_flex_96_tiprack_50ul", slot) + for i, slot in enumerate(deck_slots_50) + ] + + extra_50 = ["C4"] + tiprack_50_refill = [ + protocol.load_labware("opentrons_flex_96_tiprack_50ul", slot) + for slot in extra_50 + ] + + tips = [tiprack_50[0], tiprack_50[1], tiprack_50[2], tiprack_50_refill[0]] + + # pipette setting + p = protocol.load_instrument("flex_96channel_200", tip_racks=tiprack_50[:3]) + + # liquid info + liquid_vols_and_wells: Dict[str, List[Dict[str, Well | List[Well] | float]]] = { + "Samples": [{"well": sample_wells, "volume": 60.0}], + "Assay Buffer": [ + { + "well": [reagent_res.wells()[11]], + "volume": 3000.0 * float(num_plate_pairs) + 2000.0, + } + ], + "Controls": [{"well": control_wells, "volume": 60.0}], + } + helpers.load_wells_with_custom_liquids(protocol, liquid_vols_and_wells) + + helpers.find_liquid_height_of_loaded_liquids( + protocol, liquid_vols_and_wells=liquid_vols_and_wells, pipette=p + ) + + if buffer_filling: + protocol.pause("Please remove one tip from tiprack D2 tip H1") + if num_plate_pairs == 1: + protocol.pause("Please remove one tip from tiprack D2 tip H5") + if num_plate_pairs == 2: + protocol.pause("Please remove one tip from tiprack D2 tip H5, H8") + if num_plate_pairs == 3: + protocol.pause("Please remove one tip from tiprack D2 tip H5, H8, H11") + else: + if num_plate_pairs == 1: + protocol.pause("Please remove one tip from tiprack D2 tip H3") + if num_plate_pairs == 2: + protocol.pause("Please remove one tip from tiprack D2 tip H3, H6") + if num_plate_pairs == 3: + protocol.pause("Please remove one tip from tiprack D2 tip H3, H6, H9") + + p.configure_nozzle_layout(style=COLUMN, start="A12", tip_racks=[tiprack_200]) + if buffer_filling: + + p.pick_up_tip() + + for plate in plate_96: + p.aspirate(40 * 3 + 10, buffer_96.bottom(z=1), rate=0.5) + protocol.delay(seconds=1) + for j in range(3): + p.dispense(40, plate.rows()[0][9 + j].bottom(z=2)) + protocol.delay(seconds=1) + p.blow_out(buffer_96.top(z=-2)) + + p.drop_tip() + + p.pick_up_tip() + + for plate in plate_96: + for i in range(2): + p.aspirate(40 * 3 + 10, buffer_96.bottom(z=1), rate=0.5) + protocol.delay(seconds=1) + for j in range(3): + p.dispense(40, plate.rows()[0][i * 4 + j + 1].bottom(z=2)) + protocol.delay(seconds=1) + p.blow_out(buffer_96.top(z=-2)) + + p.drop_tip() + + col_ctr = 0 + for plate in plate_96: + for _ in range(9): + if not p.has_tip: + p.pick_up_tip() + p.aspirate(20, plate.rows()[0][col_ctr].bottom(z=2), rate=0.2) + protocol.delay(seconds=1) + p.dispense(20, plate.rows()[0][col_ctr + 1].bottom(z=5), rate=0.5) + p.mix(5, 20, plate.rows()[0][col_ctr + 1].bottom(z=2)) + p.blow_out(plate.rows()[0][col_ctr + 1].top()) + col_ctr += 1 + if col_ctr > 0 and (col_ctr + 1) % 4 == 0: + p.drop_tip() + col_ctr += 1 + col_ctr = 0 + + p.configure_nozzle_layout(style=ALL) + for i in range(num_plate_pairs): + + if i == 1: + protocol.move_labware( + labware=tiprack_50[0], + new_location="D4", + use_gripper=True, + ) + protocol.move_labware( + labware=tiprack_50_refill[0], + new_location=tiprack_adapter[0], + use_gripper=True, + ) + elif i == 2: + protocol.move_labware( + labware=tiprack_50[1], + new_location="A1", + use_gripper=True, + ) + protocol.move_labware( + labware=tiprack_50_refill[1], + new_location=tiprack_adapter[1], + use_gripper=True, + ) + protocol.move_labware( + labware=tiprack_50[2], + new_location="A2", + use_gripper=True, + ) + protocol.move_labware( + labware=tiprack_50_refill[2], + new_location=tiprack_adapter[2], + use_gripper=True, + ) + for n in range(3): + p.tip_racks = [tips[i * 2]] + p.pick_up_tip() + p.aspirate(7 * 2, plate_96[i]["A1"].bottom(z=2)) + protocol.delay(seconds=1) + p.dispense(7, plate_384[i]["A1"].bottom(z=2)) + protocol.delay(seconds=1) + p.dispense(7, plate_384[i]["A2"].bottom(z=2)) + protocol.delay(seconds=1) + p.mix(5, 7, plate_384[i]["A2"].bottom(z=2)) + p.blow_out(plate_384[i]["A2"].top()) + p.mix(5, 7, plate_384[i]["A1"].bottom(z=2)) + p.blow_out(plate_384[i]["A1"].top()) + p.return_tip() + p.reset_tipracks() + p.tip_racks = [tips[i * 2 + 1]] + p.pick_up_tip() + p.aspirate(7 * 2, plate_96[i]["A1"].bottom(z=2)) + protocol.delay(seconds=1) + p.dispense(7, plate_384[i]["B1"].bottom(z=2)) + protocol.delay(seconds=1) + p.dispense(7, plate_384[i]["B2"].bottom(z=2)) + protocol.delay(seconds=1) + p.mix(5, 7, plate_384[i]["B2"].bottom(z=2)) + p.blow_out(plate_384[i]["B2"].top()) + p.mix(5, 7, plate_384[i]["B1"].bottom(z=2)) + p.blow_out(plate_384[i]["B1"].top()) + p.return_tip() + p.reset_tipracks() + all_plates = plate_384 + plate_96 + [reagent_res] + helpers.clean_up_plates(p, all_plates, liquid_waste["A1"], 50) diff --git a/abr-testing/abr_testing/protocols/active_protocols/8_Illumina and Plate Reader.py b/abr-testing/abr_testing/protocols/active_protocols/8_Illumina and Plate Reader.py index 3d8c664956c..8bb528f647b 100644 --- a/abr-testing/abr_testing/protocols/active_protocols/8_Illumina and Plate Reader.py +++ b/abr-testing/abr_testing/protocols/active_protocols/8_Illumina and Plate Reader.py @@ -119,8 +119,6 @@ def run(protocol: ProtocolContext) -> None: plate_name_str = "hellma_plate_" + str(plate_orientation) global p200_tips global p50_tips - # WASTE BIN - protocol.load_waste_chute() # TIP RACKS tiprack_200_1 = protocol.load_labware("opentrons_flex_96_tiprack_200ul", "B2") tiprack_200_2 = protocol.load_labware("opentrons_flex_96_tiprack_200ul", "C2") diff --git a/abr-testing/abr_testing/protocols/helpers.py b/abr-testing/abr_testing/protocols/helpers.py index 07670022403..31a1d1a9244 100644 --- a/abr-testing/abr_testing/protocols/helpers.py +++ b/abr-testing/abr_testing/protocols/helpers.py @@ -215,7 +215,7 @@ def create_disposable_lid_parameter(parameters: ParameterContext) -> None: variable_name="disposable_lid", display_name="Disposable Lid", description="True means use lid.", - default=False, + default=True, ) diff --git a/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py b/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py new file mode 100644 index 00000000000..1cf9b520806 --- /dev/null +++ b/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py @@ -0,0 +1,443 @@ +"""All Liquid Set Ups.""" +from opentrons.protocol_api import ( + ProtocolContext, + ParameterContext, + COLUMN, + ALL, + OFF_DECK, +) +from typing import Dict, List + +metadata = { + "protocolName": "Liquid Set up for all robots", + "author": "Rhyann clarke ", + "source": "Protocol Library", +} + +requirements = { + "robotType": "Flex", + "apiLevel": "2.21", +} + + +SLOTS: Dict[str, str | List[str]] = { + "FULL_TIP_RACK": "A1", + "PARTIAL_TIP_RACK_1000": "C2", + "PARTIAL_TIP_RACK_200": "B3", + "SRC_RESERVOIR": "B1", + "LABWARE": ["D1", "D2", "D3", "C1", "C3"], + "TRASH_BIN": "A3", +} + + +def add_parameters(parameters: ParameterContext) -> None: + """Parameters to determine which set ups to run.""" + robot_list = [ + "DVT1ABR1", + "DVT1ABR2", + "DVT1ABR3", + "DVT1ABR4", + "DVT2ABR5", + "DVT2ABR6", + "PVT1ABR7", + "PVT1ABR8", + "PVT1ABR9", + "PVT1ABR10", + "PVT1ABR11", + "PVT1ABR12", + ] + for robot in robot_list: + parameters.add_bool(variable_name=robot, display_name=robot, default=True) + + +def run(protocol: ProtocolContext) -> None: + """Protocol to fill all robot plates.""" + protocol.load_trash_bin(str(SLOTS["TRASH_BIN"])) + tip_rack = protocol.load_labware( + "opentrons_flex_96_tiprack_1000ul", + str(SLOTS["FULL_TIP_RACK"]), + adapter="opentrons_flex_96_tiprack_adapter", + ) + tip_rack_partial = protocol.load_labware( + "opentrons_flex_96_tiprack_1000ul", str(SLOTS["PARTIAL_TIP_RACK_1000"]) + ) + tip_rack_partial_200 = protocol.load_labware( + "opentrons_flex_96_tiprack_200ul", str(SLOTS["PARTIAL_TIP_RACK_200"]) + ) + src_reservoir = protocol.load_labware( + "nest_1_reservoir_290ml", str(SLOTS["SRC_RESERVOIR"]) + ) + pipette = protocol.load_instrument("flex_96channel_1000") + # LOAD PARAMETERS + dvt1abr1 = protocol.params.DVT1ABR1 # type: ignore[attr-defined] + dvt1abr2 = protocol.params.DVT1ABR2 # type: ignore[attr-defined] + dvt1abr3 = protocol.params.DVT1ABR3 # type: ignore[attr-defined] + dvt1abr4 = protocol.params.DVT1ABR4 # type: ignore[attr-defined] + dvt2abr5 = protocol.params.DVT2ABR5 # type: ignore[attr-defined] + dvt2abr6 = protocol.params.DVT2ABR6 # type: ignore[attr-defined] + pvt1abr7 = protocol.params.PVT1ABR7 # type: ignore[attr-defined] + pvt1abr8 = protocol.params.PVT1ABR8 # type: ignore[attr-defined] + pvt1abr9 = protocol.params.PVT1ABR9 # type: ignore[attr-defined] + pvt1abr10 = protocol.params.PVT1ABR10 # type: ignore[attr-defined] + pvt1abr11 = protocol.params.PVT1ABR11 # type: ignore[attr-defined] + pvt1abr12 = protocol.params.PVT1ABR12 # type: ignore[attr-defined] + if pvt1abr7: + protocol.pause("SET UP PVT1ABR7") + res1 = protocol.load_labware( + "nest_12_reservoir_15ml", str(SLOTS["LABWARE"][0]), "Reservoir" + ) + elution_plate = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", + str(SLOTS["LABWARE"][1]), + "Elution Plate", + ) + sample_plate = protocol.load_labware( + "nest_96_wellplate_2ml_deep", str(SLOTS["LABWARE"][2]), "Sample Plate" + ) + pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) + pipette.transfer( + 200, src_reservoir["A1"], sample_plate["A1"].top(), trash=False + ) + pipette.reset_tipracks() + pipette.transfer( + 100, src_reservoir["A1"], elution_plate["A1"].top(), trash=False + ) + pipette.reset_tipracks() + pipette.transfer(600, src_reservoir["A1"], res1["A1"].top(), trash=False) + pipette.reset_tipracks() + pvt1abr7_labware = [res1, elution_plate, sample_plate] + for lw in pvt1abr7_labware: + protocol.move_labware(lw, OFF_DECK, use_gripper=False) + if pvt1abr9: + protocol.pause("SET UP PVT1ABR9") + res1 = protocol.load_labware( + "nest_12_reservoir_15ml", str(SLOTS["LABWARE"][0]), "Reservoir" + ) + elution_plate = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", + str(SLOTS["LABWARE"][1]), + "Elution Plate", + ) + sample_plate = protocol.load_labware( + "nest_96_wellplate_2ml_deep", str(SLOTS["LABWARE"][2]), "Sample Plate" + ) + pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) + pipette.transfer( + 9500 / 8, src_reservoir["A1"], res1["A1"].top(), trash=False, blow_out=True + ) + pipette.reset_tipracks() + pipette.transfer( + 55, + src_reservoir["A1"], + elution_plate["A1"].bottom(z=1), + trash=False, + blow_out=True, + ) + pipette.reset_tipracks() + pipette.transfer( + 100, + src_reservoir["A1"], + sample_plate["A1"].top(), + trash=False, + blow_out=True, + ) + pipette.reset_tipracks() + pvt1abr9_labware = [res1, elution_plate, sample_plate] + for lw in pvt1abr9_labware: + protocol.move_labware(lw, OFF_DECK, use_gripper=False) + if pvt1abr10: + protocol.pause("SET UP PVT1ABR10") + res1 = protocol.load_labware( + "nest_12_reservoir_15ml", str(SLOTS["LABWARE"][0]), "Reagent Reservoir 1" + ) + res2 = protocol.load_labware( + "nest_12_reservoir_15ml", str(SLOTS["LABWARE"][1]), "Reagent Reservoir 2" + ) + res3 = protocol.load_labware( + "nest_12_reservoir_15ml", str(SLOTS["LABWARE"][2]), "Reagent Reservoir 3" + ) + lysis_and_pk = 12320 / 8 + beads_and_binding = 11875 / 8 + binding2 = 13500 / 8 + wash2 = 9800 / 8 + pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) + pipette.transfer(1225, src_reservoir["A1"], res2["A1"].top(), trash=False) + pipette.reset_tipracks() + pipette.configure_nozzle_layout( + style=COLUMN, start="A1", tip_racks=[tip_rack_partial] + ) + pipette.transfer( + volume=[ + lysis_and_pk, + beads_and_binding, + beads_and_binding, + beads_and_binding, + beads_and_binding, + beads_and_binding, + beads_and_binding, + beads_and_binding, + binding2, + binding2, + binding2, + binding2, + wash2, + wash2, + ], + source=src_reservoir["A1"], + dest=[ + res1["A1"].top(), + res1["A2"].top(), + res1["A3"].top(), + res1["A4"].top(), + res1["A5"].top(), + res1["A6"].top(), + res1["A7"].top(), + res1["A8"].top(), + res1["A9"].top(), + res1["A10"].top(), + res1["A11"].top(), + res1["A12"].top(), + res3["A1"].top(), + res3["A2"].top(), + ], + blow_out=True, + blowout_location="source well", + trash=True, + ) + pipette.reset_tipracks() + pvt1abr10_labware = [res1, res2, res3] + for lw in pvt1abr10_labware: + protocol.move_labware(lw, OFF_DECK, use_gripper=False) + if dvt1abr2: + protocol.pause("SET UP DVT1ABR2") + if dvt1abr3: + protocol.pause("SET UP DVT1ABR3") + if dvt1abr4: + protocol.pause("SET UP DVT1ABR4") + reservoir_1 = protocol.load_labware( + "nest_96_wellplate_2ml_deep", str(SLOTS["LABWARE"][0]), "Reservoir 1" + ) # Reservoir + sample_plate_2 = protocol.load_labware( + "thermoscientificnunc_96_wellplate_1300ul", + str(SLOTS["LABWARE"][1]), + "Sample Plate 2", + ) # Reservoir + sample_plate_1 = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", + str(SLOTS["LABWARE"][2]), + "Sample Plate 1", + ) # Sample Plate + reagent_plate_1 = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", + str(SLOTS["LABWARE"][3]), + "Reagent Plate", + ) # reagent Plate + pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) + pipette.pick_up_tip() + pipette.aspirate(150, src_reservoir["A1"]) + pipette.dispense(150, sample_plate_1["A1"].top()) + pipette.return_tip() + pipette.reset_tipracks() + pipette.configure_nozzle_layout( + style=COLUMN, start="A12", tip_racks=[tip_rack_partial] + ) + pipette.transfer( + volume=[120, 750, 900, 96, 1000, 1000, 1000, 1000], + source=src_reservoir["A1"], + dest=[ + reservoir_1["A1"].top(), # AMPure + reservoir_1["A2"].top(), # SMB + reservoir_1["A4"].top(), # EtOH + reservoir_1["A5"].top(), # RSB + sample_plate_2["A9"].top(), + sample_plate_2["A10"].top(), + sample_plate_2["A11"].top(), + sample_plate_2["A12"].top(), + ], + blow_out=True, + blowout_location="source well", + trash=True, + ) + pipette.configure_nozzle_layout( + style=COLUMN, start="A12", tip_racks=[tip_rack_partial_200] + ) + protocol.pause("about to use 200 ul tips, change reservoir") + pipette.transfer( + volume=[75, 15, 20, 65], + source=src_reservoir["A1"], + dest=[ + reagent_plate_1["A4"].top(), + reagent_plate_1["A5"].top(), + reagent_plate_1["A6"].top(), + reagent_plate_1["A7"].top(), + ], + blow_out=True, + blowout_location="source well", + trash=True, + ) + dvt1abr4_labware = [ + reservoir_1, + sample_plate_1, + sample_plate_2, + reagent_plate_1, + ] + for lw in dvt1abr4_labware: + protocol.move_labware(lw, OFF_DECK, use_gripper=False) + + if dvt2abr5: + protocol.pause("SET UP DVT2ABR5") + reservoir = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", + str(SLOTS["LABWARE"][0]), + "Reservoir", + ) + pcr_reagents_plate = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", + str(SLOTS["LABWARE"][1]), + "PCR Master Mix", + ) + indices_plate = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", + str(SLOTS["LABWARE"][2]), + "Indices", + ) + dna_plate = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", SLOTS["LABWARE"][3], "DNA" + ) + # RESERVOIR, INDICES PLATE, DNA PLATE + pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) + pipette.transfer( + volume=[150, 100, 100], + source=3 * [src_reservoir["A1"]], + dest=[reservoir["A1"], indices_plate["A1"], dna_plate["A1"]], + trash=False, + ) + pipette.reset_tipracks() + # partial tip for pcr_reagents_plate + pipette.configure_nozzle_layout( + style=COLUMN, start="A12", tip_racks=[tip_rack_partial_200] + ) + pipette.transfer( + [100, 100], + source=2 * [src_reservoir["A1"]], + dest=[pcr_reagents_plate["A1"], pcr_reagents_plate["A2"]], + trash=True, + ) + dvt2abr5_plates = [reservoir, pcr_reagents_plate, indices_plate, dna_plate] + for plate in dvt2abr5_plates: + protocol.move_labware(plate, OFF_DECK, use_gripper=False) + + if dvt2abr6: + protocol.pause("SET UP DVT2ABR6") + reservoir = protocol.load_labware( + "nest_12_reservoir_15ml", str(SLOTS["LABWARE"][0]), "Assay Buffer" + ) + sample_and_control_plate = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", + str(SLOTS["LABWARE"][1]), + "Sample and Control Plate", + ) + pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) + pipette.transfer( + [1000, 60], + source=2 * [src_reservoir["A1"]], + dest=[reservoir["A1"], sample_and_control_plate["A1"]], + trash=False, + ) + dvt2abr6_plates = [reservoir, sample_and_control_plate] + for plate in dvt2abr6_plates: + protocol.move_labware(plate, OFF_DECK, use_gripper=False) + pipette.reset_tipracks() + if pvt1abr8: + protocol.pause("SET UP PVT1ABR8") + reservoir_1 = protocol.load_labware( + "nest_96_wellplate_2ml_deep", str(SLOTS["LABWARE"][0]), "Reservoir 1" + ) # Reservoir + sample_plate_2 = protocol.load_labware( + "thermoscientificnunc_96_wellplate_1300ul", + str(SLOTS["LABWARE"][1]), + "Sample Plate 2", + ) # Reservoir + sample_plate_1 = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", + str(SLOTS["LABWARE"][2]), + "Sample Plate 1", + ) # Sample Plate + reagent_plate_1 = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", + str(SLOTS["LABWARE"][3]), + "Reagent Plate", + ) # reagent Plate + pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) + pipette.pick_up_tip() + pipette.aspirate(150, src_reservoir["A1"]) + pipette.dispense(150, sample_plate_1["A1"].top()) + pipette.return_tip() + pipette.configure_nozzle_layout( + style=COLUMN, start="A12", tip_racks=[tip_rack_partial] + ) + pipette.transfer( + volume=[120, 750, 900, 96, 1000, 1000, 1000, 1000], + source=src_reservoir["A1"], + dest=[ + reservoir_1["A1"].top(), # AMPure + reservoir_1["A2"].top(), # SMB + reservoir_1["A4"].top(), # EtOH + reservoir_1["A5"].top(), # RSB + sample_plate_2["A9"].top(), + sample_plate_2["A10"].top(), + sample_plate_2["A11"].top(), + sample_plate_2["A12"].top(), + ], + blow_out=True, + blowout_location="source well", + trash=True, + ) + pipette.configure_nozzle_layout( + style=COLUMN, start="A12", tip_racks=[tip_rack_partial_200] + ) + protocol.pause("about to use 200 ul tips, change reservoir") + pipette.transfer( + volume=[75, 15, 20, 65], + source=src_reservoir["A1"], + dest=[ + reagent_plate_1["A4"].bottom(z=1), + reagent_plate_1["A5"].bottom(z=1), + reagent_plate_1["A6"].bottom(z=1), + reagent_plate_1["A7"].bottom(z=1), + ], + blow_out=True, + blowout_location="source well", + trash=True, + ) + pvt1abr8_labware = [ + reservoir_1, + sample_plate_1, + sample_plate_2, + reagent_plate_1, + ] + for lw in pvt1abr8_labware: + protocol.move_labware(lw, OFF_DECK, use_gripper=False) + if dvt1abr1: + protocol.pause("SET UP DVT1ABR1") + reservoir = protocol.load_labware( + "nest_12_reservoir_15ml", str(SLOTS["LABWARE"][0]) + ) + pipette.configure_nozzle_layout(style=COLUMN, start="A1") + # fill last column + pipette.pick_up_tip(tip_rack_partial["A12"]) + pipette.aspirate(1000, src_reservoir["A1"]) + pipette.dispense(1000, reservoir["A6"].top()) + pipette.aspirate(65, src_reservoir["A1"]) + pipette.dispense(65, reservoir["A6"].top()) + pipette.drop_tip() + # FILL FIRST 5 COLUMNS + pipette.pick_up_tip(tip_rack_partial["A7"]) + pipette.aspirate(6175 / 8, src_reservoir["A1"]) + pipette.dispense(6175 / 8, reservoir["A1"].top()) + pipette.drop_tip() + protocol.move_labware(reservoir, OFF_DECK, use_gripper=False) + if pvt1abr11: + protocol.pause("SET UP PVT1ABR11") + if pvt1abr12: + protocol.pause("SET UP PVT1ABR12") diff --git a/abr-testing/abr_testing/protocols/test_protocols/quick.py b/abr-testing/abr_testing/protocols/test_protocols/quick.py deleted file mode 100644 index 9c80910f6b4..00000000000 --- a/abr-testing/abr_testing/protocols/test_protocols/quick.py +++ /dev/null @@ -1,168 +0,0 @@ -metadata = { - 'protocolName': 'QUiCKR V2 kit - part 2 ', - 'author': 'Opentrons' -} -requirements = { - 'robotType': 'Flex', - 'apiLevel': '2.20' -} - - -def add_parameters(parameters): - - parameters.add_int( - variable_name="num_plate_pairs", - display_name="Number of 96-384 pairs", - description="Number of 96-384 pairs", - default=2, - choices=[ - {"display_name": "1", "value": 1}, - {"display_name": "2", "value": 2}, - {"display_name": "3", "value": 3} - ] -) - - -def run(ctx): - - num_plate_pairs = ctx.params.num_plate_pairs - - # deck layout - plate_384_slots = ['C1', 'B1', 'A1'] - plate_384_name = ['Assay Plate #1', 'Assay Plate #2', 'Assay Plate #3'] - plate_96_slots = ['C2', 'B2', 'A2'] - plate_96_name = ['Sample Plate #1', 'Sample Plate #2', 'Sample Plate #3'] - - plate_384 = [ctx.load_labware('biorad_384_wellplate_50ul', slot, name) - for slot, name in zip(plate_384_slots[:num_plate_pairs], plate_384_name[:num_plate_pairs])] - plate_96 = [ctx.load_labware('opentrons_96_wellplate_200ul_pcr_full_skirt', slot, name) - for slot, name in zip(plate_96_slots[:num_plate_pairs], plate_96_name[:num_plate_pairs])] - - if num_plate_pairs == 1: - deck_slots_50 = ['C3', 'B3'] - tiprack_adapter = [ctx.load_adapter('opentrons_flex_96_tiprack_adapter', slot) - for slot in deck_slots_50] - - tiprack_50 = [tiprack_adapter[i].load_labware('opentrons_flex_96_tiprack_50ul', slot) - for i, slot in enumerate(deck_slots_50)] - - tips = [tiprack_50[0], tiprack_50[1]] - - elif num_plate_pairs == 2: - deck_slots_50 = ['C3', 'B3', 'A3'] - tiprack_adapter = [ctx.load_adapter('opentrons_flex_96_tiprack_adapter', slot) - for slot in deck_slots_50] - - tiprack_50 = [tiprack_adapter[i].load_labware('opentrons_flex_96_tiprack_50ul', slot) - for i, slot in enumerate(deck_slots_50)] - - extra_50 = ['C4'] - tiprack_50_refill = [ctx.load_labware('opentrons_flex_96_tiprack_50ul', slot) - for slot in extra_50] - - tips = [tiprack_50[0], tiprack_50[1], tiprack_50[2], tiprack_50_refill[0]] - - elif num_plate_pairs == 3: - deck_slots_50 = ['C3', 'B3', 'A3'] - tiprack_adapter = [ctx.load_adapter('opentrons_flex_96_tiprack_adapter', slot) - for slot in deck_slots_50] - - tiprack_50 = [tiprack_adapter[i].load_labware('opentrons_flex_96_tiprack_50ul', slot) - for i, slot in enumerate(deck_slots_50)] - - extra_50 = ['C4', 'B4', 'A4'] - tiprack_50_refill = [ctx.load_labware('opentrons_flex_96_tiprack_50ul', slot) - for slot in extra_50] - - tips = [tiprack_50[0], tiprack_50[1], tiprack_50[2], tiprack_50_refill[0], tiprack_50_refill[1], tiprack_50_refill[2]] - - # pipette setting - p = ctx.load_instrument("flex_96channel_200", tip_racks=tiprack_50[:3]) - p.flow_rate.aspirate = 7 - p.flow_rate.dispense = 7 * 2 - - - # liquid info - sample_liq = ctx.define_liquid(name="Samples", description="Samples (diluted)", display_color="#7EFF42") - for plate in plate_96: - for col in [0, 4]: - [plate.rows()[row][col].load_liquid(liquid=sample_liq, volume=40) - for row in range(8)] - [plate.rows()[row][8].load_liquid(liquid=sample_liq, volume=40) - for row in range(7)] - for col in [1,2,5,6]: - [plate.rows()[row][col].load_liquid(liquid=sample_liq, volume=40) - for row in range(8)] - for col in [3,7]: - [plate.rows()[row][col].load_liquid(liquid=sample_liq, volume=60) - for row in range(8)] - for col in [9,10]: - [plate.rows()[row][col].load_liquid(liquid=sample_liq, volume=40) - for row in range(7)] - [plate.rows()[row][11].load_liquid(liquid=sample_liq, volume=60) - for row in range(7)] - - control_liq = ctx.define_liquid(name="Controls", description="Controls", display_color="#FF4F4F") - for plate in plate_96: - [plate.wells()[well].load_liquid(liquid=control_liq, volume=40) - for well in [71, 79, 87, 95]] - - - for i in range(num_plate_pairs): - - if i == 1: - ctx.move_labware(labware = tiprack_50[0], - new_location = "D4", - use_gripper=True, - ) - ctx.move_labware(labware = tiprack_50_refill[0], - new_location = tiprack_adapter[0], - use_gripper=True, - ) - elif i == 2: - ctx.move_labware(labware = tiprack_50[1], - new_location = "A1", - use_gripper=True, - ) - ctx.move_labware(labware = tiprack_50_refill[1], - new_location = tiprack_adapter[1], - use_gripper=True, - ) - ctx.move_labware(labware = tiprack_50[2], - new_location = "A2", - use_gripper=True, - ) - ctx.move_labware(labware = tiprack_50_refill[2], - new_location = tiprack_adapter[2], - use_gripper=True, - ) - for n in range(12): - p.tip_racks = [tips[i*2]] - p.pick_up_tip() - p.aspirate(7*2, plate_96[i]['A1'].bottom(z=2)) - ctx.delay(seconds=1) - p.dispense(7, plate_384[i]['A1'].bottom(z=2)) - ctx.delay(seconds=1) - p.dispense(7, plate_384[i]['A2'].bottom(z=2)) - ctx.delay(seconds=1) - p.mix(5, 7, plate_384[i]['A2'].bottom(z=2)) - p.blow_out(plate_384[i]['A2'].top()) - p.mix(5, 7, plate_384[i]['A1'].bottom(z=2)) - p.blow_out(plate_384[i]['A1'].top()) - p.return_tip() - p.reset_tipracks() - p.tip_racks = [tips[i*2+1]] - p.pick_up_tip() - p.aspirate(7*2, plate_96[i]['A1'].bottom(z=2)) - ctx.delay(seconds=1) - p.dispense(7, plate_384[i]['B1'].bottom(z=2)) - ctx.delay(seconds=1) - p.dispense(7, plate_384[i]['B2'].bottom(z=2)) - ctx.delay(seconds=1) - p.mix(5, 7, plate_384[i]['B2'].bottom(z=2)) - p.blow_out(plate_384[i]['B2'].top()) - p.mix(5, 7, plate_384[i]['B1'].bottom(z=2)) - p.blow_out(plate_384[i]['B1'].top()) - p.return_tip() - p.reset_tipracks() - From b261db2755d0bfe12b96103167f4146292629acc Mon Sep 17 00:00:00 2001 From: rclarke0 Date: Mon, 10 Feb 2025 12:31:50 -0500 Subject: [PATCH 04/10] change hellma slot location --- .../protocols/active_protocols/8_Illumina and Plate Reader.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/abr-testing/abr_testing/protocols/active_protocols/8_Illumina and Plate Reader.py b/abr-testing/abr_testing/protocols/active_protocols/8_Illumina and Plate Reader.py index 8bb528f647b..5b7fa205979 100644 --- a/abr-testing/abr_testing/protocols/active_protocols/8_Illumina and Plate Reader.py +++ b/abr-testing/abr_testing/protocols/active_protocols/8_Illumina and Plate Reader.py @@ -28,7 +28,7 @@ requirements = {"robotType": "Flex", "apiLevel": "2.21"} -HELLMA_PLATE_SLOT = "D4" +HELLMA_PLATE_SLOT = "D3" PLATE_READER_SLOT = "C3" # SCRIPT SETTINGS From b9c6bdbd71fd928bc22fac54e3cc73d12f2c49e0 Mon Sep 17 00:00:00 2001 From: rclarke0 Date: Mon, 10 Feb 2025 12:40:46 -0500 Subject: [PATCH 05/10] adding blowouts to transfer --- .../liquid_setups/All_Liquid_Set_ups.py | 38 +++++++++++++------ 1 file changed, 26 insertions(+), 12 deletions(-) diff --git a/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py b/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py index 1cf9b520806..a93cb2bf7a3 100644 --- a/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py +++ b/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py @@ -96,14 +96,20 @@ def run(protocol: ProtocolContext) -> None: ) pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) pipette.transfer( - 200, src_reservoir["A1"], sample_plate["A1"].top(), trash=False + 200, src_reservoir["A1"], sample_plate["A1"].top(), trash=False, + blow_out = True, + blowout_location = "destination well" ) pipette.reset_tipracks() pipette.transfer( - 100, src_reservoir["A1"], elution_plate["A1"].top(), trash=False + 100, src_reservoir["A1"], elution_plate["A1"].top(), trash=False, + blow_out = True, + blowout_location = "destination well" ) pipette.reset_tipracks() - pipette.transfer(600, src_reservoir["A1"], res1["A1"].top(), trash=False) + pipette.transfer(600, src_reservoir["A1"], res1["A1"].top(), trash=False, + blow_out = True, + blowout_location = "destination well") pipette.reset_tipracks() pvt1abr7_labware = [res1, elution_plate, sample_plate] for lw in pvt1abr7_labware: @@ -123,7 +129,7 @@ def run(protocol: ProtocolContext) -> None: ) pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) pipette.transfer( - 9500 / 8, src_reservoir["A1"], res1["A1"].top(), trash=False, blow_out=True + 9500 / 8, src_reservoir["A1"], res1["A1"].top(), trash=False, blow_out = True, blowout_location = "destination well" ) pipette.reset_tipracks() pipette.transfer( @@ -132,6 +138,7 @@ def run(protocol: ProtocolContext) -> None: elution_plate["A1"].bottom(z=1), trash=False, blow_out=True, + blowout_location = "destination well" ) pipette.reset_tipracks() pipette.transfer( @@ -140,6 +147,7 @@ def run(protocol: ProtocolContext) -> None: sample_plate["A1"].top(), trash=False, blow_out=True, + blowout_location = "destination well" ) pipette.reset_tipracks() pvt1abr9_labware = [res1, elution_plate, sample_plate] @@ -161,7 +169,7 @@ def run(protocol: ProtocolContext) -> None: binding2 = 13500 / 8 wash2 = 9800 / 8 pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) - pipette.transfer(1225, src_reservoir["A1"], res2["A1"].top(), trash=False) + pipette.transfer(1225, src_reservoir["A1"], res2["A1"].top(), trash=False, blow_out = True, blowout_location = "destination well") pipette.reset_tipracks() pipette.configure_nozzle_layout( style=COLUMN, start="A1", tip_racks=[tip_rack_partial] @@ -201,7 +209,7 @@ def run(protocol: ProtocolContext) -> None: res3["A2"].top(), ], blow_out=True, - blowout_location="source well", + blowout_location="destination well", trash=True, ) pipette.reset_tipracks() @@ -255,7 +263,7 @@ def run(protocol: ProtocolContext) -> None: sample_plate_2["A12"].top(), ], blow_out=True, - blowout_location="source well", + blowout_location="destination well", trash=True, ) pipette.configure_nozzle_layout( @@ -272,7 +280,7 @@ def run(protocol: ProtocolContext) -> None: reagent_plate_1["A7"].top(), ], blow_out=True, - blowout_location="source well", + blowout_location="destination well", trash=True, ) dvt1abr4_labware = [ @@ -311,6 +319,8 @@ def run(protocol: ProtocolContext) -> None: source=3 * [src_reservoir["A1"]], dest=[reservoir["A1"], indices_plate["A1"], dna_plate["A1"]], trash=False, + blow_out = True, + blowout_destination = "destination well" ) pipette.reset_tipracks() # partial tip for pcr_reagents_plate @@ -322,6 +332,8 @@ def run(protocol: ProtocolContext) -> None: source=2 * [src_reservoir["A1"]], dest=[pcr_reagents_plate["A1"], pcr_reagents_plate["A2"]], trash=True, + blow_out = True, + blowout_location = "destination well" ) dvt2abr5_plates = [reservoir, pcr_reagents_plate, indices_plate, dna_plate] for plate in dvt2abr5_plates: @@ -343,6 +355,8 @@ def run(protocol: ProtocolContext) -> None: source=2 * [src_reservoir["A1"]], dest=[reservoir["A1"], sample_and_control_plate["A1"]], trash=False, + blow_out= True, + blowout_location = "destination well" ) dvt2abr6_plates = [reservoir, sample_and_control_plate] for plate in dvt2abr6_plates: @@ -389,9 +403,9 @@ def run(protocol: ProtocolContext) -> None: sample_plate_2["A11"].top(), sample_plate_2["A12"].top(), ], - blow_out=True, - blowout_location="source well", trash=True, + blow_out = True, + blowout_location = "destination well" ) pipette.configure_nozzle_layout( style=COLUMN, start="A12", tip_racks=[tip_rack_partial_200] @@ -406,9 +420,9 @@ def run(protocol: ProtocolContext) -> None: reagent_plate_1["A6"].bottom(z=1), reagent_plate_1["A7"].bottom(z=1), ], - blow_out=True, - blowout_location="source well", trash=True, + blow_out = True, + blowout_location = "destination well" ) pvt1abr8_labware = [ reservoir_1, From 5f6a604ca474f26f7fb435609c3cd774ba66095e Mon Sep 17 00:00:00 2001 From: rclarke0 Date: Tue, 11 Feb 2025 11:34:33 -0500 Subject: [PATCH 06/10] remove waste chute, adjust liquid set up --- .../6_QUiCKR_Kit_Part1and2.py | 4 +- .../liquid_setups/All_Liquid_Set_ups.py | 192 ++++++++++++------ 2 files changed, 128 insertions(+), 68 deletions(-) diff --git a/abr-testing/abr_testing/protocols/active_protocols/6_QUiCKR_Kit_Part1and2.py b/abr-testing/abr_testing/protocols/active_protocols/6_QUiCKR_Kit_Part1and2.py index 67b17f89067..72a1f423f51 100644 --- a/abr-testing/abr_testing/protocols/active_protocols/6_QUiCKR_Kit_Part1and2.py +++ b/abr-testing/abr_testing/protocols/active_protocols/6_QUiCKR_Kit_Part1and2.py @@ -30,12 +30,12 @@ def run(protocol: ProtocolContext) -> None: """Quick V2 Kit Part 1 and 2.""" num_plate_pairs = protocol.params.num_plate_pairs # type: ignore[attr-defined] buffer_filling = protocol.params.buffer_filling # type: ignore[attr-defined] + protocol.load_trash_bin("A3") # deck layout plate_384_slots = ["C1", "B1", "A1"] plate_384_name = ["Assay Plate #1", "Assay Plate #2", "Assay Plate #3"] plate_96_slots = ["C2", "B2", "A2"] plate_96_name = ["Sample Plate #1", "Sample Plate #2", "Sample Plate #3"] - protocol.load_waste_chute() plate_384 = [ protocol.load_labware("biorad_384_wellplate_50ul", slot, name) for slot, name in zip( @@ -81,7 +81,7 @@ def run(protocol: ProtocolContext) -> None: tips = [tiprack_50[0], tiprack_50[1]] elif num_plate_pairs == 2: - deck_slots_50 = ["C3", "B3", "A3"] + deck_slots_50 = ["C3", "B3", "A1"] tiprack_adapter = [ protocol.load_adapter("opentrons_flex_96_tiprack_adapter", slot) for slot in deck_slots_50 diff --git a/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py b/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py index a93cb2bf7a3..f195703133f 100644 --- a/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py +++ b/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py @@ -5,6 +5,7 @@ COLUMN, ALL, OFF_DECK, + SINGLE, ) from typing import Dict, List @@ -22,8 +23,7 @@ SLOTS: Dict[str, str | List[str]] = { "FULL_TIP_RACK": "A1", - "PARTIAL_TIP_RACK_1000": "C2", - "PARTIAL_TIP_RACK_200": "B3", + "PARTIAL_TIP_RACK_1000": ["C2", "B3"], "SRC_RESERVOIR": "B1", "LABWARE": ["D1", "D2", "D3", "C1", "C3"], "TRASH_BIN": "A3", @@ -58,12 +58,13 @@ def run(protocol: ProtocolContext) -> None: str(SLOTS["FULL_TIP_RACK"]), adapter="opentrons_flex_96_tiprack_adapter", ) - tip_rack_partial = protocol.load_labware( - "opentrons_flex_96_tiprack_1000ul", str(SLOTS["PARTIAL_TIP_RACK_1000"]) + tip_rack_partial_1 = protocol.load_labware( + "opentrons_flex_96_tiprack_1000ul", str(SLOTS["PARTIAL_TIP_RACK_1000"][0]) ) - tip_rack_partial_200 = protocol.load_labware( - "opentrons_flex_96_tiprack_200ul", str(SLOTS["PARTIAL_TIP_RACK_200"]) + tip_rack_partial_2 = protocol.load_labware( + "opentrons_flex_96_tiprack_1000ul", str(SLOTS["PARTIAL_TIP_RACK_1000"][1]) ) + src_reservoir = protocol.load_labware( "nest_1_reservoir_290ml", str(SLOTS["SRC_RESERVOIR"]) ) @@ -96,20 +97,31 @@ def run(protocol: ProtocolContext) -> None: ) pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) pipette.transfer( - 200, src_reservoir["A1"], sample_plate["A1"].top(), trash=False, - blow_out = True, - blowout_location = "destination well" + 200, + src_reservoir["A1"], + sample_plate["A1"].top(), + trash=False, + blow_out=True, + blowout_location="destination well", ) pipette.reset_tipracks() pipette.transfer( - 100, src_reservoir["A1"], elution_plate["A1"].top(), trash=False, - blow_out = True, - blowout_location = "destination well" + 100, + src_reservoir["A1"], + elution_plate["A1"].top(), + trash=False, + blow_out=True, + blowout_location="destination well", ) pipette.reset_tipracks() - pipette.transfer(600, src_reservoir["A1"], res1["A1"].top(), trash=False, - blow_out = True, - blowout_location = "destination well") + pipette.transfer( + 600, + src_reservoir["A1"], + res1["A1"].top(), + trash=False, + blow_out=True, + blowout_location="destination well", + ) pipette.reset_tipracks() pvt1abr7_labware = [res1, elution_plate, sample_plate] for lw in pvt1abr7_labware: @@ -129,7 +141,12 @@ def run(protocol: ProtocolContext) -> None: ) pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) pipette.transfer( - 9500 / 8, src_reservoir["A1"], res1["A1"].top(), trash=False, blow_out = True, blowout_location = "destination well" + 9500 / 8, + src_reservoir["A1"], + res1["A1"].top(), + trash=False, + blow_out=True, + blowout_location="destination well", ) pipette.reset_tipracks() pipette.transfer( @@ -138,7 +155,7 @@ def run(protocol: ProtocolContext) -> None: elution_plate["A1"].bottom(z=1), trash=False, blow_out=True, - blowout_location = "destination well" + blowout_location="destination well", ) pipette.reset_tipracks() pipette.transfer( @@ -147,7 +164,7 @@ def run(protocol: ProtocolContext) -> None: sample_plate["A1"].top(), trash=False, blow_out=True, - blowout_location = "destination well" + blowout_location="destination well", ) pipette.reset_tipracks() pvt1abr9_labware = [res1, elution_plate, sample_plate] @@ -169,10 +186,17 @@ def run(protocol: ProtocolContext) -> None: binding2 = 13500 / 8 wash2 = 9800 / 8 pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) - pipette.transfer(1225, src_reservoir["A1"], res2["A1"].top(), trash=False, blow_out = True, blowout_location = "destination well") + pipette.transfer( + 1225, + src_reservoir["A1"], + res2["A1"].top(), + trash=False, + blow_out=True, + blowout_location="destination well", + ) pipette.reset_tipracks() pipette.configure_nozzle_layout( - style=COLUMN, start="A1", tip_racks=[tip_rack_partial] + style=COLUMN, start="A1", tip_racks=[tip_rack_partial_1, tip_rack_partial_2] ) pipette.transfer( volume=[ @@ -216,8 +240,6 @@ def run(protocol: ProtocolContext) -> None: pvt1abr10_labware = [res1, res2, res3] for lw in pvt1abr10_labware: protocol.move_labware(lw, OFF_DECK, use_gripper=False) - if dvt1abr2: - protocol.pause("SET UP DVT1ABR2") if dvt1abr3: protocol.pause("SET UP DVT1ABR3") if dvt1abr4: @@ -247,7 +269,9 @@ def run(protocol: ProtocolContext) -> None: pipette.return_tip() pipette.reset_tipracks() pipette.configure_nozzle_layout( - style=COLUMN, start="A12", tip_racks=[tip_rack_partial] + style=COLUMN, + start="A12", + tip_racks=[tip_rack_partial_1, tip_rack_partial_2], ) pipette.transfer( volume=[120, 750, 900, 96, 1000, 1000, 1000, 1000], @@ -267,9 +291,10 @@ def run(protocol: ProtocolContext) -> None: trash=True, ) pipette.configure_nozzle_layout( - style=COLUMN, start="A12", tip_racks=[tip_rack_partial_200] + style=COLUMN, + start="A12", + tip_racks=[tip_rack_partial_1, tip_rack_partial_2], ) - protocol.pause("about to use 200 ul tips, change reservoir") pipette.transfer( volume=[75, 15, 20, 65], source=src_reservoir["A1"], @@ -319,21 +344,23 @@ def run(protocol: ProtocolContext) -> None: source=3 * [src_reservoir["A1"]], dest=[reservoir["A1"], indices_plate["A1"], dna_plate["A1"]], trash=False, - blow_out = True, - blowout_destination = "destination well" + blow_out=True, + blowout_destination="destination well", ) pipette.reset_tipracks() # partial tip for pcr_reagents_plate pipette.configure_nozzle_layout( - style=COLUMN, start="A12", tip_racks=[tip_rack_partial_200] + style=COLUMN, + start="A12", + tip_racks=[tip_rack_partial_1, tip_rack_partial_2], ) pipette.transfer( [100, 100], source=2 * [src_reservoir["A1"]], dest=[pcr_reagents_plate["A1"], pcr_reagents_plate["A2"]], trash=True, - blow_out = True, - blowout_location = "destination well" + blow_out=True, + blowout_location="destination well", ) dvt2abr5_plates = [reservoir, pcr_reagents_plate, indices_plate, dna_plate] for plate in dvt2abr5_plates: @@ -344,21 +371,34 @@ def run(protocol: ProtocolContext) -> None: reservoir = protocol.load_labware( "nest_12_reservoir_15ml", str(SLOTS["LABWARE"][0]), "Assay Buffer" ) - sample_and_control_plate = protocol.load_labware( + sample_and_control_plate_1 = protocol.load_labware( "opentrons_96_wellplate_200ul_pcr_full_skirt", str(SLOTS["LABWARE"][1]), - "Sample and Control Plate", + "Sample and Control Plate 1", + ) + sample_and_control_plate_2 = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", + str(SLOTS["LABWARE"][2]), + "Sample and Control Plate 2", ) pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) pipette.transfer( - [1000, 60], - source=2 * [src_reservoir["A1"]], - dest=[reservoir["A1"], sample_and_control_plate["A1"]], + [1000, 60, 60], + source=3 * [src_reservoir["A1"]], + dest=[ + reservoir["A1"], + sample_and_control_plate_1["A1"].bottom(z=1), + sample_and_control_plate_2["A1"].bottom(z=1), + ], trash=False, - blow_out= True, - blowout_location = "destination well" + blow_out=True, + blowout_location="destination well", ) - dvt2abr6_plates = [reservoir, sample_and_control_plate] + dvt2abr6_plates = [ + reservoir, + sample_and_control_plate_1, + sample_and_control_plate_2, + ] for plate in dvt2abr6_plates: protocol.move_labware(plate, OFF_DECK, use_gripper=False) pipette.reset_tipracks() @@ -388,10 +428,12 @@ def run(protocol: ProtocolContext) -> None: pipette.dispense(150, sample_plate_1["A1"].top()) pipette.return_tip() pipette.configure_nozzle_layout( - style=COLUMN, start="A12", tip_racks=[tip_rack_partial] + style=COLUMN, + start="A12", + tip_racks=[tip_rack_partial_1, tip_rack_partial_2], ) pipette.transfer( - volume=[120, 750, 900, 96, 1000, 1000, 1000, 1000], + volume=[120, 750, 900, 96, 1000, 1000, 1000, 1000, 75, 15, 20, 65], source=src_reservoir["A1"], dest=[ reservoir_1["A1"].top(), # AMPure @@ -402,27 +444,14 @@ def run(protocol: ProtocolContext) -> None: sample_plate_2["A10"].top(), sample_plate_2["A11"].top(), sample_plate_2["A12"].top(), - ], - trash=True, - blow_out = True, - blowout_location = "destination well" - ) - pipette.configure_nozzle_layout( - style=COLUMN, start="A12", tip_racks=[tip_rack_partial_200] - ) - protocol.pause("about to use 200 ul tips, change reservoir") - pipette.transfer( - volume=[75, 15, 20, 65], - source=src_reservoir["A1"], - dest=[ reagent_plate_1["A4"].bottom(z=1), reagent_plate_1["A5"].bottom(z=1), reagent_plate_1["A6"].bottom(z=1), reagent_plate_1["A7"].bottom(z=1), ], trash=True, - blow_out = True, - blowout_location = "destination well" + blow_out=True, + blowout_location="destination well", ) pvt1abr8_labware = [ reservoir_1, @@ -437,20 +466,51 @@ def run(protocol: ProtocolContext) -> None: reservoir = protocol.load_labware( "nest_12_reservoir_15ml", str(SLOTS["LABWARE"][0]) ) - pipette.configure_nozzle_layout(style=COLUMN, start="A1") + pipette.configure_nozzle_layout( + style=COLUMN, start="A1", tip_racks=[tip_rack_partial_1, tip_rack_partial_2] + ) # fill last column - pipette.pick_up_tip(tip_rack_partial["A12"]) - pipette.aspirate(1000, src_reservoir["A1"]) - pipette.dispense(1000, reservoir["A6"].top()) - pipette.aspirate(65, src_reservoir["A1"]) - pipette.dispense(65, reservoir["A6"].top()) - pipette.drop_tip() + print(len(reservoir.wells()[:7])) + pipette.transfer( + volume=7 * [1350], + source=7 * [src_reservoir["A1"]], + dest=reservoir.wells()[:7], + blow_out=True, + Trash=True, + blowout_location="destination well", + ) # FILL FIRST 5 COLUMNS - pipette.pick_up_tip(tip_rack_partial["A7"]) - pipette.aspirate(6175 / 8, src_reservoir["A1"]) - pipette.dispense(6175 / 8, reservoir["A1"].top()) - pipette.drop_tip() protocol.move_labware(reservoir, OFF_DECK, use_gripper=False) + + if dvt1abr2: + protocol.pause("SET UP DVT1ABR2") + pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) + pipette.reset_tipracks() + sample_plate = protocol.load_labware( + "opentrons_96_wellplate_200ul_pcr_full_skirt", + SLOTS["LABWARE"][0], + "Sample Plate", + ) + snap_caps = protocol.load_labware( + "opentrons_24_aluminumblock_nest_1.5ml_snapcap", + SLOTS["LABWARE"][1], + "Snap Caps", + ) + pipette.transfer( + volume=100, + source=src_reservoir["A1"], + dest=sample_plate["A1"].bottom(z=1), + blow_out=True, + trash=False, + blowout_location="destination well", + ) + pipette.configure_nozzle_layout( + style=SINGLE, + start="A12", + tip_racks=[tip_rack_partial_1, tip_rack_partial_2], + ) + pipette.transfer(1000, src_reservoir["A1"], snap_caps["B1"]) + pipette.transfer(1000, src_reservoir["A1"], snap_caps.rows()[0]) if pvt1abr11: protocol.pause("SET UP PVT1ABR11") if pvt1abr12: From 1a5c7aa06af4e18511b61de5c3b68aa204b133ee Mon Sep 17 00:00:00 2001 From: rclarke0 Date: Tue, 11 Feb 2025 14:30:28 -0500 Subject: [PATCH 07/10] reducing nubmer of transfers --- .../4_Illumina DNA Enrichment.py | 2 +- .../5_MiSeq Library Preparation.py | 17 +------ .../6_QUiCKR_Kit_Part1and2.py | 2 +- abr-testing/abr_testing/protocols/helpers.py | 2 +- .../liquid_setups/All_Liquid_Set_ups.py | 45 +++---------------- 5 files changed, 10 insertions(+), 58 deletions(-) diff --git a/abr-testing/abr_testing/protocols/active_protocols/4_Illumina DNA Enrichment.py b/abr-testing/abr_testing/protocols/active_protocols/4_Illumina DNA Enrichment.py index ff9a9807c92..056a8db1750 100644 --- a/abr-testing/abr_testing/protocols/active_protocols/4_Illumina DNA Enrichment.py +++ b/abr-testing/abr_testing/protocols/active_protocols/4_Illumina DNA Enrichment.py @@ -372,7 +372,7 @@ def tipcheck() -> None: if trash_lid: protocol.move_labware(lid_on_plate, trash_bin, use_gripper=True) elif len(used_lids) <= 1: - protocol.move_labware(lid_on_plate, "B4", use_gripper=True) + protocol.move_labware(lid_on_plate, deck_riser, use_gripper=True) else: protocol.move_labware( lid_on_plate, used_lids[-2], use_gripper=True diff --git a/abr-testing/abr_testing/protocols/active_protocols/5_MiSeq Library Preparation.py b/abr-testing/abr_testing/protocols/active_protocols/5_MiSeq Library Preparation.py index eaa2627f13c..e47b314ad35 100644 --- a/abr-testing/abr_testing/protocols/active_protocols/5_MiSeq Library Preparation.py +++ b/abr-testing/abr_testing/protocols/active_protocols/5_MiSeq Library Preparation.py @@ -29,7 +29,6 @@ def add_parameters(parameters: ParameterContext) -> None: """Parameters.""" helpers.create_dot_bottom_parameter(parameters) helpers.create_deactivate_modules_parameter(parameters) - helpers.create_disposable_lid_parameter(parameters) parameters.add_bool( variable_name="column_tip_pickup", display_name="Perform Column Tip Pickup", @@ -42,11 +41,8 @@ def run(protocol: ProtocolContext) -> None: # Load Parameters dot_bottom = protocol.params.dot_bottom # type: ignore[attr-defined] deactivate_modules_bool = protocol.params.deactivate_modules # type: ignore[attr-defined] - disposable_lid = protocol.params.disposable_lid # type: ignore[attr-defined] column_tip_pick_up = protocol.params.column_tip_pickup # type: ignore[attr-defined] - if disposable_lid: - lids = protocol.load_lid_stack("opentrons_tough_pcr_auto_sealing_lid", "A2", 3) - + def transfer( pipette: InstrumentContext, volume: float, @@ -122,7 +118,7 @@ def transfer( ) eppendorf_384 = protocol.load_labware( "appliedbiosystemsmicroamp_384_wellplate_40ul", - "B4", + "A2", label="Applied Biosystems 384", ) pcr2_plate = protocol.load_labware( @@ -198,9 +194,6 @@ def all(pipette: InstrumentContext = p96) -> None: protocol.comment("Starting PCR1 thermal cycling") protocol.move_labware(pcr1_plate, thermocycler, use_gripper=True) heater_shaker.close_labware_latch() - if disposable_lid: - print(lids) - protocol.move_lid(lids, pcr1_plate, use_gripper=True) thermocycler.close_lid() thermocycler.set_lid_temperature(105) @@ -230,8 +223,6 @@ def all(pipette: InstrumentContext = p96) -> None: thermocycler.set_block_temperature(8) thermocycler.open_lid() - if disposable_lid: - protocol.move_lid(pcr1_plate, waste_chute, use_gripper=True) # Steps 7-8: Move plates protocol.comment("Setting up PCR2") protocol.move_labware(pcr1_plate, "B2", use_gripper=True) @@ -273,8 +264,6 @@ def all(pipette: InstrumentContext = p96) -> None: # Step 14: PCR2 thermal cycling protocol.comment("Starting PCR2 thermal cycling") - if disposable_lid: - protocol.move_lid(lids, pcr2_plate, use_gripper=True) thermocycler.close_lid() thermocycler.set_lid_temperature(105) # Initial denaturation @@ -301,8 +290,6 @@ def all(pipette: InstrumentContext = p96) -> None: ) thermocycler.open_lid() - if disposable_lid: - protocol.move_lid(pcr2_plate, waste_chute, use_gripper=True) # Step 15: Move PCR2 plate protocol.comment("Moving PCR2 plate") diff --git a/abr-testing/abr_testing/protocols/active_protocols/6_QUiCKR_Kit_Part1and2.py b/abr-testing/abr_testing/protocols/active_protocols/6_QUiCKR_Kit_Part1and2.py index 72a1f423f51..17566dda225 100644 --- a/abr-testing/abr_testing/protocols/active_protocols/6_QUiCKR_Kit_Part1and2.py +++ b/abr-testing/abr_testing/protocols/active_protocols/6_QUiCKR_Kit_Part1and2.py @@ -186,7 +186,7 @@ def run(protocol: ProtocolContext) -> None: if i == 1: protocol.move_labware( labware=tiprack_50[0], - new_location="D4", + new_location="D3", use_gripper=True, ) protocol.move_labware( diff --git a/abr-testing/abr_testing/protocols/helpers.py b/abr-testing/abr_testing/protocols/helpers.py index 31a1d1a9244..07670022403 100644 --- a/abr-testing/abr_testing/protocols/helpers.py +++ b/abr-testing/abr_testing/protocols/helpers.py @@ -215,7 +215,7 @@ def create_disposable_lid_parameter(parameters: ParameterContext) -> None: variable_name="disposable_lid", display_name="Disposable Lid", description="True means use lid.", - default=True, + default=False, ) diff --git a/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py b/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py index f195703133f..144ea051617 100644 --- a/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py +++ b/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py @@ -97,32 +97,14 @@ def run(protocol: ProtocolContext) -> None: ) pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) pipette.transfer( - 200, + [200, 100, 600], src_reservoir["A1"], - sample_plate["A1"].top(), + [sample_plate["A1"].bottom(z=1), elution_plate["A1"].bottom(z=1), res1["A1"].top()], trash=False, blow_out=True, blowout_location="destination well", ) - pipette.reset_tipracks() - pipette.transfer( - 100, - src_reservoir["A1"], - elution_plate["A1"].top(), - trash=False, - blow_out=True, - blowout_location="destination well", - ) - pipette.reset_tipracks() - pipette.transfer( - 600, - src_reservoir["A1"], - res1["A1"].top(), - trash=False, - blow_out=True, - blowout_location="destination well", - ) - pipette.reset_tipracks() + pvt1abr7_labware = [res1, elution_plate, sample_plate] for lw in pvt1abr7_labware: protocol.move_labware(lw, OFF_DECK, use_gripper=False) @@ -140,28 +122,11 @@ def run(protocol: ProtocolContext) -> None: "nest_96_wellplate_2ml_deep", str(SLOTS["LABWARE"][2]), "Sample Plate" ) pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) - pipette.transfer( - 9500 / 8, - src_reservoir["A1"], - res1["A1"].top(), - trash=False, - blow_out=True, - blowout_location="destination well", - ) - pipette.reset_tipracks() - pipette.transfer( - 55, - src_reservoir["A1"], - elution_plate["A1"].bottom(z=1), - trash=False, - blow_out=True, - blowout_location="destination well", - ) pipette.reset_tipracks() pipette.transfer( - 100, + [9500 / 8, 55, 100], src_reservoir["A1"], - sample_plate["A1"].top(), + [res1["A1"].top(), elution_plate["A1"].bottom(z=1), sample_plate["A1"].bottom(z=1)], trash=False, blow_out=True, blowout_location="destination well", From 1e9f24d583150f0911bc689254b072ea5568f018 Mon Sep 17 00:00:00 2001 From: rclarke0 Date: Wed, 12 Feb 2025 10:21:25 -0500 Subject: [PATCH 08/10] abr1 protocol change --- .../protocols/liquid_setups/All_Liquid_Set_ups.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py b/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py index 144ea051617..da49e857796 100644 --- a/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py +++ b/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py @@ -304,6 +304,7 @@ def run(protocol: ProtocolContext) -> None: ) # RESERVOIR, INDICES PLATE, DNA PLATE pipette.configure_nozzle_layout(style=ALL, tip_racks=[tip_rack]) + pipette.reset_tipracks() pipette.transfer( volume=[150, 100, 100], source=3 * [src_reservoir["A1"]], @@ -432,14 +433,14 @@ def run(protocol: ProtocolContext) -> None: "nest_12_reservoir_15ml", str(SLOTS["LABWARE"][0]) ) pipette.configure_nozzle_layout( - style=COLUMN, start="A1", tip_racks=[tip_rack_partial_1, tip_rack_partial_2] + style=COLUMN, start="A12", tip_racks=[tip_rack_partial_1, tip_rack_partial_2] ) # fill last column print(len(reservoir.wells()[:7])) pipette.transfer( - volume=7 * [1350], - source=7 * [src_reservoir["A1"]], - dest=reservoir.wells()[:7], + volume=6 * [1350], + source=6 * [src_reservoir["A1"]], + dest=reservoir.wells()[:6], blow_out=True, Trash=True, blowout_location="destination well", From 87c4f483d4a1e18dca9a5576519f0acd0c6a84a0 Mon Sep 17 00:00:00 2001 From: rclarke0 Date: Thu, 13 Feb 2025 16:53:38 -0500 Subject: [PATCH 09/10] fixed error script and finalized low volume protocols --- .../data_collection/abr_robot_error.py | 48 ++++++++++++++++--- .../4_Illumina DNA Enrichment.py | 4 +- .../5_MiSeq Library Preparation.py | 4 +- .../liquid_setups/All_Liquid_Set_ups.py | 25 ++++++---- 4 files changed, 63 insertions(+), 18 deletions(-) diff --git a/abr-testing/abr_testing/data_collection/abr_robot_error.py b/abr-testing/abr_testing/data_collection/abr_robot_error.py index 0b581f046c1..6477e5ca997 100644 --- a/abr-testing/abr_testing/data_collection/abr_robot_error.py +++ b/abr-testing/abr_testing/data_collection/abr_robot_error.py @@ -34,13 +34,47 @@ def retrieve_version_file( return "" -def retrieve_protocol_file( - protocol_id: str, - robot_ip: str, - storage: str, -) -> Path | str: - """Find and copy protocol file on robot with error.""" - protocol_dir = f"/var/lib/opentrons-robot-server/8/protocols/{protocol_id}" +def retrieve_protocol_file(protocol_id: str, robot_ip: str, storage: str) -> Path | str: + """Find and copy protocol file on robot with error handling.""" + # List folders in the robot's directory + list_folder_command = [ + "ssh", + f"root@{robot_ip}", + "ls /var/lib/opentrons-robot-server", + ] + try: + result = subprocess.run( + list_folder_command, check=True, capture_output=True, text=True + ) + folders = result.stdout.splitlines() + + def convert_to_floats(data: List) -> List: + """Convert list to floats.""" + float_list = [] + for item in data: + try: + float_value = float(item) + float_list.append(float_value) + except ValueError: + pass # Ignore items that cannot be converted to float + return float_list + + folders_float = convert_to_floats(folders) + if not folders_float: + print("No folders found.") + return "" + folder_num = max( + folders_float + ) # Assuming the highest folder number is the latest + if folder_num.is_integer(): + folder_num = int(folder_num) + except subprocess.CalledProcessError: + print("Could not find folder.") + return "" + protocol_dir = ( + f"/var/lib/opentrons-robot-server/{folder_num}/protocols/{protocol_id}" + ) + # Copy protocol file found in robot onto host computer save_dir = Path(f"{storage}") command = ["scp", "-r", f"root@{robot_ip}:{protocol_dir}", save_dir] diff --git a/abr-testing/abr_testing/protocols/active_protocols/4_Illumina DNA Enrichment.py b/abr-testing/abr_testing/protocols/active_protocols/4_Illumina DNA Enrichment.py index 056a8db1750..92aa7e90969 100644 --- a/abr-testing/abr_testing/protocols/active_protocols/4_Illumina DNA Enrichment.py +++ b/abr-testing/abr_testing/protocols/active_protocols/4_Illumina DNA Enrichment.py @@ -372,7 +372,9 @@ def tipcheck() -> None: if trash_lid: protocol.move_labware(lid_on_plate, trash_bin, use_gripper=True) elif len(used_lids) <= 1: - protocol.move_labware(lid_on_plate, deck_riser, use_gripper=True) + protocol.move_labware( + lid_on_plate, deck_riser, use_gripper=True + ) else: protocol.move_labware( lid_on_plate, used_lids[-2], use_gripper=True diff --git a/abr-testing/abr_testing/protocols/active_protocols/5_MiSeq Library Preparation.py b/abr-testing/abr_testing/protocols/active_protocols/5_MiSeq Library Preparation.py index e47b314ad35..ccfd1962b3f 100644 --- a/abr-testing/abr_testing/protocols/active_protocols/5_MiSeq Library Preparation.py +++ b/abr-testing/abr_testing/protocols/active_protocols/5_MiSeq Library Preparation.py @@ -42,7 +42,7 @@ def run(protocol: ProtocolContext) -> None: dot_bottom = protocol.params.dot_bottom # type: ignore[attr-defined] deactivate_modules_bool = protocol.params.deactivate_modules # type: ignore[attr-defined] column_tip_pick_up = protocol.params.column_tip_pickup # type: ignore[attr-defined] - + def transfer( pipette: InstrumentContext, volume: float, @@ -81,7 +81,7 @@ def transfer( pipette.flow_rate.dispense = original_disp_rate # Load modules - waste_chute = protocol.load_waste_chute() + protocol.load_waste_chute() thermocycler: ThermocyclerContext = protocol.load_module( "thermocyclerModuleV2" ) # type: ignore[assignment] diff --git a/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py b/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py index da49e857796..efc7beb29ca 100644 --- a/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py +++ b/abr-testing/abr_testing/protocols/liquid_setups/All_Liquid_Set_ups.py @@ -7,7 +7,6 @@ OFF_DECK, SINGLE, ) -from typing import Dict, List metadata = { "protocolName": "Liquid Set up for all robots", @@ -21,7 +20,7 @@ } -SLOTS: Dict[str, str | List[str]] = { +SLOTS = { "FULL_TIP_RACK": "A1", "PARTIAL_TIP_RACK_1000": ["C2", "B3"], "SRC_RESERVOIR": "B1", @@ -99,12 +98,16 @@ def run(protocol: ProtocolContext) -> None: pipette.transfer( [200, 100, 600], src_reservoir["A1"], - [sample_plate["A1"].bottom(z=1), elution_plate["A1"].bottom(z=1), res1["A1"].top()], + [ + sample_plate["A1"].bottom(z=1), + elution_plate["A1"].bottom(z=1), + res1["A1"].top(), + ], trash=False, blow_out=True, blowout_location="destination well", ) - + pvt1abr7_labware = [res1, elution_plate, sample_plate] for lw in pvt1abr7_labware: protocol.move_labware(lw, OFF_DECK, use_gripper=False) @@ -126,7 +129,11 @@ def run(protocol: ProtocolContext) -> None: pipette.transfer( [9500 / 8, 55, 100], src_reservoir["A1"], - [res1["A1"].top(), elution_plate["A1"].bottom(z=1), sample_plate["A1"].bottom(z=1)], + [ + res1["A1"].top(), + elution_plate["A1"].bottom(z=1), + sample_plate["A1"].bottom(z=1), + ], trash=False, blow_out=True, blowout_location="destination well", @@ -353,8 +360,8 @@ def run(protocol: ProtocolContext) -> None: source=3 * [src_reservoir["A1"]], dest=[ reservoir["A1"], - sample_and_control_plate_1["A1"].bottom(z=1), - sample_and_control_plate_2["A1"].bottom(z=1), + sample_and_control_plate_1["A1"], + sample_and_control_plate_2["A1"], ], trash=False, blow_out=True, @@ -433,7 +440,9 @@ def run(protocol: ProtocolContext) -> None: "nest_12_reservoir_15ml", str(SLOTS["LABWARE"][0]) ) pipette.configure_nozzle_layout( - style=COLUMN, start="A12", tip_racks=[tip_rack_partial_1, tip_rack_partial_2] + style=COLUMN, + start="A12", + tip_racks=[tip_rack_partial_1, tip_rack_partial_2], ) # fill last column print(len(reservoir.wells()[:7])) From 7fa2bc47cc1f75fa921a0882f8e6f134035f75a3 Mon Sep 17 00:00:00 2001 From: rclarke0 Date: Thu, 13 Feb 2025 16:55:35 -0500 Subject: [PATCH 10/10] remove input --- abr-testing/abr_testing/data_collection/abr_robot_error.py | 1 - 1 file changed, 1 deletion(-) diff --git a/abr-testing/abr_testing/data_collection/abr_robot_error.py b/abr-testing/abr_testing/data_collection/abr_robot_error.py index 6477e5ca997..9ac20531f63 100644 --- a/abr-testing/abr_testing/data_collection/abr_robot_error.py +++ b/abr-testing/abr_testing/data_collection/abr_robot_error.py @@ -674,7 +674,6 @@ def get_run_error_info_from_robot( protocol_file_path, version_file_path, ] + file_paths - input("-------") error_folder_path = os.path.join(storage_directory, issue_key) os.makedirs(error_folder_path, exist_ok=True) for source_file in error_files: