def dilute_primer(source_well, destination_well, destination_volume_uL, ratio, diluent): """ Dilutes source_well into destination tube using diluent Args: source_well: the tube at a higher concentration destination_well: the tube that will have the dilution product destination_volume_uL: the volume of destination_well ratio: destination_well concentration / source_well concentration diluent_well: a tube with enough d to be used for the diluation Returns: None """ global inv #@TODO: figure out how to check if a diluent tube has enough volume in it to conduct the action # (needs to account for multiple calls to this function) mix_volume = destination_volume_uL / 2 source_volume_uL = ratio * destination_volume_uL diluent_volume_uL = destination_volume_uL - source_volume_uL p.provision(inv[diluent], destination_well, ul(diluent_volume_uL)) p.transfer(source_well, destination_well, ul(source_volume_uL), mix_before=True, mix_after=True, mix_vol=min(ul(source_volume_uL*5), #prevent drawing more from the source well than is retrievable source_well.volume-source_well.container.container_type.dead_volume_ul)) p.mix(destination_well, volume=ul(destination_volume_uL/2.0), repetitions=10)
def amplify_and_store_bacteria(source_bacteria_well): # Tubes and plates growth_plate = p.ref(expid("growth"), cont_type="96-deep", storage="cold_80", discard=False) growth_wells = growth_plate.wells(['A1', 'A2']) prepare_growth_wells(growth_wells) p.distribute(source_bacteria_well, growth_wells, ul(25), mix_before=True, mix_vol=ul(150), allow_carryover=True) for growth_well in growth_wells: p.mix(growth_well, volume=ul(450), repetitions=10) p.cover(growth_plate) #grow bacteria until they are in their log phase of growth #https://www.qiagen.com/us/resources/technologies/plasmid-resource-center/growth%20of%20bacterial%20cultures/ p.incubate(growth_plate, "warm_37", "{}:hour".format(15), shaking=True) p.uncover(growth_plate) #add glycerol p.provision(p.inv['glycerol'], growth_wells, ul(500)) for growth_well in growth_wells: p.mix(growth_well, volume=ul(900), repetitions=10)
def amplify_and_store_bacteria(source_bacteria_well): # Tubes and plates growth_plate = p.ref(expid("growth"), cont_type="96-deep", storage="cold_80", discard=False) growth_wells = growth_plate.wells(['A1','A2']) prepare_growth_wells(growth_wells) p.distribute(source_bacteria_well,growth_wells,ul(25),mix_before=True,mix_vol=ul(150), allow_carryover=True) for growth_well in growth_wells: p.mix(growth_well, volume=ul(450), repetitions=10) p.cover(growth_plate) #grow bacteria until they are in their log phase of growth #https://www.qiagen.com/us/resources/technologies/plasmid-resource-center/growth%20of%20bacterial%20cultures/ p.incubate(growth_plate, "warm_37", "{}:hour".format(15), shaking=True) p.uncover(growth_plate) #add glycerol p.provision(p.inv['glycerol'],growth_wells,ul(500)) for growth_well in growth_wells: p.mix(growth_well, volume=ul(900), repetitions=10)
def do_gibson_assembly(p, water_tube, clone_plate, puc19_cut_tube, sfgfp_pcroe_amp_tube): # # Combine all the Gibson reagents in one tube and thermocycle # p.provision(p.inv["NEBuilder_Master_Mix"], clone_plate.well(0), ul(10)) p.transfer(water_tube, clone_plate.well(0), ul(3.5), mix_after=True, mix_vol=ul(6)) p.transfer(puc19_cut_tube, clone_plate.well(0), ul(2.5), mix_after=True, mix_vol=ul(6)) p.transfer(sfgfp_pcroe_amp_tube, clone_plate.well(0), ul(4), mix_after=True, mix_vol=ul(10)) p.seal(clone_plate) p.thermocycle( clone_plate, [{ "cycles": 1, "steps": [{ "temperature": "50:celsius", "duration": "15:minute" }] }], volume=ul(20)) # # Dilute assembled plasmid 4X according to the NEB Gibson assembly protocol (20ul->80ul) # p.unseal(clone_plate) p.transfer(water_tube, clone_plate.well(0), ul(60), mix_after=True, mix_vol=ul(40), repetitions=5)
def dilute_primer(source_well, destination_well, destination_volume_uL, ratio, diluent): """ Dilutes source_well into destination tube using diluent Args: source_well: the tube at a higher concentration destination_well: the tube that will have the dilution product destination_volume_uL: the volume of destination_well ratio: destination_well concentration / source_well concentration diluent_well: a tube with enough d to be used for the diluation Returns: None """ global inv #@TODO: figure out how to check if a diluent tube has enough volume in it to conduct the action # (needs to account for multiple calls to this function) mix_volume = destination_volume_uL / 2 source_volume_uL = ratio * destination_volume_uL diluent_volume_uL = destination_volume_uL - source_volume_uL p.provision(inv[diluent], destination_well, ul(diluent_volume_uL)) p.transfer( source_well, destination_well, ul(source_volume_uL), mix_before=True, mix_after=True, mix_vol=min( ul(source_volume_uL * 5), #prevent drawing more from the source well than is retrievable source_well.volume - source_well.container.container_type.dead_volume_ul)) p.mix(destination_well, volume=ul(destination_volume_uL / 2.0), repetitions=10)
def do_gibson_assembly(p, water_tube, clone_plate, puc19_cut_tube, sfgfp_pcroe_amp_tube): # # Combine all the Gibson reagents in one tube and thermocycle # p.provision(p.inv["NEBuilder_Master_Mix"], clone_plate.well(0), ul(10)) p.transfer(water_tube, clone_plate.well(0), ul(3.5), mix_after=True, mix_vol=ul(6)) p.transfer(puc19_cut_tube, clone_plate.well(0), ul(2.5), mix_after=True, mix_vol=ul(6)) p.transfer(sfgfp_pcroe_amp_tube, clone_plate.well(0), ul(4), mix_after=True, mix_vol=ul(10)) p.seal(clone_plate) p.thermocycle(clone_plate, [{"cycles": 1, "steps": [{"temperature": "50:celsius", "duration": "15:minute"}]}], volume=ul(20)) # # Dilute assembled plasmid 4X according to the NEB Gibson assembly protocol (20ul->80ul) # p.unseal(clone_plate) p.transfer(water_tube, clone_plate.well(0), ul(60), mix_after=True, mix_vol=ul(40), repetitions=5)
def get_synthesized_oligo_tube_protocol(tube_name, sequence): """ Synthesize and prepare an oligo tube 25nm seems to be more than enough for most downstream work (25pmol seems to be all that is used for transcriptic's pcr) """ global inv scale = '25nm' p = Protocol() dna_tube = p.ref(tube_name, cont_type="micro-1.5", storage="cold_20", discard=False) dna_tube.well(0).properties = { 'Molar Concentration': '100uM', 'original moles': '25nm' } p.oligosynthesize([{ "sequence": sequence, "destination": dna_tube.well(0), "scale": scale, "purification": "standard" }]) #spin p.spin(dna_tube, '2000:g', '30:second') #dilute to 100uM #safe min volume of 1.5uL is 20uL so we want a lot more than this so we don't lose too much #how do you go from scale and desired concentration to volume --> n = CV --> V = n/C --> V = 25nmol / 100uM = 25nmol / (100E3 nmol / 1L) # = 2.5E-4 L = 250 uL #convert 100uM to nM #convert to uL te_volume = 25 / (100 * pow(10, 3)) * pow(10, 6) #add 250uL p.provision(inv["te"], dna_tube.well(0), ul(te_volume)) #spin p.spin(dna_tube, '2000:g', '30:second') return json.dumps(p.as_dict(), indent=2)
def get_synthesized_oligo_tube_protocol(tube_name, sequence): """ Synthesize and prepare an oligo tube 25nm seems to be more than enough for most downstream work (25pmol seems to be all that is used for transcriptic's pcr) """ global inv scale = '25nm' p = Protocol() dna_tube = p.ref(tube_name, cont_type="micro-1.5", storage="cold_20", discard=False) dna_tube.well(0).properties = {'Molar Concentration':'100uM', 'original moles':'25nm'} p.oligosynthesize([{"sequence": sequence, "destination": dna_tube.well(0), "scale": scale, "purification": "standard"}] ) #spin p.spin(dna_tube, '2000:g', '30:second') #dilute to 100uM #safe min volume of 1.5uL is 20uL so we want a lot more than this so we don't lose too much #how do you go from scale and desired concentration to volume --> n = CV --> V = n/C --> V = 25nmol / 100uM = 25nmol / (100E3 nmol / 1L) # = 2.5E-4 L = 250 uL #convert 100uM to nM #convert to uL te_volume = 25 / (100 * pow(10, 3)) * pow(10, 6) #add 250uL p.provision(inv["te"], dna_tube.well(0), ul(te_volume)) #spin p.spin(dna_tube, '2000:g', '30:second') return json.dumps(p.as_dict(), indent=2)
def prepare_growth_wells(): # # To LB, add ampicillin at ~1/1000 concentration # Mix slowly in case of overflow # p.provision(p.inv["LB Miller"], lb_xab_tube, ul(1913)) for lb_amp_tube in lb_amp_tubes: p.provision(p.inv["LB Miller"], lb_amp_tube, ul(1911)) p.provision(p.inv["Amp 100mgml"], lb_amp_tube, ul(2)) p.mix(lb_amp_tube, volume=ul(800), repetitions=10) # # Add IPTG but save on X-Gal # http://openwetware.org/images/f/f1/Dh5a_sub.pdf # "If you are concerned about obtaining maximal levels of expression, add IPTG to a final concentration of 1 mM." # 20ul of IPTG @ 100uM in ~2000ul equals 1mM # p.provision(p.inv['IPTG'], [lb_xab_tube] + lb_amp_tubes, ul(20)) # # Distribute LB among wells, row D is control (no ampicillin) # cols = range(1, 11) row = "D" # control, no AB cwells = ["{}{}".format(row, col) for col in cols] assert set(cwells).issubset(set(abs_wells)) p.distribute(lb_xab_tube, growth_plate.wells(cwells), ul(191.8), allow_carryover=True) rows = "BCEF" for row, lb_amp_tube in zip(rows, lb_amp_tubes): cwells = ["{}{}".format(row, col) for col in cols] assert set(cwells).issubset(set(abs_wells)) p.distribute(lb_amp_tube, growth_plate.wells(cwells), ul(191.8), allow_carryover=True) assert all( round(lb_amp_tube.volume, 0) == round(lb_xab_tube.volume, 0) == dead_volume['micro-2.0'] for lb_amp_tube in lb_amp_tubes), [ lb_amp_tube.volume for lb_amp_tube in lb_amp_tubes ] return
def _do_transformation(p, clone_plate, transform_plate, transform_tube, transctrl_tube, control_pUC19): # # Combine plasmid and competent bacteria in a pcr_plate and shock # p.provision(p.inv["DH5a"], transform_tube, ul(50)) assert clone_plate.well(0).volume >= ul(6), clone_plate.well(0).volume #This was changed from the original publication of 3uL due to low colony turnout p.transfer(clone_plate.well(0), transform_tube, ul(5), dispense_speed="10:microliter/second", mix_after=True, mix_vol=ul(10)) if control_pUC19: p.provision(p.inv["DH5a"], transctrl_tube, ul(50)) p.provision(p.inv["pUC19"], transctrl_tube, ul(1)) # # Heatshock the bacteria to transform using a PCR machine # p.seal(transform_plate) p.thermocycle( transform_plate, [{ "cycles": 1, "steps": [{ "temperature": "4:celsius", "duration": "5:minute" }] }, { "cycles": 1, "steps": [{ "temperature": "37:celsius", "duration": "30:minute" }] }], volume=ul(50))
def prepare_growth_wells(): # # To LB, add ampicillin at ~1/1000 concentration # Mix slowly in case of overflow # p.provision(p.inv["LB Miller"], lb_xab_tube, ul(1913)) for lb_amp_tube in lb_amp_tubes: p.provision(p.inv["LB Miller"], lb_amp_tube, ul(1911)) p.provision(p.inv["Amp 100mgml"], lb_amp_tube, ul(2)) p.mix(lb_amp_tube, volume=ul(800), repetitions=10) # # Add IPTG but save on X-Gal # http://openwetware.org/images/f/f1/Dh5a_sub.pdf # "If you are concerned about obtaining maximal levels of expression, add IPTG to a final concentration of 1 mM." # 20ul of IPTG @ 100uM in ~2000ul equals 1mM # p.provision(p.inv['IPTG'], [lb_xab_tube] + lb_amp_tubes, ul(20)) # # Distribute LB among wells, row D is control (no ampicillin) # cols = range(1,11) row = "D" # control, no AB cwells = ["{}{}".format(row,col) for col in cols] assert set(cwells).issubset(set(abs_wells)) p.distribute(lb_xab_tube, growth_plate.wells(cwells), ul(191.8), allow_carryover=True) rows = "BCEF" for row, lb_amp_tube in zip(rows, lb_amp_tubes): cwells = ["{}{}".format(row,col) for col in cols] assert set(cwells).issubset(set(abs_wells)) p.distribute(lb_amp_tube, growth_plate.wells(cwells), ul(191.8), allow_carryover=True) assert all(round(lb_amp_tube.volume,0) == round(lb_xab_tube.volume,0) == dead_volume['micro-2.0'] for lb_amp_tube in lb_amp_tubes), [lb_amp_tube.volume for lb_amp_tube in lb_amp_tubes] return
def _do_transformation(p, clone_plate,transform_plate, transform_tube, transctrl_tube, control_pUC19): # # Combine plasmid and competent bacteria in a pcr_plate and shock # p.provision(p.inv["DH5a"], transform_tube, ul(50)) assert clone_plate.well(0).volume >= ul(6), clone_plate.well(0).volume #This was changed from the original publication of 3uL due to low colony turnout p.transfer(clone_plate.well(0), transform_tube, ul(5), dispense_speed="10:microliter/second", mix_after=True,mix_vol=ul(10)) if control_pUC19: p.provision(p.inv["DH5a"], transctrl_tube, ul(50)) p.provision(p.inv["pUC19"], transctrl_tube, ul(1)) # # Heatshock the bacteria to transform using a PCR machine # p.seal(transform_plate) p.thermocycle(transform_plate, [{"cycles": 1, "steps": [{"temperature": "4:celsius", "duration": "5:minute"}]}, {"cycles": 1, "steps": [{"temperature": "37:celsius", "duration": "30:minute"}]}], volume=ul(50))
def transfer(self, source, dest, volume, one_source=False, one_tip=False, aspirate_speed=None, dispense_speed=None, aspirate_source=None, dispense_target=None, pre_buffer=None, disposal_vol=None, transit_vol=None, blowout_buffer=None, tip_type=None, new_group=False, **mix_kwargs): """ Transfer liquid from one specific well to another. A new pipette tip is used between each transfer step unless the "one_tip" parameter is set to True. Example Usage: .. code-block:: python p = Protocol() sample_plate = p.ref("sample_plate", ct32kj234l21g, "96-flat", storage="warm_37") # a basic one-to-one transfer: p.transfer(sample_plate.well("B3"), sample_plate.well("C3"), "20:microliter") # using a basic transfer in a loop: for i in xrange(1, 12): p.transfer(sample_plate.well(i-1), sample_plate.well(i), "10:microliter") # transfer liquid from each well in the first column of a 96-well # plate to each well of the second column using a new tip and # a different volume each time: volumes = ["5:microliter", "10:microliter", "15:microliter", "20:microliter", "25:microliter", "30:microliter", "35:microliter", "40:microliter"] p.transfer(sample_plate.wells_from(0,8,columnwise=True), sample_plate.wells_from(1,8,columnwise=True), volumes) # transfer liquid from wells A1 and A2 (which both contain the same # source) into each of the following 10 wells: p.transfer(sample_plate.wells_from("A1", 2), sample_plate.wells_from("A3", 10), "10:microliter", one_source=True) # transfer liquid from wells containing the same source to multiple # other wells without discarding the tip in between: p.transfer(sample_plate.wells_from("A1", 2), sample_plate.wells_from("A3", 10), "10:microliter", one_source=True, one_tip=True) Parameters ---------- source : Well, WellGroup Well or wells to transfer liquid from. If multiple source wells are supplied and one_source is set to True, liquid will be transfered from each source well specified as long as it contains sufficient volume. Otherwise, the number of source wells specified must match the number of destination wells specified and liquid will be transfered from each source well to its corresponding destination well. dest : Well, WellGroup Well or WellGroup to which to transfer liquid. The number of destination wells must match the number of source wells specified unless one_source is set to True. volume : str, Unit, list The volume(s) of liquid to be transferred from source wells to destination wells. Volume can be specified as a single string or Unit, or can be given as a list of volumes. The length of a list of volumes must match the number of destination wells given unless the same volume is to be transferred to each destination well. one_source : bool, optional Specify whether liquid is to be transferred to destination wells from a group of wells all containing the same substance. one_tip : bool, optional Specify whether all transfer steps will use the same tip or not. mix_after : bool, optional Specify whether to mix the liquid in the destination well after liquid is transferred. mix_before : bool, optional Specify whether to mix the liquid in the source well before liquid is transferred. mix_vol : str, Unit, optional Volume to aspirate and dispense in order to mix liquid in a wells before and/or after each transfer step. repetitions : int, optional Number of times to aspirate and dispense in order to mix liquid in well before and/or after each transfer step. flowrate : str, Unit, optional Speed at which to mix liquid in well before and/or after each transfer step. aspirate speed : str, Unit, optional Speed at which to aspirate liquid from source well. May not be specified if aspirate_source is also specified. By default this is the maximum aspiration speed, with the start speed being half of the speed specified. dispense_speed : str, Unit, optional Speed at which to dispense liquid into the destination well. May not be specified if dispense_target is also specified. aspirate_source : fn, optional Can't be specified if aspirate_speed is also specified. dispense_target : fn, optional Same but opposite of aspirate_source. pre_buffer : str, Unit, optional Volume of air aspirated before aspirating liquid. disposal_vol : str, Unit, optional Volume of extra liquid to aspirate that will be dispensed into trash afterwards. transit_vol : str, Unit, optional Volume of air aspirated after aspirating liquid to reduce presence of bubbles at pipette tip. blowout_buffer : bool, optional If true the operation will dispense the pre_buffer along with the dispense volume. Cannot be true if disposal_vol is specified. tip_type : str, optional Type of tip to be used for the transfer operation. new_group : bool, optional Raises ------ RuntimeError If more than one volume is specified as a list but the list length does not match the number of destination wells given. RuntimeError If transferring from WellGroup to WellGroup that have different number of wells and one_source is not True. """ if type(volume) == list: min_volume = min(volume) else: min_volume = volume if min_volume < ul(10) and not mix_kwargs.get('mix_after') \ and not mix_kwargs.get('ignore_mix_after_warning'): raise Exception( 'mix_after required for <10uL of solution to ensure complete transfer. \n' 'Ensure you have are pipetting into something big enough and set this' ) if 'ignore_mix_after_warning' in mix_kwargs: del mix_kwargs['ignore_mix_after_warning'] super().transfer(source, dest, volume, one_source=one_source, one_tip=one_tip, aspirate_speed=aspirate_speed, dispense_speed=dispense_speed, aspirate_source=aspirate_source, dispense_target=dispense_target, pre_buffer=pre_buffer, disposal_vol=disposal_vol, transit_vol=transit_vol, blowout_buffer=blowout_buffer, tip_type=tip_type, new_group=new_group, **mix_kwargs)
import json from autoprotocol.protocol import Protocol from utils import ul """ This protoocol will take a tube and fill it with water """ inv = { 'te':'rs17pwyc754v9t' #catalog: te } p = Protocol() #create a container te_well = p.ref("te_tube", cont_type="micro-1.5", storage="cold_4", discard=False).well(0) p.provision(inv["te"], te_well, ul(1500)) print(json.dumps(p.as_dict(), indent=2))
def distribute(self, source, dest, volume, allow_carryover=False, mix_before=False, mix_after=False, mix_vol=None, repetitions=10, flowrate="100:microliter/second", aspirate_speed=None, aspirate_source=None, distribute_target=None, pre_buffer=None, disposal_vol=None, transit_vol=None, blowout_buffer=None, tip_type=None, new_group=False, ignore_mix_after_warning=False): """ Distribute liquid from source well(s) to destination wells(s). For volumes under 10uL, multiple transfer operations will be used instead Example Usage: .. code-block:: python p = Protocol() sample_plate = p.ref("sample_plate", None, "96-flat", storage="warm_37") sample_source = p.ref("sample_source", "ct32kj234l21g", "micro-1.5", storage="cold_20") p.distribute(sample_source.well(0), sample_plate.wells_from(0,8,columnwise=True), "200:microliter", mix_before=True, mix_vol="500:microliter", repetitions=20) Autoprotocol Output: .. code-block:: json "instructions": [ { "groups": [ { "distribute": { "to": [ { "volume": "150.0:microliter", "well": "sample_plate/0" }, { "volume": "150.0:microliter", "well": "sample_plate/12" }, { "volume": "150.0:microliter", "well": "sample_plate/24" }, { "volume": "150.0:microliter", "well": "sample_plate/36" }, { "volume": "150.0:microliter", "well": "sample_plate/48" }, { "volume": "150.0:microliter", "well": "sample_plate/60" }, { "volume": "150.0:microliter", "well": "sample_plate/72" }, { "volume": "150.0:microliter", "well": "sample_plate/84" } ], "from": "sample_source/0", "mix_before": { "volume": "500:microliter", "repetitions": 20, "speed": "100:microliter/second" } } } ], "op": "pipette" } ] Parameters ---------- source : Well, WellGroup Well or wells to distribute liquid from. If passed as a WellGroup with set_volume() called on it, liquid will be automatically be drawn from the wells specified using the fill_wells function. dest : Well, WellGroup Well or wells to distribute liquid to. volume : str, Unit, list Volume of liquid to be distributed to each destination well. If a single string or unit is passed to represent the volume, that volume will be distributed to each destination well. If a list of volumes is provided, that volume will be distributed to the corresponding well in the WellGroup provided. The length of the volumes list must therefore match the number of wells in the destination WellGroup if destination wells are recieving different volumes. allow_carryover : bool, optional specify whether the same pipette tip can be used to aspirate more liquid from source wells after the previous volume aspirated has been depleted. mix_before : bool, optional Specify whether to mix the liquid in the destination well before liquid is transferred. mix_after : bool, optional Specify whether to mix the liquid in the destination well after liquid is transferred. mix_vol : str, Unit, optional Volume to aspirate and dispense in order to mix liquid in a wells before liquid is distributed. repetitions : int, optional Number of times to aspirate and dispense in order to mix liquid in a well before liquid is distributed. flowrate : str, Unit, optional Speed at which to mix liquid in well before liquid is distributed. aspirate speed : str, Unit, optional Speed at which to aspirate liquid from source well. May not be specified if aspirate_source is also specified. By default this is the maximum aspiration speed, with the start speed being half of the speed specified. aspirate_source : fn, optional Can't be specified if aspirate_speed is also specified. distribute_target : fn, optional A function that contains additional parameters for distributing to target wells including depth, dispense_speed, and calibrated volume. If this parameter is specified, the same parameters will be applied to every destination well. Can't be specified if dispense_speed is also specified. pre_buffer : str, Unit, optional Volume of air aspirated before aspirating liquid. disposal_vol : str, Unit, optional Volume of extra liquid to aspirate that will be dispensed into trash afterwards. transit_vol : str, Unit, optional Volume of air aspirated after aspirating liquid to reduce presence of bubbles at pipette tip. blowout_buffer : bool, optional If true the operation will dispense the pre_buffer along with the dispense volume. Cannot be true if disposal_vol is specified. Raises ------ RuntimeError If no mix volume is specified for the mix_before instruction. ValueError If source and destination well(s) is/are not expressed as either Wells or WellGroups. """ if volume < ul(10): for dest_well in dest: self.transfer(source,dest_well,volume,mix_before=mix_before, mix_after=mix_after,mix_vol=mix_vol, aspirate_speed=aspirate_speed, aspirate_source=aspirate_source, pre_buffer=pre_buffer, disposal_vol=disposal_vol, transit_vol=transit_vol, blowout_buffer=blowout_buffer, tip_type=tip_type, new_group=new_group, ignore_mix_after_warning=ignore_mix_after_warning) else: super().distribute(source, dest, volume, allow_carryover=allow_carryover, mix_before=mix_before, mix_vol=mix_vol, repetitions=repetitions, flowrate=flowrate, aspirate_speed=aspirate_speed, aspirate_source=aspirate_source, distribute_target=distribute_target, pre_buffer=pre_buffer, disposal_vol=disposal_vol, transit_vol=transit_vol, blowout_buffer=blowout_buffer, tip_type=tip_type, new_group=new_group)
if 'run_absorbance' in options: abs_plate = p.ref("abs_plate_%s_clean"%experiment_name, cont_type="96-flat", storage="cold_20", discard=False) # Initialize all existing inventory all_inventory_wells = [dna_to_clean_well] for well in all_inventory_wells: init_inventory_well(well) # ----------------------------------------------------- # ExoSAP-IT PCR product cleanyup # http://media.affymetrix.com/support/technical/usb/brief_proto/78200B.pdf # requires 2uL of exosap for every 5 ul of dna product p.transfer(dna_to_clean_well, exosap_reaction_plate.wells(["A1"]), ul(15), mix_before=True, mix_vol=ul(20)) p.transfer(exosap_it_well, exosap_reaction_plate.wells(["A1"]), ul(6), mix_before=True, mix_after=True,mix_vol=ul(6)) # --------------------------------------------------------- # Thermocycle # cycles = [{"cycles": 1, "steps": [{"temperature": "37:celsius", "duration": "15:minute"}, {"temperature": "80:celsius", "duration": "15:minute"}]}] p.seal(exosap_reaction_plate) p.thermocycle(exosap_reaction_plate, cycles, volume=ul(21)) p.unseal(exosap_reaction_plate) #---------------------------------------------------------
import json from autoprotocol.protocol import Protocol from utils import ul """ This protoocol will take a tube and fill it with water """ inv = { 'water': 'rs17gmh5wafm5p' #autoclave milliq h2o } p = Protocol() #create a container water_tube = p.ref("water_tube", cont_type="micro-1.5", storage="cold_4", discard=False).well(0) p.provision(inv["water"], water_tube, ul(1500)) print(json.dumps(p.as_dict(), indent=2))
pcr_product_well = p.ref("sfgfp_pcr_v1_amplified", id=inv['sfgfp_pcr_v1_amplified'], cont_type="micro-1.5", storage="cold_20").well(0) # Temporary tubes for use, then discarded #diluted_product_well1 = p.ref("diluted_1_10th_pcr_product_well", cont_type="micro-1.5", storage="cold_20").well(0) diluted_product_well2 = p.ref("diluted_1_20th_pcr_product_well", cont_type="micro-1.5", storage="cold_20").well(0) #create a water tube with 36ul water and 4ul pcr product --> 40uL --> 1/10 dilution #p.provision(inv["water"], diluted_product_well1, ul(36)) #p.transfer(pcr_product_well, diluted_product_well1, ul(4),mix_before=True,mix_after=True,mix_vol=ul(20)) p.provision(inv["water"], diluted_product_well2, ul(38)) p.transfer(pcr_product_well, diluted_product_well2, ul(2), mix_before=True, mix_after=True, mix_vol=ul(20)) # Initialize all existing inventory all_inventory_wells = [pcr_product_well] for well in all_inventory_wells: init_inventory_well(well) # -------------------------------------------------------- # Run a gel #
cont_type="micro-1.5", storage="cold_4").well(0) clone_plate = p.ref(expid("clone"), cont_type="96-pcr", storage="cold_20") # # Catalog (all to be discarded afterward) # water_tube = p.ref("water", cont_type="micro-1.5", discard=True).well(0) # # Initialize inventory # all_inventory_wells = [puc19_cut_tube, sfgfp_pcroe_amp_tube, IPTG_tube] assert puc19_cut_tube.volume == ul(66), puc19_cut_tube.volume assert sfgfp_pcroe_amp_tube.volume == ul(36), sfgfp_pcroe_amp_tube.volume for well in all_inventory_wells: init_inventory_well(well) # # Provisioning. Water is used all over the protocol. Provision an excess since it's cheap # p.provision(inv["water"], water_tube, ul(500)) # --------------------------------------------------------------- # Generate protocol # do_gibson_assembly(p, water_tube, clone_plate, puc19_cut_tube,
def transfer(self, source, dest, volume, one_source=False, one_tip=False, aspirate_speed=None, dispense_speed=None, aspirate_source=None, dispense_target=None, pre_buffer=None, disposal_vol=None, transit_vol=None, blowout_buffer=None, tip_type=None, new_group=False, **mix_kwargs): """ Transfer liquid from one specific well to another. A new pipette tip is used between each transfer step unless the "one_tip" parameter is set to True. Example Usage: .. code-block:: python p = Protocol() sample_plate = p.ref("sample_plate", ct32kj234l21g, "96-flat", storage="warm_37") # a basic one-to-one transfer: p.transfer(sample_plate.well("B3"), sample_plate.well("C3"), "20:microliter") # using a basic transfer in a loop: for i in xrange(1, 12): p.transfer(sample_plate.well(i-1), sample_plate.well(i), "10:microliter") # transfer liquid from each well in the first column of a 96-well # plate to each well of the second column using a new tip and # a different volume each time: volumes = ["5:microliter", "10:microliter", "15:microliter", "20:microliter", "25:microliter", "30:microliter", "35:microliter", "40:microliter"] p.transfer(sample_plate.wells_from(0,8,columnwise=True), sample_plate.wells_from(1,8,columnwise=True), volumes) # transfer liquid from wells A1 and A2 (which both contain the same # source) into each of the following 10 wells: p.transfer(sample_plate.wells_from("A1", 2), sample_plate.wells_from("A3", 10), "10:microliter", one_source=True) # transfer liquid from wells containing the same source to multiple # other wells without discarding the tip in between: p.transfer(sample_plate.wells_from("A1", 2), sample_plate.wells_from("A3", 10), "10:microliter", one_source=True, one_tip=True) Parameters ---------- source : Well, WellGroup Well or wells to transfer liquid from. If multiple source wells are supplied and one_source is set to True, liquid will be transfered from each source well specified as long as it contains sufficient volume. Otherwise, the number of source wells specified must match the number of destination wells specified and liquid will be transfered from each source well to its corresponding destination well. dest : Well, WellGroup Well or WellGroup to which to transfer liquid. The number of destination wells must match the number of source wells specified unless one_source is set to True. volume : str, Unit, list The volume(s) of liquid to be transferred from source wells to destination wells. Volume can be specified as a single string or Unit, or can be given as a list of volumes. The length of a list of volumes must match the number of destination wells given unless the same volume is to be transferred to each destination well. one_source : bool, optional Specify whether liquid is to be transferred to destination wells from a group of wells all containing the same substance. one_tip : bool, optional Specify whether all transfer steps will use the same tip or not. mix_after : bool, optional Specify whether to mix the liquid in the destination well after liquid is transferred. mix_before : bool, optional Specify whether to mix the liquid in the source well before liquid is transferred. mix_vol : str, Unit, optional Volume to aspirate and dispense in order to mix liquid in a wells before and/or after each transfer step. repetitions : int, optional Number of times to aspirate and dispense in order to mix liquid in well before and/or after each transfer step. flowrate : str, Unit, optional Speed at which to mix liquid in well before and/or after each transfer step. aspirate speed : str, Unit, optional Speed at which to aspirate liquid from source well. May not be specified if aspirate_source is also specified. By default this is the maximum aspiration speed, with the start speed being half of the speed specified. dispense_speed : str, Unit, optional Speed at which to dispense liquid into the destination well. May not be specified if dispense_target is also specified. aspirate_source : fn, optional Can't be specified if aspirate_speed is also specified. dispense_target : fn, optional Same but opposite of aspirate_source. pre_buffer : str, Unit, optional Volume of air aspirated before aspirating liquid. disposal_vol : str, Unit, optional Volume of extra liquid to aspirate that will be dispensed into trash afterwards. transit_vol : str, Unit, optional Volume of air aspirated after aspirating liquid to reduce presence of bubbles at pipette tip. blowout_buffer : bool, optional If true the operation will dispense the pre_buffer along with the dispense volume. Cannot be true if disposal_vol is specified. tip_type : str, optional Type of tip to be used for the transfer operation. new_group : bool, optional Raises ------ RuntimeError If more than one volume is specified as a list but the list length does not match the number of destination wells given. RuntimeError If transferring from WellGroup to WellGroup that have different number of wells and one_source is not True. """ if type(volume) == list: min_volume = min(volume) else: min_volume = volume if min_volume < ul(10) and not mix_kwargs.get('mix_after') \ and not mix_kwargs.get('ignore_mix_after_warning'): raise Exception('mix_after required for <10uL of solution to ensure complete transfer. \n' 'Ensure you have are pipetting into something big enough and set this') if 'ignore_mix_after_warning' in mix_kwargs: del mix_kwargs['ignore_mix_after_warning'] super().transfer(source, dest, volume, one_source=one_source, one_tip=one_tip, aspirate_speed=aspirate_speed, dispense_speed=dispense_speed, aspirate_source=aspirate_source, dispense_target=dispense_target, pre_buffer=pre_buffer, disposal_vol=disposal_vol, transit_vol=transit_vol, blowout_buffer=blowout_buffer, tip_type=tip_type, new_group=new_group,**mix_kwargs)
import json from autoprotocol.protocol import Protocol from utils import ul """ This protoocol will take a tube and fill it with water """ inv = { 'water':'rs17gmh5wafm5p' #autoclave milliq h2o } p = Protocol() #create a container water_tube = p.ref("water_tube", cont_type="micro-1.5", storage="cold_4", discard=False).well(0) p.provision(inv["water"], water_tube, ul(1500)) print(json.dumps(p.as_dict(), indent=2))
def distribute(self, source, dest, volume, allow_carryover=False, mix_before=False, mix_after=False, mix_vol=None, repetitions=10, flowrate="100:microliter/second", aspirate_speed=None, aspirate_source=None, distribute_target=None, pre_buffer=None, disposal_vol=None, transit_vol=None, blowout_buffer=None, tip_type=None, new_group=False, ignore_mix_after_warning=False): """ Distribute liquid from source well(s) to destination wells(s). For volumes under 10uL, multiple transfer operations will be used instead Example Usage: .. code-block:: python p = Protocol() sample_plate = p.ref("sample_plate", None, "96-flat", storage="warm_37") sample_source = p.ref("sample_source", "ct32kj234l21g", "micro-1.5", storage="cold_20") p.distribute(sample_source.well(0), sample_plate.wells_from(0,8,columnwise=True), "200:microliter", mix_before=True, mix_vol="500:microliter", repetitions=20) Autoprotocol Output: .. code-block:: json "instructions": [ { "groups": [ { "distribute": { "to": [ { "volume": "150.0:microliter", "well": "sample_plate/0" }, { "volume": "150.0:microliter", "well": "sample_plate/12" }, { "volume": "150.0:microliter", "well": "sample_plate/24" }, { "volume": "150.0:microliter", "well": "sample_plate/36" }, { "volume": "150.0:microliter", "well": "sample_plate/48" }, { "volume": "150.0:microliter", "well": "sample_plate/60" }, { "volume": "150.0:microliter", "well": "sample_plate/72" }, { "volume": "150.0:microliter", "well": "sample_plate/84" } ], "from": "sample_source/0", "mix_before": { "volume": "500:microliter", "repetitions": 20, "speed": "100:microliter/second" } } } ], "op": "pipette" } ] Parameters ---------- source : Well, WellGroup Well or wells to distribute liquid from. If passed as a WellGroup with set_volume() called on it, liquid will be automatically be drawn from the wells specified using the fill_wells function. dest : Well, WellGroup Well or wells to distribute liquid to. volume : str, Unit, list Volume of liquid to be distributed to each destination well. If a single string or unit is passed to represent the volume, that volume will be distributed to each destination well. If a list of volumes is provided, that volume will be distributed to the corresponding well in the WellGroup provided. The length of the volumes list must therefore match the number of wells in the destination WellGroup if destination wells are recieving different volumes. allow_carryover : bool, optional specify whether the same pipette tip can be used to aspirate more liquid from source wells after the previous volume aspirated has been depleted. mix_before : bool, optional Specify whether to mix the liquid in the destination well before liquid is transferred. mix_after : bool, optional Specify whether to mix the liquid in the destination well after liquid is transferred. mix_vol : str, Unit, optional Volume to aspirate and dispense in order to mix liquid in a wells before liquid is distributed. repetitions : int, optional Number of times to aspirate and dispense in order to mix liquid in a well before liquid is distributed. flowrate : str, Unit, optional Speed at which to mix liquid in well before liquid is distributed. aspirate speed : str, Unit, optional Speed at which to aspirate liquid from source well. May not be specified if aspirate_source is also specified. By default this is the maximum aspiration speed, with the start speed being half of the speed specified. aspirate_source : fn, optional Can't be specified if aspirate_speed is also specified. distribute_target : fn, optional A function that contains additional parameters for distributing to target wells including depth, dispense_speed, and calibrated volume. If this parameter is specified, the same parameters will be applied to every destination well. Can't be specified if dispense_speed is also specified. pre_buffer : str, Unit, optional Volume of air aspirated before aspirating liquid. disposal_vol : str, Unit, optional Volume of extra liquid to aspirate that will be dispensed into trash afterwards. transit_vol : str, Unit, optional Volume of air aspirated after aspirating liquid to reduce presence of bubbles at pipette tip. blowout_buffer : bool, optional If true the operation will dispense the pre_buffer along with the dispense volume. Cannot be true if disposal_vol is specified. Raises ------ RuntimeError If no mix volume is specified for the mix_before instruction. ValueError If source and destination well(s) is/are not expressed as either Wells or WellGroups. """ if volume < ul(10): for dest_well in dest: self.transfer( source, dest_well, volume, mix_before=mix_before, mix_after=mix_after, mix_vol=mix_vol, aspirate_speed=aspirate_speed, aspirate_source=aspirate_source, pre_buffer=pre_buffer, disposal_vol=disposal_vol, transit_vol=transit_vol, blowout_buffer=blowout_buffer, tip_type=tip_type, new_group=new_group, ignore_mix_after_warning=ignore_mix_after_warning) else: super().distribute(source, dest, volume, allow_carryover=allow_carryover, mix_before=mix_before, mix_vol=mix_vol, repetitions=repetitions, flowrate=flowrate, aspirate_speed=aspirate_speed, aspirate_source=aspirate_source, distribute_target=distribute_target, pre_buffer=pre_buffer, disposal_vol=disposal_vol, transit_vol=transit_vol, blowout_buffer=blowout_buffer, tip_type=tip_type, new_group=new_group)
def _transfer_transformed_to_plates(p, transform_plate, transform_tube, transform_tube_L, transctrl_tube, transctrl_tube_L, amp_6_flat, noAB_6_flat, control_pUC19): assert transform_tube.volume == ul(53), transform_tube.volume p.unseal(transform_plate) num_ab_plates = 4 # antibiotic places # # Transfer bacteria to a bigger tube for diluting # Then spread onto 6-flat plates # Generally you would spread 50-100ul of diluted bacteria # Put more on ampicillin plates for more opportunities to get a colony # I use a dilution series since it's unclear how much to plate # p.provision(p.inv["LB Miller"], transform_tube_L, ul(445)) # # Add the transformed cells and mix (use new mix op in case of different pipette) # p.transfer(transform_tube, transform_tube_L, ul(50), mix_before=True) p.mix(transform_tube_L, volume=transform_tube_L.volume / 2, repetitions=10) assert transform_tube.volume == dead_volume['96-pcr'] == ul( 3), transform_tube.volume assert transform_tube_L.volume == ul(495), transform_tube_L.volume # # Spread an average of 60ul on each plate == 480ul total # for i in range(num_ab_plates): p.spread(transform_tube_L, amp_6_flat.well(i), ul(51 + i * 6)) p.spread(transform_tube_L, noAB_6_flat.well(i), ul(51 + i * 6)) assert transform_tube_L.volume == dead_volume[ "micro-1.5"], transform_tube_L.volume # # Controls: include 2 ordinary pUC19-transformed plates as a control # if control_pUC19: num_ctrl = 2 assert num_ab_plates + num_ctrl <= 6 p.provision(p.inv["LB Miller"], transctrl_tube_L, ul(192) + dead_volume["micro-1.5"]) p.transfer(transctrl_tube, transctrl_tube_L, ul(48)) p.mix(transctrl_tube_L, volume=transctrl_tube_L.volume / 2, repetitions=10) for i in range(num_ctrl): p.spread(transctrl_tube_L, amp_6_flat.well(num_ab_plates + i), ul(55 + i * 10)) p.spread(transctrl_tube_L, noAB_6_flat.well(num_ab_plates + i), ul(55 + i * 10)) assert transctrl_tube_L.volume >= dead_volume[ "micro-1.5"], transctrl_tube_L.volume
def _transfer_transformed_to_plates(p, transform_plate, transform_tube, transform_tube_L, transctrl_tube, transctrl_tube_L, amp_6_flat, noAB_6_flat,control_pUC19): assert transform_tube.volume == ul(53), transform_tube.volume p.unseal(transform_plate) num_ab_plates = 4 # antibiotic places # # Transfer bacteria to a bigger tube for diluting # Then spread onto 6-flat plates # Generally you would spread 50-100ul of diluted bacteria # Put more on ampicillin plates for more opportunities to get a colony # I use a dilution series since it's unclear how much to plate # p.provision(p.inv["LB Miller"], transform_tube_L, ul(445)) # # Add the transformed cells and mix (use new mix op in case of different pipette) # p.transfer(transform_tube, transform_tube_L, ul(50), mix_before=True) p.mix(transform_tube_L, volume=transform_tube_L.volume/2, repetitions=10) assert transform_tube.volume == dead_volume['96-pcr'] == ul(3), transform_tube.volume assert transform_tube_L.volume == ul(495), transform_tube_L.volume # # Spread an average of 60ul on each plate == 480ul total # for i in range(num_ab_plates): p.spread(transform_tube_L, amp_6_flat.well(i), ul(51+i*6)) p.spread(transform_tube_L, noAB_6_flat.well(i), ul(51+i*6)) assert transform_tube_L.volume == dead_volume["micro-1.5"], transform_tube_L.volume # # Controls: include 2 ordinary pUC19-transformed plates as a control # if control_pUC19: num_ctrl = 2 assert num_ab_plates + num_ctrl <= 6 p.provision(p.inv["LB Miller"], transctrl_tube_L, ul(192)+dead_volume["micro-1.5"]) p.transfer(transctrl_tube, transctrl_tube_L, ul(48)) p.mix(transctrl_tube_L, volume=transctrl_tube_L.volume/2, repetitions=10) for i in range(num_ctrl): p.spread(transctrl_tube_L, amp_6_flat.well(num_ab_plates+i), ul(55+i*10)) p.spread(transctrl_tube_L, noAB_6_flat.well(num_ab_plates+i), ul(55+i*10)) assert transctrl_tube_L.volume >= dead_volume["micro-1.5"], transctrl_tube_L.volume
# Temporary tubes for use, then discarded (you can't set storage if you are going to discard) mastermix_well = p.ref("mastermix", cont_type="micro-1.5", discard=True).well(0) water_well = p.ref("water", cont_type="micro-1.5", discard=True).well(0) pcr_plate = p.ref("pcr_plate", cont_type="96-pcr", discard=True) # Initialize all existing inventory all_inventory_wells = [template_tube] + primer_wells for well in all_inventory_wells: init_inventory_well(well) # ----------------------------------------------------- # Provision water once, for general use # p.provision(inv["water"], water_well, ul(500)) # ----------------------------------------------------- # Q5 PCR protocol # www.neb.com/protocols/2013/12/13/pcr-using-q5-high-fidelity-dna-polymerase-m0491 # # 25ul reaction (we will run it 4 times, totally 100uL of solution) # ------------- 4rxn total # Q5 reaction buffer 5 ul --> 20uL # Q5 polymerase 0.25 ul --> 1uL # 10mM dNTP 0.5 ul --> 2uL # 10uM forward primer 1.25 ul --> 5uL # 10uM reverse primer 1.25 ul --> 5uL # 1ng Template (1 ng/ul) 1 ul --> 4uL (1ng/ul concentration) # water # -------------------------------
inv.update(test_inv) p = Protocol() if 'use_existing_pcr_reagent_plate' not in options: #we use a PCR plate since it has less dead volume (we would be throwing out $30 if we use normal tubes) #pcr well has 3uL of dead volume and 5uL safe min (you can't pipette from less than this) pcr_reagent_plate = p.ref("pcr_reagent_plate", cont_type="96-pcr", storage="cold_20", discard=False) else: pcr_reagent_plate = p.ref("pcr_reagent_plate", id=inv['pcr_reagent_plate'], cont_type="96-pcr", storage="cold_20", discard=False) if 'include_Q5_set' in options: #We use 1uL per set of 4 experiments. To get 4 sets of experiments, we need 8uL q5_poly_well = pcr_reagent_plate.wells(["A1"])[0] p.provision(inv["Q5_Polymerase"], q5_poly_well, ul(14)) q5_poly_well.name = 'Q5_Polymerase' if 'include_Q5_set' in options: #We use 20uL per 4 experiments. 3 of dead volume + 20 uL * 4 sets of 4 experiments = q5_buffer_well = pcr_reagent_plate.wells(["A2"])[0] p.provision(inv["Q5_Buffer"], q5_buffer_well, ul(83)) q5_buffer_well.name = 'Q5_Buffer' if 'include_Q5_set' in options: #we aren't using this but you get it for 20 cents because it comes with the Q5 kit q5_enhancer_well = pcr_reagent_plate.wells(["A3"])[0] p.provision(inv["Q5_Enhancer"], q5_enhancer_well, ul(83)) q5_enhancer_well.name = 'Q5_Enhancer' if 'include_dNTP_Mixture_10mM' in options:
import json from autoprotocol.protocol import Protocol from utils import ul inv = { 'gblock_dna':'ct18vs7cmjat2c', # my inventory 'te': 'rs17pwyc754v9t', # catalog; TE } p = Protocol() #existing inventory dna_sample = p.ref("gblock_dna", id=inv['gblock_dna'], cont_type="micro-1.5", storage='cold_20') #tubes are thawed before being placed into workcell #Centrifuge the tube for 3-5 sec at a minimum of 3000 x g to pellet the material to the bottom of the tube. p.spin(dna_sample, '3000:g', '5:second') #Add 500uL TE (to reach 1 ng/uL) p.provision(inv["te"], dna_sample.well(0), ul(500)) #Briefly vortex (here we have to use mix) and centrifuge p.mix(dna_sample.well(0),'480:microliter',speed='480:microliter/second',repetitions=10) p.spin(dna_sample, '3000:g', '3:second') print(json.dumps(p.as_dict(), indent=2))
sfgfp_pcroe_out_tube = p.ref(expid("amplified",experiment_name), cont_type="micro-1.5", storage="cold_20").well(0) # Temporary tubes for use, then discarded (you can't set storage if you are going to discard) mastermix_well = p.ref("mastermix", cont_type="micro-1.5", discard=True).well(0) water_well = p.ref("water", cont_type="micro-1.5", discard=True).well(0) pcr_plate = p.ref("pcr_plate", cont_type="96-pcr", discard=True) # Initialize all existing inventory all_inventory_wells = [template_tube] + primer_wells for well in all_inventory_wells: init_inventory_well(well) # ----------------------------------------------------- # Provision water once, for general use # p.provision(inv["water"], water_well, ul(500)) # ----------------------------------------------------- # Q5 PCR protocol # www.neb.com/protocols/2013/12/13/pcr-using-q5-high-fidelity-dna-polymerase-m0491 # # 25ul reaction (we will run it 4 times, totally 100uL of solution) # ------------- 4rxn total # Q5 reaction buffer 5 ul --> 20uL # Q5 polymerase 0.25 ul --> 1uL # 10mM dNTP 0.5 ul --> 2uL # 10uM forward primer 1.25 ul --> 5uL # 10uM reverse primer 1.25 ul --> 5uL # 1ng Template (1 ng/ul) 1 ul --> 4uL (1ng/ul concentration) # water # -------------------------------
# # Catalog (all to be discarded afterward) # water_tube = p.ref("water", cont_type="micro-1.5", discard=True).well(0) # # Initialize inventory # all_inventory_wells = [puc19_cut_tube, sfgfp_pcroe_amp_tube] for well in all_inventory_wells: init_inventory_well(well) assert puc19_cut_tube.volume >= ul(20), puc19_cut_tube.volume assert sfgfp_pcroe_amp_tube.volume >= ul(20), sfgfp_pcroe_amp_tube.volume # # Provisioning. Water is used all over the protocol. Provision an excess since it's cheap # p.provision(p.inv["water"], water_tube, ul(500)) # --------------------------------------------------------------- # Generate protocol # do_gibson_assembly(p, water_tube, clone_plate, puc19_cut_tube, sfgfp_pcroe_amp_tube) # ---------------------------------------------------------------
def prepare_growth_wells(growth_wells): # # To LB, add ampicillin at ~1/1000 concentration # p.provision(p.inv["LB Miller"], growth_wells, ul(474.5)) p.provision(p.inv["Amp 100mgml"], growth_wells, ul(0.5))
inv = { 'gblock_dna': 'ct18vs7cmjat2c', # my inventory 'te': 'rs17pwyc754v9t', # catalog; TE } p = Protocol() #existing inventory dna_sample = p.ref("gblock_dna", id=inv['gblock_dna'], cont_type="micro-1.5", storage='cold_20') #tubes are thawed before being placed into workcell #Centrifuge the tube for 3-5 sec at a minimum of 3000 x g to pellet the material to the bottom of the tube. p.spin(dna_sample, '3000:g', '5:second') #Add 500uL TE (to reach 1 ng/uL) p.provision(inv["te"], dna_sample.well(0), ul(500)) #Briefly vortex (here we have to use mix) and centrifuge p.mix(dna_sample.well(0), '480:microliter', speed='480:microliter/second', repetitions=10) p.spin(dna_sample, '3000:g', '3:second') print(json.dumps(p.as_dict(), indent=2))
init_inventory_well(well) # Tubes and plates we use and then discard water_tube = p.ref("water_tube", cont_type="micro-1.5", discard=True).well(0) pcr_plate = p.ref("pcr_plate", cont_type="96-pcr", discard=True) # The result of the experiment, a pUC19 cut by EcoRI and HindIII, goes in this tube for storage puc19_cut_tube = p.ref(expid("puc19_cut", experiment_name), cont_type="micro-1.5", storage="cold_20").well(0) # ------------------------------------------------------------- # Provisioning and diluting. # Diluted EcoRI can be used more than once # p.provision(inv["water"], water_tube, ul(500)) # ------------------------------------------------------------- # Restriction enzyme cutting pUC19 # 3 experiments (1 without re) # 50ul total reaction volume for cutting 1ug of DNA: # 42uL water # 5ul CutSmart 10x # 1ul pUC19 1ml/ml or 1ug/ul (1ug of DNA) # 2ul EcoRI+hindiii (20 units each, >10 units per ug DNA) p.distribute(water_tube, pcr_plate.wells(["A1", "B1", "A2"]), ul(42)) p.distribute(pUC19_well, pcr_plate.wells(["A1", "B1", "A2"]), ul(1), mix_before=True,
"hindiii": "rs18nw6kpnp44v", # catalog; hindiii-HF; cold_20; 20 units/ul "CutSmart": "rs17ta93g3y85t", # catalog; CutSmart Buffer 10x; cold_20 "pUC19": "rs17tcqmncjfsh", # catalog; pUC19; cold_20 'reagent_plate': '' #optional: only needed after the first run } if "--test" in sys.argv: test_inv = { 'reagent_plate': '' #optional: only needed after the first run } inv.update(test_inv) p = Protocol() if 'use_existing_reagent_plate' not in options: dead_volume = ul(3) reagent_plate = p.ref(plate_name, cont_type="96-pcr", storage="cold_20") else: dead_volume = ul(0) reagent_plate = p.ref(plate_name, id=inv['reagent_plate'], cont_type="96-pcr", storage="cold_20") ecori_hindiii_well = reagent_plate.wells(["A1"])[0] #provisioning less than 10uL is dangerous due to pipetting mistakes (can't mix after) volume_per_experiment = ul(1) re_volume = max(ul(10),number_of_experiments*volume_per_experiment+dead_volume/2) p.provision(inv["EcoRI"], ecori_hindiii_well, re_volume) p.provision(inv["hindiii"], ecori_hindiii_well, re_volume) ecori_hindiii_well.name = 'EcoRI+hindiii' ecori_hindiii_well.properties = {'Unit Concentration':'10 units/ul'}