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))
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))
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'}
