예제 #1
0
    trp.runT7Setup(theo=False,src=srcs,tgt=t71master,vol=len(timepoints)*12.2+15,srcdil=10.0/6)
    t71=[];
    for i in range(len(timepoints)):
        t71=t71+trp.saveSamps(src=t71master,tgt=["%s.T%d"%(s,timepoints[i]) for s in srcs],vol=10,dil=1,plate=trp.e.SAMPLEPLATE)
        
    # Stop one sample immediately for a zero timepoint
    trp.runT7Stop(theo=False,vol=10, tgt=t71[0:len(srcs)],stopmaster=stop)
    trp.runT7Pgm(vol=10,dur=timepoints[-1])
    
    for s in findsamps(t71[len(srcs):]):
        s.volume=s.volume+10 # Program doesn't know that they were diluted 2x by hand
        s.addhistory("Manual stop",10,None)
        
    # No stop, done during run
    trp.diluteInPlace(tgt=t71,dil=5)
    # Dilute input samples enough to use in qPCR directly (should be 5000/(rnagain*2*5)  = 20)
    
    qpcrdil1=trp.runQPCRDIL(src=t71,tgt=[],vol=100,srcdil=20,dilPlate=True)   
    rt1=trp.runRT(pos=True,src=t71,tgt=[],vol=5,srcdil=2)
    rt1=trp.diluteInPlace(tgt=rt1,dil=5)
    lig1=trp.runLig(src=rt1,tgt=[],vol=10,srcdil=3,master=ligmaster)
    prods=trp.diluteInPlace(tgt=lig1,dil=10)
        
    for i in range(len(qpcrdil1)):
        trp.runQPCR(src=qpcrdil1[i],vol=15,srcdil=10.0/4,primers=[tmplqpcr[i]])
    for i in range(len(prods)):
        trp.runQPCR(src=[prods[i]],vol=15,srcdil=10.0/4,primers=pcr[i])

trp.finish()

예제 #2
0
        trp.addTemplates(input,stockconc=10.0/6.0,units="x",plate=Experiment.EPPENDORFS)   # Add a template
    else:   
        reagents=Sample.getAllOnPlate(Experiment.REAGENTPLATE)+Sample.getAllOnPlate(Experiment.EPPENDORFS)
        for r in reagents:
            if r.volume<=0:
                r.initvolume=-r.volume+r.plate.unusableVolume
        Sample.clearall()

    t71=trp.runT7(theo=False,src=srcs,tgt=[],vol=10,srcdil=10.0/6,dur=15,stopmaster=stop)
    #print t71
    t71=trp.diluteInPlace(tgt=t71,dil=5)
    # Dilute input samples enough to use in qPCR directly (should be 5000/(rnagain*2*5)  = 20)
    qpcrdil1=trp.runQPCRDIL(src=t71,tgt=[],vol=100,srcdil=20,dilPlate=False)
    
    rt1=trp.runRT(pos=True,src=t71,tgt=[],vol=30,srcdil=2)
    rt1=trp.diluteInPlace(tgt=rt1,dil=5)
    
    lig=trp.runLig(src=rt1*6,tgt=[],vol=20,srcdil=3,master=ligmaster1*3+ligmaster2*3)
    prods=trp.diluteInPlace(tgt=lig,dil=10)
    print "prod=",prods
    for i in range(len(qpcrdil1)):
        trp.runQPCR(src=qpcrdil1[i],vol=15,srcdil=10.0/4,primers=[tmplqpcr[i]],nreplicates=3)

    for p in pcr1:
        trp.runQPCR(src=prods[0:3],vol=15,srcdil=10.0/4,primers=p,nreplicates=3)
    for p in pcr2:
        trp.runQPCR(src=prods[3:6],vol=15,srcdil=10.0/4,primers=p,nreplicates=3)

trp.finish()

예제 #3
0
    t71 = trp.runT7(theo=False,
                    src=srcs,
                    tgt=[],
                    vol=10,
                    srcdil=10.0 / 6,
                    dur=15,
                    stopmaster=stop)
    #print t71
    t71 = trp.diluteInPlace(tgt=t71, dil=5)
    # Dilute input samples enough to use in qPCR directly (should be 5000/(rnagain*2*5)  = 20)
    qpcrdil1 = trp.runQPCRDIL(src=t71,
                              tgt=[],
                              vol=100,
                              srcdil=20,
                              dilPlate=True)
    rt1 = trp.runRT(pos=True, src=t71, tgt=[], vol=5, srcdil=2)
    rt1 = trp.diluteInPlace(tgt=rt1, dil=5)
    lig1 = trp.runLig(src=rt1, tgt=[], vol=10, srcdil=3, master=ligmaster)
    prods = trp.diluteInPlace(tgt=lig1, dil=10)

    for i in range(len(qpcrdil1)):
        trp.runQPCR(src=qpcrdil1[i],
                    vol=15,
                    srcdil=10.0 / 4,
                    primers=[tmplqpcr[i]])
    for i in range(len(prods)):
        trp.runQPCR(src=[prods[i]], vol=15, srcdil=10.0 / 4, primers=pcr[i])

trp.finish()
예제 #4
0
    pcr1=trp.runPCR(prefix=[srcprefix],src=rt1[1],tgt=[],vol=50,srcdil=4)
    trp.diluteInPlace(tgt=pcr1,dil=3)
    sv1pcr=trp.saveSamps(src=pcr1,tgt=["R1"],vol=125,dil=1)
    
    # Round 2 (-theo, Ligate, keep cleaved)
    t72=trp.runT7(theo=[False,True],src=sv1pcr+sv1pcr,tgt=[],vol=17,srcdil=80.0/24)
    sv2t7=trp.saveSamps(src=t72,tgt=[],vol=7,dil=4)
    rt2=trp.runRT(pos=[True for i in t72+sv1t7]+[False for i in t72+sv1t7],src=t72+sv1t7+t72+sv1t7,tgt=[],vol=[12]+[9 for s in t72[1:]+sv1t7+t72+sv1t7],srcdil=2)
    trp.diluteInPlace(tgt=rt2,dil=2)
    lig2=trp.runLig(prefix=prodprefix,src=rt2+sv1rt,tgt=[],vol=[30]+[16 for s in rt2[1:]+sv1rt],srcdil=3)
    qsamps=lig2+sv1t7+sv2t7     # Samples for QPCR
    diltolig=[24 for s in t72]+[24*4 for s in sv1t7]+[24 for s in t72]+[24*4 for s in sv1t7]+[16 for s in sv1rt]+[8 for s in sv1t7]+[8 for s in sv2t7]   # Their dilution so far from the T7 product point (before stop added)
    dilneeded=[20000/d for d in diltolig]
    qdil1=[max(50,math.sqrt(d)) for d in dilneeded]   # Split dilution equally, but don't use more than 3ul in first step
    qdil2=[dilneeded[i]/qdil1[i] for i in range(len(qdil1))]   # Whatever remains
    qpcrdil1=trp.runQPCRDIL(src=qsamps,tgt=[],vol=150,srcdil=qdil1)   # First dilution before starting PCR (so the rest of the QPCR setup can be done while PCR is running)
    pcr2=trp.runPCR(prefix=prodprefix,src="R1.T-.RT+.L"+prodprefix,tgt=[],vol=50,srcdil=4)
    qpcrdil2x1=trp.runQPCRDIL(src=qpcrdil1,tgt=[],vol=150,srcdil=qdil2)
    #    qpcrdil2x2=trp.runQPCRDIL(src=qpcrdil1[0:2],tgt=['x2a','x2b'],vol=150,srcdil=[d*2 for d in qdil2[0:2]])
    qpcrdil2x4=trp.runQPCRDIL(src=qpcrdil1[0:2],tgt=['x4a','x4b'],vol=150,srcdil=[d*4 for d in qdil2[0:2]])
    qpcrdil2x4b=trp.runQPCRDIL(src=qpcrdil2x1[0:2],tgt=['x4ab','x4bb'],vol=150,srcdil=[4 for d in qdil2[0:2]])
    qpcrdil2x16=trp.runQPCRDIL(src=qpcrdil2x1[0:2],tgt=['x16a','x16b'],vol=150,srcdil=[16 for d in qdil2[0:2]])
    qpcrdil2=qpcrdil2x1+qpcrdil2x4+qpcrdil2x4b+qpcrdil2x16
    trp.runQPCR(src=qpcrdil2,vol=15,srcdil=10.0/4)
    trp.diluteInPlace(tgt=pcr2,dil=3)
    sv2pcr=trp.saveSamps(src=pcr2,tgt=["R2"],vol=125,dil=1)

trp.finish()

            
예제 #5
0
        tmpldil2 = trp.saveSamps(src=tmpldil1 + pcrsave,
                                 vol=4,
                                 dil=20,
                                 plate=trp.e.DILPLATE)
        tmpldil2b = trp.saveSamps(src=["BT371"],
                                  vol=2,
                                  dil=50,
                                  plate=trp.e.DILPLATE)
        tmpldil3 = trp.saveSamps(src=tmpldil2 + tmpldil2b,
                                 vol=4,
                                 dil=16,
                                 dilutant=trp.r.SSD,
                                 plate=trp.e.DILPLATE)

        trp.runQPCR(src=ligtmp1 + ligtmp2,
                    vol=15,
                    srcdil=15.0 / 6,
                    primers=["A", "B"])
        notSpiked = [t for t in tmpldil3 if "spike" not in t]
        spiked = [t for t in tmpldil3 if "spike" in t]
        print "Setting up qPCR of  %d non-spiked template/PCR products with A,B,M,T primers" % (
            len(notSpiked))
        trp.runQPCR(src=notSpiked + ["Water"],
                    vol=15,
                    srcdil=15.0 / 6,
                    primers=["A", "B", "M", "T"])
        print "Setting up qPCR of  %d spiked template/PCR products with M,T primers" % (
            len(tmpldil3[3:]))
        trp.runQPCR(src=spiked, vol=15, srcdil=15.0 / 6, primers=["M", "T"])
        trp.e.w.setOptimization(False)

trp.finish()
예제 #6
0
파일: NGSTRP3.py 프로젝트: qPCR4vir/pyTecan
    else:   
        reagents=Sample.getAllOnPlate(Experiment.REAGENTPLATE)+Sample.getAllOnPlate(Experiment.EPPENDORFS)
        for r in reagents:
            if r.volume<=0:
                r.initvolume=-r.volume+r.plate.unusableVolume
        Sample.clearall()

    t71=trp.runT7Setup(theo=False,src=srcs*2,tgt=["%s.T%d"%(srcs[i],timepoints[j])  for j in range(len(timepoints)) for i in range(len(srcs))],vol=10,srcdil=10.0/6)
    timesofar=0
    for i in range(len(timepoints)):
        lastelapse=trp.e.w.elapsed
        trp.runT7Pgm(10,timepoints[i]-timesofar) # vol, duration
        timesofar=timesofar+timepoints[i]
        tp=trp.runT7Stop(theo=False,vol=10,tgt=t71[(i*len(srcs)):((i+1)*len(srcs))],stopmaster=stop)
        print "Dead time=%.1f min"%((trp.e.w.elapsed-lastelapse)/60.0)

    trp.diluteInPlace(tgt=t71,dil=5)

    # Dilute input samples enough to use in qPCR directly (should be 5000/(rnagain*2*5)  = 20)
    qpcrdil1=trp.runQPCRDIL(src=t71,tgt=[],vol=100,srcdil=20,dilPlate=True)   
    rt1=trp.runRT(pos=True,src=t71,tgt=[],vol=10,srcdil=2)
    rt1=trp.diluteInPlace(tgt=rt1,dil=5)
    lig1=trp.runLig(src=rt1,tgt=[],vol=25,srcdil=3,master=ligmaster)
    prods=trp.saveSamps(lig1,vol=5,dil=10,plate=Experiment.DILPLATE)
    
    trp.runQPCR(src=qpcrdil1,vol=15,srcdil=10.0/4,primers=["WX","REF"])
    trp.runQPCR(src=prods,vol=15,srcdil=10.0/4,primers=["WX","AX","REF"])
        
    
trp.finish()
예제 #7
0
    for i in range(len(timepoints)):
        lastelapse = trp.e.w.elapsed
        trp.runT7Pgm(10, timepoints[i] - timesofar)
        timesofar = timesofar + timepoints[i]
        tp = trp.runT7Stop(theo=False,
                           vol=10,
                           tgt=t71[(i * len(srcs)):((i + 1) * len(srcs))],
                           stopmaster=stop)
        print "Dead time=%.1f min" % ((trp.e.w.elapsed - lastelapse) / 60.0)

    trp.diluteInPlace(tgt=t71, dil=5)
    print t71

    # Dilute input samples enough to use in qPCR directly (should be 5000/(rnagain*2*5)  = 20)
    qpcrdil1 = trp.runQPCRDIL(src=t71,
                              tgt=[],
                              vol=100,
                              srcdil=20,
                              dilPlate=True)
    rt1 = trp.runRT(pos=True, src=t71, tgt=[], vol=5, srcdil=2)
    rt1 = trp.diluteInPlace(tgt=rt1, dil=5)
    lig1 = trp.runLig(src=rt1, tgt=[], vol=10, srcdil=3, master=ligmaster)
    prods = trp.diluteInPlace(tgt=lig1, dil=10)

    print "qpcrdil1=", qpcrdil1
    trp.runQPCR(src=qpcrdil1, vol=15, srcdil=10.0 / 4, primers=tmplqpcr)
    print "prods=", prods
    trp.runQPCR(src=prods, vol=15, srcdil=10.0 / 4, primers=pcr)

trp.finish()
예제 #8
0
                              dilPlate=False)

    rt1 = trp.runRT(pos=True, src=t71, tgt=[], vol=30, srcdil=2)
    rt1 = trp.diluteInPlace(tgt=rt1, dil=5)

    lig = trp.runLig(src=rt1 * 6,
                     tgt=[],
                     vol=20,
                     srcdil=3,
                     master=ligmaster1 * 3 + ligmaster2 * 3)
    prods = trp.diluteInPlace(tgt=lig, dil=10)
    print "prod=", prods
    for i in range(len(qpcrdil1)):
        trp.runQPCR(src=qpcrdil1[i],
                    vol=15,
                    srcdil=10.0 / 4,
                    primers=[tmplqpcr[i]],
                    nreplicates=3)

    for p in pcr1:
        trp.runQPCR(src=prods[0:3],
                    vol=15,
                    srcdil=10.0 / 4,
                    primers=p,
                    nreplicates=3)
    for p in pcr2:
        trp.runQPCR(src=prods[3:6],
                    vol=15,
                    srcdil=10.0 / 4,
                    primers=p,
                    nreplicates=3)
예제 #9
0
            if r.volume<=0:
                r.initvolume=-r.volume+r.plate.unusableVolume
        Sample.clearall()

    t71=trp.runT7Setup(theo=False,src=srcs*2,tgt=["%s.T%d"%(srcs[i],timepoints[j])  for j in range(len(timepoints)) for i in range(len(srcs))],vol=10,srcdil=10.0/6)
    timesofar=0
    for i in range(len(timepoints)):
        lastelapse=trp.e.w.elapsed
        trp.runT7Pgm(10,timepoints[i]-timesofar)
        timesofar=timesofar+timepoints[i]
        tp=trp.runT7Stop(theo=False,vol=10,tgt=t71[(i*len(srcs)):((i+1)*len(srcs))],stopmaster=stop)
        print "Dead time=%.1f min"%((trp.e.w.elapsed-lastelapse)/60.0)

    trp.diluteInPlace(tgt=t71,dil=5)
    print t71

    # Dilute input samples enough to use in qPCR directly (should be 5000/(rnagain*2*5)  = 20)
    qpcrdil1=trp.runQPCRDIL(src=t71,tgt=[],vol=100,srcdil=20,dilPlate=True)   
    rt1=trp.runRT(pos=True,src=t71,tgt=[],vol=5,srcdil=2)
    rt1=trp.diluteInPlace(tgt=rt1,dil=5)
    lig1=trp.runLig(src=rt1,tgt=[],vol=10,srcdil=3,master=ligmaster)
    prods=trp.diluteInPlace(tgt=lig1,dil=10)
        
    print "qpcrdil1=",qpcrdil1
    trp.runQPCR(src=qpcrdil1,vol=15,srcdil=10.0/4,primers=tmplqpcr)
    print "prods=",prods
    trp.runQPCR(src=prods,vol=15,srcdil=10.0/4,primers=pcr)

trp.finish()

예제 #10
0
    for i in range(len(timepoints)):
        lastelapse = trp.e.w.elapsed
        trp.runT7Pgm(10, timepoints[i] - timesofar)  # vol, duration
        timesofar = timesofar + timepoints[i]
        tp = trp.runT7Stop(theo=False,
                           vol=10,
                           tgt=t71[(i * len(srcs)):((i + 1) * len(srcs))],
                           stopmaster=stop)
        print "Dead time=%.1f min" % ((trp.e.w.elapsed - lastelapse) / 60.0)

    trp.diluteInPlace(tgt=t71, dil=5)

    # Dilute input samples enough to use in qPCR directly (should be 5000/(rnagain*2*5)  = 20)
    qpcrdil1 = trp.runQPCRDIL(src=t71,
                              tgt=[],
                              vol=100,
                              srcdil=20,
                              dilPlate=True)
    rt1 = trp.runRT(pos=True, src=t71, tgt=[], vol=10, srcdil=2)
    rt1 = trp.diluteInPlace(tgt=rt1, dil=5)
    lig1 = trp.runLig(src=rt1, tgt=[], vol=25, srcdil=3, master=ligmaster)
    prods = trp.saveSamps(lig1, vol=5, dil=10, plate=Experiment.DILPLATE)

    trp.runQPCR(src=qpcrdil1, vol=15, srcdil=10.0 / 4, primers=["WX", "REF"])
    trp.runQPCR(src=prods,
                vol=15,
                srcdil=10.0 / 4,
                primers=["WX", "AX", "REF"])

trp.finish()
예제 #11
0
        
        # But use PCR product from sample plate for next rount to avoid extra dilution
        input=pcr2

    if doqpcr:
        # Setup qPCR
        # Do A,B,M,T of input and PCR products (4*9), A,B of ligation products (2*8), M,T of reference
        # Saved products should already be at correct concentration for qPCR
        #trp.e.w.setOptimization(True)
        print "Setting up qPCR of %d ligation products with A,B primers"%(len(ligsave1+ligsave2))
        ligtmp1=trp.saveSamps(src=ligsave1,vol=4,dil=8,plate=trp.e.DILPLATE,dilutant=trp.r.SSD)
        ligtmp2=trp.saveSamps(src=ligsave2,vol=4,dil=8*3.5,plate=trp.e.DILPLATE,dilutant=trp.r.SSD)
        # Need to dilute templates to match PCR products
        tmpldil1=trp.saveSamps(src=templates,vol=4,dil=20.0/3,plate=trp.e.DILPLATE)
        tmpldil2=trp.saveSamps(src=tmpldil1+pcrsave,vol=4,dil=20,plate=trp.e.DILPLATE) 
        tmpldil2b=trp.saveSamps(src=["BT371"],vol=2,dil=50,plate=trp.e.DILPLATE) 
        tmpldil3=trp.saveSamps(src=tmpldil2+tmpldil2b,vol=4,dil=16,dilutant=trp.r.SSD,plate=trp.e.DILPLATE)

        trp.runQPCR(src=ligtmp1+ligtmp2,vol=15,srcdil=15.0/6,primers=["A","B"])
        notSpiked=[t for t in tmpldil3 if "spike" not in  t]
        spiked=[t for t in tmpldil3 if "spike" in t]
        print "Setting up qPCR of  %d non-spiked template/PCR products with A,B,M,T primers"%(len(notSpiked))
        trp.runQPCR(src=notSpiked+["Water"],vol=15,srcdil=15.0/6,primers=["A","B","M","T"])
        print "Setting up qPCR of  %d spiked template/PCR products with M,T primers"%(len(tmpldil3[3:]))
        trp.runQPCR(src=spiked,vol=15,srcdil=15.0/6,primers=["M","T"])
        trp.e.w.setOptimization(False)

trp.finish()