def check_correlations(aliceTtags, aliceChannels, bobTtags, bobChannels, resolution, A_B_timetags, A_B_channels, channels1, channels2, delays, coincidence_window_radius): for delay, ch1, ch2 in zip(delays, channels1, channels2): if delay < 0: A_B_timetags[A_B_channels == ch2] += (abs(delay)).astype(uint64) else: A_B_timetags[A_B_channels == ch1] += delay.astype(uint64) indexes_of_order = A_B_timetags.argsort(kind="mergesort") A_B_channels = take(A_B_channels, indexes_of_order) A_B_timetags = take(A_B_timetags, indexes_of_order) buf_num = ttag.getfreebuffer() buffer = ttag.TTBuffer(buf_num, create=True, datapoints=int(5e7)) buffer.resolution = 260e-12 buffer.channels = max(A_B_channels) + 1 buffer.addarray(A_B_channels, A_B_timetags) buf_num = ttag.getfreebuffer() bufDelays = ttag.TTBuffer(buf_num, create=True, datapoints=int(5e7)) bufDelays.resolution = resolution bufDelays.channels = max(A_B_channels) + 1 bufDelays.addarray(A_B_channels, A_B_timetags.astype(uint64)) with_delays = (bufDelays.coincidences( (A_B_timetags[-1] - 1) * bufDelays.resolution, coincidence_window_radius)) remade = remake_coincidence_matrix(with_delays) print "__COINCIDENCES WITH DELAYS ->>\n", remade.astype(uint64)
def startTagger(): global buf ttnumber = ttag.getfreebuffer() - 1 print "ttnumber: ", ttnumber buf = ttag.TTBuffer(ttnumber) #Opens the buffer # Timetag time units are float buf.start() return buf
def openttag(toFile=None): fromFile = '/mnt/odrive/HPD/ShanePyStuff/scripts/UQDttagger2/ttag/UQD/src/uqd.uqcfg' ttnumber = ttag.getfreebuffer() - 1 print "ttnumber: ", ttnumber buf = ttag.TTBuffer(ttnumber) #Opens the buffer buf.tagsAsTime = False #buf.start() if toFile != None: shutil.copyfile(fromFile, toFile) return buf
def Start(self): if not self.connected: print('Connect the rotator before starting acquisition') return self.btnConnect.setEnabled(False) if not self.inAcq: self.inAcq = True self.txtBufferNo.setEnabled(False) self.btnStart.setStyleSheet('background-color: red') self.btnStart.setText('Stop') self.getParameters() self.runStart += 1 if self.runStart > 1: return self.UpdateLabels() print('Acquisition started') self.ttagBuf = ttag.TTBuffer(self.bufNum) self.btnSaveData.setEnabled(True) self.Ncounts = [] for angle in np.arange(self.iniAngle, self.finAngle, self.stepAngle): QtGui.qApp.processEvents() if not self.inAcq: break self.ttagBuf.start() time.sleep(self.integrationTime / .9) self.ttagBuf.stop() time.sleep(.1) self.Ncounts.append(self.ttagBuf.singles(self.integrationTime)) self.con.goto(angle, wait=True) ## Move plate to angle=angle time.sleep(timeAfterPlateMove) self.UpdateView() self.runStart = 0 self.btnConnect.setEnabled(True) print('Acquisition stopped') self.inAcq = False self.txtBufferNo.setEnabled(True) self.btnStart.setStyleSheet('') self.btnStart.setText('Start')
def calculate_delays(aliceTtags, aliceChannels, bobTtags, bobChannels, resolution=260e-12, coincidence_window_radius=200 - 12, delay_max=1e-6): channels1 = [0, 1, 2, 3] channels2 = [4, 5, 6, 7] A_B_timetags = concatenate([aliceTtags, bobTtags]) A_B_channels = concatenate([aliceChannels, bobChannels]) indexes_of_order = A_B_timetags.argsort(kind="mergesort") A_B_channels = take(A_B_channels, indexes_of_order) A_B_timetags = take(A_B_timetags, indexes_of_order) buf_num = ttag.getfreebuffer() bufN = ttag.TTBuffer(buf_num, create=True, datapoints=int(5e11)) bufN.resolution = resolution bufN.channels = max(A_B_channels) + 1 bufN.addarray(A_B_channels, A_B_timetags) coincidences_before = (bufN.coincidences( (A_B_timetags[-1] - 1) * bufN.resolution, coincidence_window_radius)) remade = remake_coincidence_matrix(coincidences_before) print "__COINCIDENCES BEFORE-->>\n", remade.astype(uint64) channel_number = int(max(append(channels1, channels2))) delays = zeros(channel_number) k = 0 for i, j in zip(channels1, channels2): delays[i] = (getDelay( bufN, i, j, delaymax=delay_max, time=(A_B_timetags[-1] - 1) * bufN.resolution)) / bufN.resolution print delays[i] k += 1 check_correlations(aliceTtags, aliceChannels, bobTtags, bobChannels, resolution, A_B_timetags, A_B_channels, channels1, channels2, delays, coincidence_window_radius) print("Saving delays to file.") save("./resultsLaurynas/Delays/delays.npy", delays)
def Start(self): if not self.inAcq: self.inAcq = True self.txtPause.setEnabled(False) self.txtBufferNo.setEnabled(False) self.btnStart.setStyleSheet('background-color: red') self.btnStart.setText('Stop') self.getParameters() self.timer.start(self.pause) self.ttagBuf = ttag.TTBuffer(self.bufNum) else: self.timer.stop() self.inAcq = False self.txtPause.setEnabled(True) self.txtBufferNo.setEnabled(True) self.btnStart.setStyleSheet('') self.btnStart.setText('Start')
def prep(): #Alice and Bob Channels aliceChannels = [0, 1, 2, 3] bobChannels = [4, 5, 6, 7] #binsize: The time in seconds of a bin binsize = 1 / (32 * 120.0e6) #Create the buffer that will do stuff bufAlice = ttag.TTBuffer(1) print("Binning...") #The time allocated to each bin: c, t = binData(bufAlice, binsize) #Create data sequences for Alice and Bob bob, alice, bob_pol, alice_pol = extractAliceBob(c, t, aliceChannels, bobChannels) print("Finding Intersect") #Make sure Alice and Bob datasets coencide aliceMask = logical_and(alice > bob[0], alice < bob[-1]) bobMask = logical_and(bob > alice[0], bob < alice[-1]) bob = bob[bobMask] bob_pol = bob_pol[bobMask] alice = alice[aliceMask] alice_pol = alice_pol[aliceMask] #Now, rezero z = min(bob[0], alice[0]) bob -= z alice -= z return (alice, bob, alice_pol, bob_pol)
import ttag bufNum = ttag.getfreebuffer() - 1 buf = ttag.TTBuffer(bufNum) buf.stop()
#Run UQDinterface # is this needed anymore? SN, May 17, 2014 #args = ['sudo', 'bash','launch.sh'] #f = open('test','w') #process = subprocess.Popen(args,stdout=f) #print "The process ID is:" #print process.pid+1 # p.pid is the PID for the new shell. p.pid is the PID for UQDinterface in the new shell #print process.pid+2 #time.sleep(1) #ttnumber = int(raw_input("Time tagger to open:")) ttnumber = ttag.getfreebuffer() - 1 print "ttnumber: ", ttnumber buf = ttag.TTBuffer(ttnumber) #Opens the buffer buf.tagsAsTime = False buf.start() time.sleep(1) print "Channels:", buf.channels print "Resolution:", buf.resolution print "Datapoints:", buf.datapoints print "Buffer size:", buf.size() ptr = 0 updateTime = ptime.time() fps = 0 logdata = False seq_count = 0
aliceTtags = array(alice[1], dtype=uint64) bobTtags = array(bob[1], dtype=uint64) aliceChannels = array(alice[0], dtype=uint8) bobChannels = array(bob[0], dtype=uint8) A_B_timetags = concatenate((aliceTtags, bobTtags)) A_B_channels = concatenate((aliceChannels, bobChannels)) indexes_of_order = A_B_timetags.argsort(kind="mergesort") A_B_channels = take(A_B_channels, indexes_of_order) A_B_timetags = take(A_B_timetags, indexes_of_order) A_B_channels.astype(uint8) A_B_timetags.astype(uint64) buf_num = ttag.getfreebuffer() buffer = ttag.TTBuffer(buf_num, create=True, datapoints=int(5e7)) buffer.resolution = 156.25e-12 buffer.channels = max(A_B_channels) + 1 buffer.addarray(A_B_channels, A_B_timetags) resolution = 156.25e-12, channels1 = [0, 1, 2, 3] channels2 = [4, 5, 6, 7] # (d1,d2) = calculate_delays(aliceTtags, aliceChannels, bobTtags, bobChannels,resolution= 156.25e-12,coincidence_window_radius = 5e-9, channel_array=channels1) # print d1,d2 set_printoptions(edgeitems=50) coincidence_window_radius = 1e-4 print "radius in bins: ", coincidence_window_radius / buffer.resolution, "time back in bins, ", int( ((A_B_timetags[-1] - 1) * buffer.resolution) / buffer.resolution)
def check_correlations(aliceTtags, aliceChannels, bobTtags, bobChannels, resolution, A_B_timetags, A_B_channels, channels1, channels2, delays, coincidence_window_radius, matrix_before, delay_max, dic, l, b1, b2): # print "TIMETAGS BEFORE DELAYS:", A_B_timetags,A_B_channels # print("- Applying Delays") # save("./Debugging/aliceChD.npy",A_B_channels[in1d(A_B_channels,channels1)]) # save("./Debugging/aliceTtagsD.npy",A_B_timetags[in1d(A_B_channels,channels1)]) # # save("./Debugging/bobChD.npy",A_B_channels[in1d(A_B_channels,channels2)]) # save("./Debugging/bobTtagsD.npy",A_B_timetags[in1d(A_B_channels,channels2)]) # for delay, ch1, ch2 in zip(delays, channels1, channels2): if delay < 0: # print "abs-->>",(abs(delay)).astype(int) A_B_timetags[A_B_channels == ch2] += (abs(delay)).astype(uint64) else: # print "-->",delay A_B_timetags[A_B_channels == ch1] += delay.astype(uint64) indexes_of_order = A_B_timetags.argsort(kind="mergesort") A_B_channels = take(A_B_channels, indexes_of_order) A_B_timetags = take(A_B_timetags, indexes_of_order) # print "SORTED TTAGS: ", A_B_timetags,A_B_channels buf_num = ttag.getfreebuffer() buffer = ttag.TTBuffer(buf_num, create=True, datapoints=int(5e7)) buffer.resolution = 260e-12 buffer.channels = max(A_B_channels) + 1 buffer.addarray(A_B_channels, A_B_timetags) # a_ttags = array([]) # a_channels = array([]) # for ch in [0,1,2,3]: # a_ttags = append(a_ttags, A_B_timetags[A_B_channels == ch]) # a_channels = append(a_channels, A_B_channels[A_B_channels == ch]) # # indexes_of_order = a_ttags.argsort(kind = "mergesort") # a_channels = take(a_channels,indexes_of_order) # a_ttags = take(a_ttags,indexes_of_order) # # # # # a_laser_delay_string = laser(a_ttags[a_channels == 3], resolution, coincidence_window_radius) # # # # # # b_ttags = array([]) # b_channels = array([]) # for ch in [4,5,6,7]: # b_ttags = append(b_ttags, A_B_timetags[A_B_channels == ch]) # b_channels = append(b_channels, A_B_channels[A_B_channels == ch]) # # indexes_of_order = b_ttags.argsort(kind = "mergesort") # b_channels = take(b_channels,indexes_of_order) # b_ttags = take(b_ttags,indexes_of_order) # # # savetxt("./DarpaQKD/a_ttags3-7",a_ttags[a_channels == 3],fmt='%15d') # # print "with getcoinc",get_coinc(a_ttags, a_channels, b_ttags, b_channels, 3, 7, int(coincidence_window_radius/resolution)) # savetxt("./DarpaQKD/intersection3-7.npy",intersect1d(a_laser_delay_string,b_ttags[b_channels == 7]),fmt='%10d') # print "Coincidences WITH delays",len(intersect1d(a_laser_delay_string,b_ttags[b_channels == 7])) # (d1,d2) = getDelays(buffer,channels1,channels2,delaymax=coincidence_window_radius,time=(A_B_timetags[-1]-1)*buffer.resolution) # A_B_timetags = A_B_timetags.astype(float) # for i in range(len(channels1)): # A_B_timetags[A_B_channels==channels1[i]]-=d1[i] # for i in range(len(channels2)): # A_B_timetags[A_B_channels==channels2[i]]-=d2[i] # A_B_timetags = A_B_timetags.astype(uint64) buf_num = ttag.getfreebuffer() bufDelays = ttag.TTBuffer(buf_num, create=True, datapoints=int(5e7)) bufDelays.resolution = resolution bufDelays.channels = max(A_B_channels) + 1 bufDelays.addarray(A_B_channels, A_B_timetags.astype(uint64)) # print bufDelays.singles((A_B_timetags[-1]-1)*bufDelays.resolution) with_delays = (bufDelays.coincidences( (A_B_timetags[-1] - 1) * bufDelays.resolution, coincidence_window_radius)) # print "__WITH_DELAYS-->\n",with_delays remade = remake_coincidence_matrix(with_delays) # print "=========================================================================================================" # print coincidence_window_radius # print "__REMADE-->>\n",remade remade1 = array( [[(remade[0][0] + remade[0][1] + remade[1][0] + remade[1][1]) / sum(sum(remade)), (remade[0][2] + remade[0][3] + remade[1][2] + remade[1][3]) / sum(sum(remade))], [(remade[2][0] + remade[2][1] + remade[3][0] + remade[3][1]) / sum(sum(remade)), (remade[2][2] + remade[2][3] + remade[3][2] + remade[3][3]) / sum(sum(remade))]]) print remade[2][2], remade[3][3] dic[l] = (remade[2][2] + remade[3][3]) - (b1 + b2) return dic # print array([ [(remade[0][0] + remade[0][1]+remade[1][0]+remade[1][1]), (remade[0][2] + remade[0][3]+remade[1][2]+remade[1][3])], # [(remade[2][0] + remade[2][1]+remade[3][0]+remade[3][1]), (remade[2][2] + remade[2][3]+remade[3][2]+remade[3][3])] # ]) print "=========================================================================================================" # # print "__CONTRIBUTION-->>\n", remade1 save("./Debugging/aliceChD.npy", A_B_channels[in1d(A_B_channels, channels1)]) save("./Debugging/aliceTtagsD.npy", A_B_timetags[in1d(A_B_channels, channels1)]) save("./Debugging/bobChD.npy", A_B_channels[in1d(A_B_channels, channels2)]) save("./Debugging/bobTtagsD.npy", A_B_timetags[in1d(A_B_channels, channels2)]) # print"----",len(bobTtags) # bobTtags = load("./DarpaQKD/bobCorrectedT.npy") # bobChannels = load("./DarpaQKD/bobCorrectedC.npy") # aliceTtags = load("./DarpaQKD/aliceCorrectedT.npy") # aliceChannels = load("./DarpaQKD/aliceCorrectedC.npy") # a_laser_string = laser(aliceTtags[aliceChannels==3], resolution, coincidence_window_radius) # print a_laser_string # print "Coincidences WITH CORRECTIONS",len(intersect1d(a_laser_string,bobTtags[bobChannels == 7]))/float(len(bobTtags[bobChannels == 7])) # print len(bobTtags) A_B_timetags1 = concatenate([aliceTtags, bobTtags]) A_B_channels1 = concatenate([aliceChannels, bobChannels]) indexes_of_order = A_B_timetags1.argsort(kind="mergesort") A_B_channels1 = take(A_B_channels1, indexes_of_order) A_B_timetags1 = take(A_B_timetags1, indexes_of_order) buf_num = ttag.getfreebuffer() bufCorrec = ttag.TTBuffer(buf_num, create=True, datapoints=int(5e7)) bufCorrec.resolution = resolution bufCorrec.channels = max(A_B_channels1) + 1 bufCorrec.addarray(A_B_channels1, A_B_timetags1.astype(uint64)) with_corrections = (bufCorrec.coincidences( (A_B_timetags1[-1] - 1) * bufCorrec.resolution, coincidence_window_radius)) # print "__WITH_Corrections-->\n",with_corrections # print "__REMADE-->>\n",remake_coincidence_matrix(with_corrections) # a_laser_string = laser(aliceTtags[:len(aliceTtags)/88000], resolution, int(coincidence_window_radius/resolution)) # print "Coincidences with delays",len(intersect1d(a_laser_string,bobTtags[:len(aliceTtags)/88000])) # print "with delays: number of 0 channels and number of channel 4",len(A_B_timetags[A_B_channels == 1]),len(A_B_timetags[A_B_channels == 4]) # print "COINcidences between 0 and 4 after delays: ", get_coinc(aliceTtags, aliceChannels, bobTtags, bobChannels, 0, 4, int(coincidence_window_radius/resolution)) # print "__DIFF___->>>>\n",matrix_before.astype(int64)-(bufDelays.coincidences((A_B_timetags[-1]-1)*bufDelays.resolution, coincidence_window_radius).astype(int64)) length_in_bins = int(delay_max / resolution) * 2
def calculate_delays(aliceTtags, aliceChannels, bobTtags, bobChannels, l, dic, resolution=260e-12, coincidence_window_radius=200 - 12, delay_max=1e-6): channels1 = [0, 1, 2, 3] channels2 = [4, 5, 6, 7] A_B_timetags = concatenate([aliceTtags, bobTtags]) A_B_channels = concatenate([aliceChannels, bobChannels]) indexes_of_order = A_B_timetags.argsort(kind="mergesort") A_B_channels = take(A_B_channels, indexes_of_order) A_B_timetags = take(A_B_timetags, indexes_of_order) # print "TIME: ", A_B_timetags[-1]*resolution, " in seconds" buf_num = ttag.getfreebuffer() bufN = ttag.TTBuffer(buf_num, create=True, datapoints=int(5e11)) bufN.resolution = resolution bufN.channels = max(A_B_channels) + 1 bufN.addarray(A_B_channels, A_B_timetags) # print aliceChannels[-20:],aliceTtags[-20:] # print bobChannels[-20:],bobTtags[-20:] # print A_B_channels[-20:],A_B_timetags[-20:] coincidences_before = (bufN.coincidences( (A_B_timetags[-1] - 1) * bufN.resolution, coincidence_window_radius)) # print "__BEFORE DELAYS-->\n",coincidences_before remade = remake_coincidence_matrix(coincidences_before) # print "__REMADE-->>\n",remade remade1 = array( [[(remade[0][0] + remade[0][1] + remade[1][0] + remade[1][1]) / sum(sum(remade)), (remade[0][2] + remade[0][3] + remade[1][2] + remade[1][3]) / sum(sum(remade))], [(remade[2][0] + remade[2][1] + remade[3][0] + remade[3][1]) / sum(sum(remade)), (remade[2][2] + remade[2][3] + remade[3][2] + remade[3][3]) / sum(sum(remade))]]) # # print array([ [(remade[0][0] + remade[0][1]+remade[1][0]+remade[1][1]), (remade[0][2] + remade[0][3]+remade[1][2]+remade[1][3])], # [(remade[2][0] + remade[2][1]+remade[3][0]+remade[3][1]), (remade[2][2] + remade[2][3]+remade[3][2]+remade[3][3])] # ]) print "", remade[2][2], remade[3][3] # print "__CONTRIBUTION-->>\n", remade1 # # # # # a_laser_string = laser(aliceTtags[aliceChannels==3], resolution, coincidence_window_radius) # print "Coincidences without delays",len(intersect1d(a_laser_string,bobTtags[bobChannels == 7]))/float(len(bobTtags[bobChannels == 7])) # print "number of 0 channels and number of channel 4",len(A_B_timetags[A_B_channels == 0]),len(A_B_timetags[A_B_channels == 4]) # print "Coincidences between 0 and 4 by Laurynas: ", get_coincidences(A_B_timetags, A_B_channels, 0, 4, coincidence_window_radius*2/bufN.resolution) # print "That's it" # 1.9e-7 biggest u can make and still get correlations this corresponds to 1458 bins in diameter of coincidence window # UPDATE: actaully you can take smaller fraction of the strings to determine delays but then you need to increase coincidence window delays = zeros(7) k = 0 for i, j in zip(channels1, channels2): delays[i] = getDelay(bufN, i, j, delaymax=delay_max, time=(A_B_timetags[-1] - 1) * bufN.resolution) # delays[i] = getDelay(bufN,i,j,delaymax=coincidence_window_radius,time=5.0) # print delays[i] k += 1 delays1 = zeros((len(channels1), len(channels2))) delays2 = zeros((len(channels1), len(channels2))) # # for j in range(len(delays1)): # for i in range(len(delays2)): # delays2[j][i] = getDelay(bufN,channels1[j],channels2[i], delaymax=delay_max,time=(A_B_timetags[-1]-1)*bufN.resolution) # # #Next, set all of delays for channels1 # for j in range(len(delays2)): # for i in range(len(delays1)): # delays1[j][i] = getDelay(bufN,channels1[i],channels2[j], delaymax=delay_max,time=(A_B_timetags[-1]-1)*bufN.resolution) delays1 = delays1 / bufN.resolution delays2 = delays2 / bufN.resolution # print "DIRECT_____>",(delays/bufN.resolution) # # print "MATRIX for alice_____>",(delays1) # print "MATRIX for bob_____>",(delays2) # # for i in range(len(channels1)): # for j in range(len(channels2)-1): # print channels2[j],"-",channels2[j+1],": ",delays1[i][j]-delays1[i][j+1] # sys.stdout.flush() # print "will now plotting corellations to check if it looks good." # return check_correlations(aliceTtags,aliceChannels,bobTtags,bobChannels,resolution, A_B_timetags.astype(uint64), A_B_channels, channels1, channels2,delays/bufN.resolution, coincidence_window_radius,coincidences_before, delay_max,dic,l,remade[2][2],remade[3][3]) # # print("Saving delays to file.") save("./resultsLaurynas/Delays/delays.npy", delays / bufN.resolution)
#Run UQDinterface #args = ['sudo', '../../CppDemo/UQDinterface', '&'] #args = ['sudo', 'bash','launch.sh'] #f = open('test','w') #p = subprocess.Popen(args,stdout=f) #p = subprocess.Popen(args) print "The process ID is:" #print p.pid+1 # p.pid is the PID for the new shell. p.pid is the PID for UQDinterface in the new shell #print p.pid+2 #time.sleep(1) #ttnumber = int(raw_input("Time tagger to open:")) ttnumber = ttag.getfreebuffer() - 1 #buf = ttag.TTBuffer(ttnumber) #Opens the buffer buf = ttag.TTBuffer(0) #Opens the buffer print "Channels:", buf.channels print "Resolution:", buf.resolution print "Datapoints:", buf.datapoints print "Buffer size:", buf.size() currentTag = 1 lastTag = 0 biasList = np.array([x for x in range(8)]) #biasList = biasList[biasList == 7] startOutter = 120 startInner = 120 numPatterns = 42 step = 2
#If you want to dump by time, set to True, if dump by datapoints, set to False dumpByTime = False #Amount to dump - #if dumpyByTime is True, the number of seconds to dump, if False, the number of datapoints\ dumpamt = -1 buffernumber = 2 filename = "C:/Users/kwiat/Desktop/dumpedDATA.csv" from pylab import * import ttag print "Writing File: \"" + filename + "\"" print "Amount to dump:", dumpamt try: x = ttag.TTBuffer(buffernumber) #print if (dumpByTime): (c, t) = x(dumpamt) else: if (dumpamt == -1): dumpamt = len(x) print "Set Dump Amount:", dumpamt (c, t) = x[-int(dumpamt):] savetxt(filename, (c, t)) except Exception, e: print e raw_input()
def startTagger(): ttnumber = ttag.getfreebuffer()-1 print "ttnumber: ", ttnumber buf = ttag.TTBuffer(ttnumber) #Opens the buffer return buf
def polarizationPlot(polA, polB): figure() suptitle("Polarization Channels") for i in range(4): subplot(2, 2, i + 1) title("Channel " + str(1 + i)) v = polA[polB == i] bar([1, 2, 3, 4], array([sum(v == 0), sum(v == 1), sum(v == 2), sum(v == 3)], dtype=double) / float(len(v))) #if (i==0): # legend() show() if (__name__ == "__main__"): aliceChannels = [0, 1, 2, 3] bobChannels = [4, 5, 6, 7] binsize = 1 / (32 * 120.0e6) bufAlice = ttag.TTBuffer(1) plotAutocorrelations(bufAlice, ymax=3000, bins=10000) plotABCorrelations(bufAlice, aliceChannels, bobChannels, bins=60, pulsebin=binsize)
def runExperiment(threshLevels): currentTag = 1 lastTag = 0 delays = -1 * np.array([ 0, 0, 0, 0, 0, 0, 0, 0, 5e-9, 5e-9, 5e-9, 5e-9, 5e-9, 5e-9, 5e-9, 5e-9 ]) data = np.empty([1, 16]) biasList = np.array([x for x in range(8)]) # biasList = biasList[biasList == 0] outmsg = 'VOLT %f' % float(V) for i in biasList: sim.conn(i + 1) sim.write('OPON') sim.write(outmsg) sim.write('xyz') time.sleep(1) #Quick test to see if settle time an issue for level in threshLevels: writeSH(level) p = launch() print "The process ID is:" print p.pid + 2 time.sleep(1) ttnumber = ttag.getfreebuffer() - 1 buf = ttag.TTBuffer(ttnumber) #Opens the buffer print "Channels:", buf.channels print "Resolution:", buf.resolution print "Datapoints:", buf.datapoints print "Buffer size:", buf.size() buf.start() time.sleep(Tacq + 0.5) buf.stop() try: xx = buf(Tacq) # an array of the last 1 seconds worth of data currentTag = xx[1][-1] except: print "Can't run buf(Tacq) code" y = buf.singles(Tacq) for i in range(8): print "Row %d singles: " % (i + 1) print y[i] for i in range(8): print "Col %d singles: " % (i + 1) print y[i + 8] print "lastTag, currentTag:" print lastTag, currentTag if currentTag == lastTag: data[0, :] = 0 else: data[0, :] = y if not currentTag == 1: lastTag = currentTag np.savetxt(fintcnts, data, fmt='%0.2f') kill(p) fintcnts.flush() fintcnts.close() for i in biasList: sim.conn(i + 1) sim.write('VOLT 0') sim.write('OPOF') sim.write('xyz') time.sleep(.5) sim.meter.loc()
def startBuffer(): bufNum = ttag.getfreebuffer() - 1 buf = ttag.TTBuffer(bufNum) buf.start() time.sleep(1) return buf
@author: qittlab """ import ttag import numpy as np import random import time import matplotlib.pyplot as plt # Load fake data into buffer. if True: bufNum = ttag.getfreebuffer() bufSize = 100000000 buf = ttag.TTBuffer(bufNum, create=True, datapoints=bufSize) buf.resolution = 156e-12 buf.channels = 16 res = buf.resolution rate = 10e-6 dr = 50e-9 delay = int(2e-9 / res) tag = 0 buf.add(random.randint(0, 8), tag) buf.add(random.randint(8, 16), tag) to = time.time() while (buf[-1][1] <= 1.2): #print buf[-1][1] tag += random.randint(int((rate - dr) / res), int((rate + dr) / res))
# is this needed anymore? SN, May 17, 2014 #args = ['sudo', 'bash','launch.sh'] #f = open('test','w') #process = subprocess.Popen(args,stdout=f) #print "The process ID is:" #print process.pid+1 # p.pid is the PID for the new shell. p.pid is the PID for UQDinterface in the new shell #print process.pid+2 #time.sleep(1) #ttnumber = int(raw_input("Time tagger to open:")) if False: # For using real data from ttager ttnumber = ttag.getfreebuffer() - 1 print "ttnumber: ", ttnumber buf = ttag.TTBuffer(ttnumber) #Opens the buffer buf.start() time.sleep(1) if True: # For using fake data, manually added to buffer bufNum = ttag.getfreebuffer() print "bufNum", bufNum bufSize = 100000000 buf = ttag.TTBuffer(bufNum, create=True, datapoints=bufSize) buf.resolution = 156e-12 buf.channels = 16 res = buf.resolution rate = 4e-6 dr = 50e-9 delay = int(2e-9 / res)