Exemplo n.º 1
0
    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)
Exemplo n.º 2
0
protocol.transfer(e_cells.well("A1"), growth_plate.well("A1"),"30:microliter", mix_after=True)

# Step 4 - Add the negative control cells to the growth plate and mix
protocol.transfer(nc_cells.well("A1"), growth_plate.well("H1"),"30:microliter", mix_after=True)

# Step 5 - Add the engineered cells to the measurement plate
protocol.distribute(growth_plate.well("A1"), measurement_plate.wells_from("A1", 3, columnwise=False), "100:microliter")

# Step 6 - Add the negative control cells to the measurement plate
protocol.distribute(growth_plate.well("H1"), measurement_plate.wells_from("C1", 3, columnwise=False), "100:microliter")

# Step 7 - Add LB medium to the measurement plate
protocol.distribute(lb_medium_c.well("A1"), measurement_plate.wells_from("E1", 3, columnwise=False), "100:microliter")

# Step 8 - Cover the growth plate
protocol.cover(growth_plate, lid="standard")

# Step 9 - Measure indirectly cell concentrations
protocol.absorbance(measurement_plate, ["A1", "A2", "A3", "C1", "C2", "C3", "E1", "E2", "E3",], "600:nanometer","Before Incubation")

# Step 10 - Cover the measurement plate
protocol.cover(measurement_plate, lid="standard")

# Step 11 - Grow new engineered and negative control cells
protocol.incubate(growth_plate, "warm_37", "5:hour", shaking=True)

# Step 12 - Store the measurement plate in the fridge
# This step is being run in series instead of parallel.  Will uncomment it when it runs in parallel.
# The measurement plate remains covered and in room temperature while the growth plate is in the incubator.
#protocol.incubate(measurement_plate, "cold_4", "4:hour")
Exemplo n.º 3
0
xfer_vol = [10] * 96
shape_format = 'SBS96'

# common parameters for all stamps performed
stamp_kwargs = {
    'new_defaults': True,
    'pre_buffer': '10:microliter',
    'blowout_buffer': True,
    'mix_after': True,
    'mix_vol': '30:microliter',
    'repetitions': 5,
    'flowrate': '100:microliter/second',
    'shape_format': shape_format
}

p.seal(src_plate)
p.unseal(src_plate)

p.transfer(
    src_plate.wells_from(0, 4), dest_plate.wells_from(0, 4),
    ["10:microliter", "20:microliter", "30:microliter", "40:microliter"])

p.stamp(src_plate, dest_plate, "10:microliter")
p.cover(dest_plate)
p.incubate(dest_plate, "warm_37", "30:minute", shaking=False)

#p.stamp(src_plate, dest_plate, xfer_vol, **stamp_kwargs)

print(json.dumps(p.as_dict(), indent=2))
Exemplo n.º 4
0
from autoprotocol.protocol import Protocol
import json

p = Protocol()
src_plate= p.ref("src_plate", None, "96-flat", discard=True)

p.cover(src_plate);
p.incubate(src_plate, "warm_37", "1:minute", shaking=False)


print (json.dumps(p.as_dict(), indent=2))
    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")
        assert (p.instructions[0].op == "seal")
        assert (p.instructions[1].op == "incubate")
        assert (cont1.cover == "ultra-clear")

        p.spin(cont1, acceleration="1000:g", duration="2:minute")
        assert (cont1.cover == "ultra-clear")
        assert (cont2.cover is None)

        p.thermocycle(cont2, groups=therm_groups)
        assert (cont2.cover == "ultra-clear")

        p.transfer(cont2.well(0), cont1.well(1), volume="1:microliter")
        assert (cont1.cover is None)
        assert (cont2.cover is None)
        with pytest.raises(RuntimeError):
            p.cover(cont2)

        p.seal(cont2)
        p.thermocycle(cont1, groups=therm_groups)
        assert (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")
        assert (cont1.cover == "ultra-clear")
        assert (cont2.cover == "ultra-clear")
        assert (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")
        assert (cont4.cover is None)
        with pytest.raises(RuntimeError):
            p.thermocycle(cont4, groups=therm_groups)

        seal_on_store(p)
        assert (cont1.cover == "ultra-clear")
        assert (cont2.cover == "ultra-clear")
        assert (cont3.cover == "standard")
        assert (cont4.cover is None)
        assert (cont5.cover is None)