Python Protocol.spin方法代码示例

# 需要导入模块: from autoprotocol.protocol import Protocol [as 别名]
# 或者: from autoprotocol.protocol.Protocol import spin [as 别名]
    def runTest(self):
        p1 = Protocol()
        p2 = Protocol()

        p1.spin("dummy_ref", "2000:rpm", "560:second")
        self.assertEqual(len(p2.instructions), 0,
            "incorrect number of instructions in empty protocol")

# 需要导入模块: from autoprotocol.protocol import Protocol [as 别名]
# 或者: from autoprotocol.protocol.Protocol import spin [as 别名]
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)

# 需要导入模块: from autoprotocol.protocol import Protocol [as 别名]
# 或者: from autoprotocol.protocol.Protocol import spin [as 别名]
    def test_sequence_cover_instructions(self):
        p = Protocol()
        cont1 = p.ref("c1", None, "384-pcr", storage="cold_4")
        cont2 = p.ref("c2", None, "384-pcr", storage="cold_4")
        cont3 = p.ref("c3", None, "96-deep", storage="cold_4")
        cont4 = p.ref("c4", None, "micro-1.5", storage="cold_4")
        cont5 = p.ref("c5", None, "384-echo", discard=True)
        therm_groups = [
            {
                "cycles": 1,
                "steps": [
                    {
                        "temperature": "37:celsius",
                        "duration": "60:minute"
                    },
                ]
            }
        ]
        p.incubate(cont1, "ambient", duration="1:minute")
        self.assertEqual(p.instructions[0].op, "seal")
        self.assertEqual(p.instructions[1].op, "incubate")
        self.assertEqual(cont1.cover, 'ultra-clear')
        p.spin(cont1, acceleration="1000:g", duration="2:minute")
        self.assertEqual(cont1.cover, "ultra-clear")
        self.assertEqual(cont2.cover, None)
        p.thermocycle(cont2, groups=therm_groups)

        self.assertEqual(cont2.cover, "ultra-clear")
        p.transfer(cont2.well(0), cont1.well(1), volume="1:microliter")
        self.assertEqual(cont1.cover, None)
        self.assertEqual(cont2.cover, None)
        with self.assertRaises(RuntimeError):
            p.cover(cont2)
        p.seal(cont2)
        p.thermocycle(cont1, groups=therm_groups)
        self.assertEqual(cont1.cover, "ultra-clear")
        p.spin(cont1, acceleration="1000:g", duration="2:minute")
        p.spin(cont2, acceleration="1000:g", duration="2:minute")
        p.spin(cont5, acceleration="1000:g", duration="2:minute")
        self.assertEqual(cont1.cover, "ultra-clear")
        self.assertEqual(cont2.cover, "ultra-clear")
        self.assertEqual(cont5.cover, "universal")
        p.uncover(cont5)
        p.unseal(cont1)
        p.transfer(cont4.well(0), cont3.well(0), "1:microliter")
        p.spin(cont4, acceleration="1000:g", duration="2:minute")
        self.assertEqual(cont4.cover, None)
        with self.assertRaises(RuntimeError):
            p.thermocycle(cont4, groups=therm_groups)
        seal_on_store(p)
        self.assertEqual(cont1.cover, "ultra-clear")
        self.assertEqual(cont2.cover, "ultra-clear")
        self.assertEqual(cont3.cover, "standard")
        self.assertEqual(cont4.cover, None)
        self.assertEqual(cont5.cover, None)

# 需要导入模块: from autoprotocol.protocol import Protocol [as 别名]
# 或者: from autoprotocol.protocol.Protocol import spin [as 别名]
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))