def do_gui(self, line): """Open the ROOT results browser""" if not guiAvailable: print "No GUI available (missing ROOT library)" return if self.window: return self.window = PxarGui(ROOT.gClient.GetRoot(), 800, 800)
def __init__(self, api, gui): cmd.Cmd.__init__(self) self.fullOutput = False self.prompt = "pxarCore =>> " self.intro = "Welcome to the pxar core console!" ## defaults to None self.api = api self.window = None if (gui and guiAvailable): self.window = PxarGui(ROOT.gClient.GetRoot(), 800, 800) elif (gui and not guiAvailable): print "No GUI available (missing ROOT library)"
def do_gui(self, line): """Open the ROOT results browser""" if not guiAvailable: print "No GUI available (missing ROOT library)" return if self.window: return self.window = PxarGui( ROOT.gClient.GetRoot(), 800, 800 )
def do_latencyScan(self, minlatency=50, maxlatency=100, triggers=10, triggersignal="extern"): """ do_latencyScan [min] [max] [triggers] [signal]: scan the trigger latency from min to max with set number of triggers)""" self.api.testAllPixels(0, None) self.api.HVon() latencyScan = [] print "latency \tyield" # loop over latency for latency in range(minlatency, maxlatency): delay = {} delay["triggerlatency"] = latency self.api.setTestboardDelays(delay) self.api.daqTriggerSource(triggersignal) self.api.daqStart() nHits = 0 nTriggers = 0 #loop until you find maxTriggers while nTriggers < triggers: try: data = self.api.daqGetEvent() if len(data.pixels) > 0: nHits += 1 nTriggers += 1 except RuntimeError: pass hitYield = 100 * nHits / triggers latencyScan.append(hitYield) print '{0:03d}'.format(latency), "\t", '{0:3.0f}%'.format(hitYield) self.api.daqStop() if (self.window): self.window = PxarGui(ROOT.gClient.GetRoot(), 1000, 800) plot = Plotter.create_tgraph(latencyScan, "latency scan", "trigger latency", "evt/trig [%]", minlatency) self.window.histos.append(plot) self.window.update()
def __init__(self, api, gui): cmd.Cmd.__init__(self) self.fullOutput=False self.prompt = "pxarCore =>> " self.intro = "Welcome to the pxar core console!" ## defaults to None self.api = api self.window = None if(gui and guiAvailable): self.window = PxarGui(ROOT.gClient.GetRoot(),800,800)
def do_wbcScan(self, minWBC=90, maxWBC=255, maxTriggers=10, triggersignal="extern"): """ do_wbcScan [minWBC] [maxWBC] [maxTriggers] [signal]: sets the values of wbc from minWBC until it finds the wbc which has more than 90% filled events or it reaches 255 (default minWBC 90)""" self.api.daqTriggerSource(triggersignal) self.api.HVon() wbcScan = [] print "wbc \tyield" # loop over wbc for wbc in range(minWBC, maxWBC): self.api.setDAC("wbc", wbc) self.api.daqStart() nHits = 0 nTriggers = 0 #loop until you find maxTriggers while nTriggers < maxTriggers: try: data = self.api.daqGetEvent() if len(data.pixels) > 0: nHits += 1 nTriggers += 1 except RuntimeError: pass hitYield = 100 * nHits / maxTriggers wbcScan.append(hitYield) print '{0:03d}'.format(wbc), "\t", '{0:3.0f}%'.format(hitYield) self.api.daqStop() if (self.window): self.window = PxarGui(ROOT.gClient.GetRoot(), 1000, 800) plot = Plotter.create_tgraph(wbcScan, "wbc scan", "wbc", "evt/trig [%]", minWBC) self.window.histos.append(plot) self.window.update()
def do_latencyScan(self, minlatency = 50, maxlatency = 100, triggers = 10, triggersignal = "extern"): """ do_latencyScan [min] [max] [triggers] [signal]: scan the trigger latency from min to max with set number of triggers)""" self.api.testAllPixels(0,None) self.api.HVon(); latencyScan = [] print "latency \tyield" # loop over latency for latency in range (minlatency,maxlatency): delay = {} delay["triggerlatency"] = latency self.api.setTestboardDelays(delay) self.api.daqTriggerSource(triggersignal) self.api.daqStart() nHits = 0 nTriggers = 0 #loop until you find maxTriggers while nTriggers < triggers: try: data = self.api.daqGetEvent() if len(data.pixels) > 0: nHits += 1 nTriggers += 1 except RuntimeError: pass hitYield = 100*nHits/triggers latencyScan.append(hitYield) print '{0:03d}'.format(latency),"\t", '{0:3.0f}%'.format(hitYield) self.api.daqStop() if(self.window): self.window = PxarGui( ROOT.gClient.GetRoot(), 1000, 800 ) plot = Plotter.create_tgraph(latencyScan, "latency scan", "trigger latency", "evt/trig [%]", minlatency) self.window.histos.append(plot) self.window.update()
def do_wbcScan(self, minWBC = 90, maxWBC = 255, maxTriggers = 10, triggersignal = "extern"): """ do_wbcScan [minWBC] [maxWBC] [maxTriggers] [signal]: sets the values of wbc from minWBC until it finds the wbc which has more than 90% filled events or it reaches 255 (default minWBC 90)""" self.api.daqTriggerSource(triggersignal) self.api.HVon(); wbcScan = [] print "wbc \tyield" # loop over wbc for wbc in range (minWBC,maxWBC): self.api.setDAC("wbc", wbc) self.api.daqStart() nHits = 0 nTriggers = 0 #loop until you find maxTriggers while nTriggers < maxTriggers: try: data = self.api.daqGetEvent() if len(data.pixels) > 0: nHits += 1 nTriggers += 1 except RuntimeError: pass hitYield = 100*nHits/maxTriggers wbcScan.append(hitYield) print '{0:03d}'.format(wbc),"\t", '{0:3.0f}%'.format(hitYield) self.api.daqStop() if(self.window): self.window = PxarGui( ROOT.gClient.GetRoot(), 1000, 800 ) plot = Plotter.create_tgraph(wbcScan, "wbc scan", "wbc", "evt/trig [%]", minWBC) self.window.histos.append(plot) self.window.update()
class PxarCoreCmd(cmd.Cmd): """Simple command processor for the pxar core API.""" def __init__(self, api, gui): cmd.Cmd.__init__(self) self.fullOutput=False self.prompt = "pxarCore =>> " self.intro = "Welcome to the pxar core console!" ## defaults to None self.api = api self.window = None if(gui and guiAvailable): self.window = PxarGui(ROOT.gClient.GetRoot(),800,800) def plot_eventdisplay(self,data): pixels = list() # Multiple events: if(isinstance(data,list)): if(not self.window): for evt in data: print evt return for evt in data: for px in evt.pixels: pixels.append(px) else: if(not self.window): print data return for px in data.pixels: pixels.append(px) self.plot_map(pixels,'Event Display',True) def plot_map(self,data,name,count=False): if(not self.window): print data return # Find number of ROCs present: module = False for px in data: if px.roc > 0: module = True break # Prepare new numpy matrix: d = zeros((416 if module else 52,160 if module else 80)) for px in data: xoffset = 52*(px.roc%8) if module else 0 yoffset = 80*int(px.roc/8) if module else 0 # Flip the ROCs upside down: y = (px.row + yoffset) if (px.roc < 8) else (2*yoffset - px.row - 1) # Reverse order of the upper ROC row: x = (px.column + xoffset) if (px.roc < 8) else (415 - xoffset - px.column) d[x][y] += 1 if count else px.value plot = Plotter.create_th2(d, 0, 415 if module else 51, 0, 159 if module else 79, name, 'pixels x', 'pixels y', name) self.window.histos.append(plot) self.window.update() def plot_1d(self,data,name,dacname,min,max): if(not self.window): print_data(self.fullOutput,data,(max-min)/len(data)) return # Prepare new numpy matrix: d = zeros(len(data)) for idac, dac in enumerate(data): if(dac): d[idac] = dac[0].value plot = Plotter.create_th1(d, min, max, name, dacname, name) self.window.histos.append(plot) self.window.update() def plot_2d(self,data,name,dac1,step1,min1,max1,dac2,step2,min2,max2): if(not self.window): for idac, dac in enumerate(data): dac1 = min1 + (idac/((max2-min2)/step2+1))*step1 dac2 = min2 + (idac%((max2-min2)/step2+1))*step2 s = "DACs " + str(dac1) + ":" + str(dac2) + " - " for px in dac: s += str(px) print s return # Prepare new numpy matrix: bins1 = (max1-min1)/step1+1 bins2 = (max2-min2)/step2+1 d = zeros((bins1,bins2)) for idac, dac in enumerate(data): if(dac): bin1 = (idac/((max2-min2)/step2+1)) bin2 = (idac%((max2-min2)/step2+1)) d[bin1][bin2] = dac[0].value plot = Plotter.create_th2(d, min1, max1, min2, max2, name, dac1, dac2, name) self.window.histos.append(plot) self.window.update() def do_EOF(self, line): """ clean exit when receiving EOF (Ctrl-D) """ return True def do_gui(self, line): """Open the ROOT results browser""" if not guiAvailable: print "No GUI available (missing ROOT library)" return if self.window: return self.window = PxarGui( ROOT.gClient.GetRoot(), 800, 800 ) def do_switchFullOutput(self, line): """Switch between full and suppressed output of all pixels""" if self.fullOutput: set_printoptions(threshold=1000) self.fullOutput = False else: set_printoptions(threshold=nan) self.fullOutput = True @arity(0,0,[]) # decorator for argument verification defined in pxar_helpers.py def do_getVersion(self): """getVersion: returns the pxarcore library version""" print self.api.getVersion() def complete_getVersion(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getVersion.__doc__, ''] @arity(0,0,[]) def do_status(self): """status: returns the pxarcore library status""" print self.api.status() def complete_status(self, text, line, start_index, end_index): # return help for the cmd return [self.do_status.__doc__, ''] @arity(1,1,[str]) def do_flashTB(self, filename): """flashTB [filename]: flash the DTB with new firmware""" self.api.flashTB(filename) def complete_flashTB(self, text, line, start_index, end_index): # tab-completion for the file path: try: # remove specific delimeters from the readline parser # to allow completion of filenames with dashes import readline delims = readline.get_completer_delims( ) delims = delims.replace('-', '') readline.set_completer_delims(delims) except ImportError: pass return get_possible_filename_completions(extract_full_argument(line,end_index)) @arity(1,1,[str]) def do_loadscript(self, filename): """loadscript [filename]: loads a list of commands to be executed on the pxar cmdline""" try: f = open(filename) except IOError: print "Error: cannot open file '" + filename + "'" try: for line in f: if not line.startswith("#") and not line.isspace(): print line.replace('\n', ' ').replace('\r', '') self.onecmd(line) finally: f.close() def complete_loadscript(self, text, line, start_index, end_index): # tab-completion for the file path: try: # remove specific delimeters from the readline parser # to allow completion of filenames with dashes import readline delims = readline.get_completer_delims( ) delims = delims.replace('-', '') readline.set_completer_delims(delims) except ImportError: pass return get_possible_filename_completions(extract_full_argument(line,end_index)) @arity(0,0,[]) def do_HVon(self): """HVon: switch High voltage for sensor bias on""" self.api.HVon() def complete_HVon(self, text, line, start_index, end_index): # return help for the cmd return [self.do_HVon.__doc__, ''] @arity(0,0,[]) def do_Poff(self): """Pon: switch DTB power output off""" self.api.Poff() def complete_Poff(self, text, line, start_index, end_index): # return help for the cmd return [self.do_Poff.__doc__, ''] @arity(0,0,[]) def do_Pon(self): """Pon: switch DTB power output on""" self.api.Pon() def complete_Pon(self, text, line, start_index, end_index): # return help for the cmd return [self.do_Pon.__doc__, ''] @arity(0,0,[]) def do_HVoff(self): """HVoff: switch High voltage for sensor bias off""" self.api.HVoff() def complete_HVoff(self, text, line, start_index, end_index): # return help for the cmd return [self.do_HVoff.__doc__, ''] @arity(0,0,[]) def do_getTBia(self): """getTBia: returns analog DTB current""" print "Analog Current: ", (self.api.getTBia()*1000), " mA" def complete_getTBia(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTBia.__doc__, ''] @arity(0,0,[]) def do_getTBva(self): """getTBva: returns analog DTB voltage""" print "Analog Voltage: ", self.api.getTBva(), " V" def complete_getTBva(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTBva.__doc__, ''] @arity(0,0,[]) def do_getTBid(self): """getTBid: returns digital DTB current""" print "Digital Current: ", (self.api.getTBid()*1000), " mA" def complete_getTBid(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTBid.__doc__, ''] @arity(0,0,[]) def do_getTBvd(self): """getTBvd: returns digital DTB voltage""" print "Digital Voltage: ", self.api.getTBvd(), " V" def complete_getTBvd(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTBvd.__doc__, ''] @arity(1,1,[int]) def do_setExternalClock(self, enable): """setExternalClock [enable]: enables the external DTB clock input, switches off the internal clock. Only switches if external clock is present.""" if self.api.setExternalClock(enable) is True: print "Switched to " + ("external" if enable else "internal") + " clock." else: print "Could not switch to " + ("external" if enable else "internal") + " clock!" def complete_setExternalClock(self, text, line, start_index, end_index): # return help for the cmd return [self.do_setExternalClock.__doc__, ''] @arity(3,3,[int,int,int]) def do_setClockStretch(self, src, delay, width): """setClockStretch [src] [delay] [width]: enables the clock stretch mechanism with the parameters given.""" self.api.setClockStretch(src,delay,width) def complete_setClockStretch(self, text, line, start_index, end_index): # return help for the cmd return [self.do_setClockStretch.__doc__, ''] @arity(0,0,[]) def do_daqStart(self): """daqStart: starts a new DAQ session""" self.api.daqStart() def complete_daqStart(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqStart.__doc__, ''] @arity(0,0,[]) def do_daqStatus(self): """daqStatus: reports status of the running DAQ session""" if self.api.daqStatus(): print "DAQ session is fine" else: print "DAQ session returns faulty state" def complete_daqStatus(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqStatus.__doc__, ''] @arity(0,0,[]) def do_daqStop(self): """daqStop: stops the running DAQ session""" self.api.daqStop() def complete_daqStop(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqStop.__doc__, ''] @arity(1,2,[int, int]) def do_daqTrigger(self, ntrig, period = 0): """daqTrigger [ntrig] [period = 0]: sends ntrig patterns to the device""" self.api.daqTrigger(ntrig,period) def complete_daqTrigger(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqTrigger.__doc__, ''] @arity(1,1,[int]) def do_daqTriggerLoop(self, period): """daqTriggerLoop [period]: starts trigger loop with given period (in BC/40MHz)""" self.api.daqTriggerLoop(period) def complete_daqTriggerLoop(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqTriggerLoop.__doc__, ''] @arity(0,0,[]) def do_daqTriggerLoopHalt(self): """daqTriggerLoopHalt: stops the trigger loop""" self.api.daqTriggerLoopHalt() def complete_daqTriggerLoopHalt(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqTriggerLoopHalt.__doc__, ''] @arity(0,0,[]) def do_daqGetEvent(self): """daqGetEvent: read one event from the event buffer""" data = self.api.daqGetEvent() self.plot_eventdisplay(data) def complete_daqGetEvent(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqGetEvent.__doc__, ''] @arity(0,0,[]) def do_daqGetEventBuffer(self): """daqGetEventBuffer: read all decoded events from the DTB buffer""" data = self.api.daqGetEventBuffer() self.plot_eventdisplay(data) def complete_daqGetEventBuffer(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqGetEventBuffer.__doc__, ''] @arity(0,0,[]) def do_daqGetRawEvent(self): """daqGetRawEvent: read one raw event from the event buffer""" dat = self.api.daqGetRawEvent() s = "" for i in dat: s += '{:03x}'.format(i) + " " print s def complete_daqGetRawEvent(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqGetRawEvent.__doc__, ''] @arity(0,0,[]) def do_daqGetBuffer(self): """daqGetBuffer: read full raw data DTB buffer""" dat = self.api.daqGetBuffer() s = "" for i in dat: if i & 0x0FF0 == 0x07f0: s += "\n" s += '{:04x}'.format(i) + " " print s def complete_daqGetBuffer(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqGetBuffer.__doc__, ''] @arity(0,0,[]) def do_daqGetReadback(self): """daqGetReadback: return all ROC readback values for the last DAQ session""" dat = self.api.daqGetReadback() for iroc, roc in enumerate(dat): print "ROC " + str(iroc) + ":" s = "" for i in roc: s += '{:04x}'.format(i) + " " print s def complete_daqGetReadback(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqGetReadback.__doc__, ''] @arity(0,2,[int, int]) def do_getEfficiencyMap(self, flags = 0, nTriggers = 10): """getEfficiencyMap [flags = 0] [nTriggers = 10]: returns the efficiency map""" data = self.api.getEfficiencyMap(flags,nTriggers) self.plot_map(data,"Efficiency") def complete_getEfficiencyMap(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getEfficiencyMap.__doc__, ''] @arity(0,2,[int, int]) def do_getPulseheightMap(self, flags = 0, nTriggers = 10): """getPulseheightMap [flags = 0] [nTriggers = 10]: returns the pulseheight map""" data = self.api.getPulseheightMap(flags,nTriggers) self.plot_map(data,"Pulseheight") def complete_getPulseheightMap(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getPulseheightMap.__doc__, ''] @arity(1,7,[str, int, int, int, int, int, int]) def do_getThresholdMap(self, dacname, dacstep = 1, dacmin = 0, dacmax = 255, threshold = 50, flags = 0, nTriggers = 10): """getThresholdMap [DAC name] [step size] [min] [max] [threshold] [flags = 0] [nTriggers = 10]: returns the threshold map for the given DAC""" data = self.api.getThresholdMap(dacname,dacstep,dacmin,dacmax,threshold,flags,nTriggers) self.plot_map(data,"Threshold " + dacname) def complete_getThresholdMap(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_getThresholdMap.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(4,6,[str, int, int, int, int, int]) def do_getPulseheightVsDAC(self, dacname, dacstep, dacmin, dacmax, flags = 0, nTriggers = 10): """getPulseheightVsDAC [DAC name] [step size] [min] [max] [flags = 0] [nTriggers = 10]: returns the pulseheight over a 1D DAC scan""" data = self.api.getPulseheightVsDAC(dacname, dacstep, dacmin, dacmax, flags, nTriggers) self.plot_1d(data,"Pulseheight",dacname,dacmin,dacmax) def complete_getPulseheightVsDAC(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_getPulseheightVsDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(4,6,[str, int, int, int, int, int]) def do_getEfficiencyVsDAC(self, dacname, dacstep, dacmin, dacmax, flags = 0, nTriggers = 10): """getEfficiencyVsDAC [DAC name] [step size] [min] [max] [flags = 0] [nTriggers = 10]: returns the efficiency over a 1D DAC scan""" data = self.api.getEfficiencyVsDAC(dacname, dacstep, dacmin, dacmax, flags, nTriggers) self.plot_1d(data,"Efficiency",dacname,dacmin,dacmax) def complete_getEfficiencyVsDAC(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_getEfficiencyVsDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(8,11,[str, int, int, int, str, int, int, int, int, int, int]) def do_getThresholdVsDAC(self, dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, threshold = 50, flags = 0, nTriggers = 10): """getThresholdVsDAC [DAC1 name] [step size 1] [min 1] [max 1] [DAC2 name] [step size 2] [min 2] [max 2] [threshold = 50] [flags = 0] [nTriggers = 10]: returns the threshold for DAC1 over a 1D DAC2 scan""" data = self.api.getThresholdVsDAC(dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, threshold, flags, nTriggers) self.plot_1d(data,"Threshold " + dac1name,dac2name,dac2min,dac2max) def complete_getThresholdVsDAC(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] elif text and len(line.split(" ")) == 6: # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if (len(line.split(" ")) > 2 and len(line.split(" ")) < 6) or len(line.split(" ")) > 6: # return help for the cmd return [self.do_getThresholdVsDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(8,10,[str, int, int, int, str, int, int, int, int, int]) def do_getPulseheightVsDACDAC(self, dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, flags = 0, nTriggers = 10): """getPulseheightVsDACDAC [DAC1 name] [step size 1] [min 1] [max 1] [DAC2 name] [step size 2] [min 2] [max 2] [flags = 0] [nTriggers = 10]: returns the pulseheight over a 2D DAC1-DAC2 scan""" data = self.api.getPulseheightVsDACDAC(dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, flags, nTriggers) self.plot_2d(data,"Pulseheight",dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max) def complete_getPulseheightVsDACDAC(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] elif text and len(line.split(" ")) == 6: # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if (len(line.split(" ")) > 2 and len(line.split(" ")) < 6) or len(line.split(" ")) > 6: # return help for the cmd return [self.do_getPulseheightVsDACDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(8,10,[str, int, int, int, str, int, int, int, int, int]) def do_getEfficiencyVsDACDAC(self, dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, flags = 0, nTriggers = 10): """getEfficiencyVsDACDAC [DAC1 name] [step size 1] [min 1] [max 1] [DAC2 name] [step size 2] [min 2] [max 2] [flags = 0] [nTriggers = 10]: returns the efficiency over a 2D DAC1-DAC2 scan""" data = self.api.getEfficiencyVsDACDAC(dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, flags, nTriggers) self.plot_2d(data,"Efficiency",dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max) def complete_getEfficiencyVsDACDAC(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] elif text and len(line.split(" ")) == 6: # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if (len(line.split(" ")) > 2 and len(line.split(" ")) < 6) or len(line.split(" ")) > 6: # return help for the cmd return [self.do_getEfficiencyVsDACDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(2,2,[str, int]) def do_setSignalMode(self, signal, mode): """setSignalMode [signal] [mode]: Set the DTB signal to given mode""" self.api.setSignalMode(signal, mode) def complete_setSignalMode(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [sig for sig in dacdict.getAllDTBNames() if sig.startswith(text)] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_setSignalMode.__doc__, ''] else: # return all signals return dacdict.getAllDTBNames() @arity(2,2,[str, str]) def do_SignalProbe(self, probe, name): """SignalProbe [probe] [name]: Switches DTB probe output [probe] to signal [name]""" self.api.SignalProbe(probe,name) def complete_SignalProbe(self, text, line, start_index, end_index): probes = ["d1","d2","a1","a2"] if len(line.split(" ")) <= 2: # first argument if text: # started to type # list matching entries return [pr for pr in probes if pr.startswith(text)] else: # list all probes return probes elif len(line.split(" ")) <= 3: # second argument p = "".join(line.split(" ")[1:2]) if text: # started to type if p.startswith("a"): return [pr for pr in probedict.getAllAnalogNames() if pr.startswith(text)] elif p.startswith("d"): return [pr for pr in probedict.getAllDigitalNames() if pr.startswith(text)] else: return [self.do_SignalProbe.__doc__, ''] else: # return all signals: if p.startswith("a"): return probedict.getAllAnalogNames() elif p.startswith("d"): return probedict.getAllDigitalNames() else: return [self.do_SignalProbe.__doc__, ''] else: # return help for the cmd return [self.do_SignalProbe.__doc__, ''] @arity(2,3,[str, int, int]) def do_setDAC(self, dacname, value, rocid = None): """setDAC [DAC name] [value] [ROCID]: Set the DAC to given value for given roc ID""" self.api.setDAC(dacname, value, rocid) def complete_setDAC(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_setDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(1,1,[str]) def do_getDACRange(self, dacname): """getDACRange [DAC name]: Get the valid value range for the given DAC""" print "DAC ", dacname, ": 0 -", self.api.getDACRange(dacname) def complete_getDACRange(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_getDACRange.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(2,3,[str, int, int]) def do_setTbmReg(self, regname, value, tbmid = None): """setTbmReg [register name] [value] [TBM ID]: Set the register to given value for given TBM ID""" self.api.setTbmReg(regname, value, tbmid) def complete_setTbmReg(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [reg for reg in dacdict.getAllTBMNames() if reg.startswith(text)] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_setTbmReg.__doc__, ''] else: # return all registers return dacdict.getAllTBMNames() @arity(1,1,[int]) def do_getTbmDACs(self, tbmid): """getTbmDACs [id]: get the currently programmed register settings for TBM #id""" print self.api.getTbmDACs(tbmid) def complete_getTbmDACs(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTbmDACs.__doc__, ''] @arity(0,0,[]) def do_info(self): """info: print pxarCore DUT info""" self.api.info() def complete_info(self, text, line, start_index, end_index): # return help for the cmd return [self.do_info.__doc__, ''] @arity(2,2,[int, int]) def do_setROCEnable(self, rocid, enable): """setROCEnable [ROC id] [enable]: enable/disable the ROC with given ID""" self.api.setROCEnable(rocid,enable) def complete_setROCEnable(self, text, line, start_index, end_index): # return help for the cmd return [self.do_setROCEnable.__doc__, ''] @arity(2,2,[int, int]) def do_setTBMEnable(self, tbmid, enable): """setTBMEnable [ROC id] [enable]: enable/disable the ROC with given ID""" self.api.setTBMEnable(tbmid,enable) def complete_setTBMEnable(self, text, line, start_index, end_index): # return help for the cmd return [self.do_setTBMEnable.__doc__, ''] @arity(3,4,[int, int, int, int]) def do_testPixel(self, col, row, enable, rocid = None): """testPixel [column] [row] [enable] [ROC id]: enable/disable testing of pixel""" self.api.testPixel(col,row,enable,rocid) def complete_testPixel(self, text, line, start_index, end_index): # return help for the cmd return [self.do_testPixel.__doc__, ''] @arity(1,2,[int, int]) def do_testAllPixels(self, enable, rocid = None): """testAllPixels [enable] [rocid]: enable/disable tesing for all pixels on given ROC""" self.api.testAllPixels(enable,rocid) def complete_testAllPixels(self, text, line, start_index, end_index): # return help for the cmd return [self.do_testAllPixels.__doc__, ''] @arity(3,4,[int, int, int, int]) def do_maskPixel(self, col, row, enable, rocid = None): """maskPixel [column] [row] [enable] [ROC id]: mask/unmask pixel""" self.api.maskPixel(col,row,enable,rocid) def complete_maskPixel(self, text, line, start_index, end_index): # return help for the cmd return [self.do_maskPixel.__doc__, ''] @arity(1,2,[int, int]) def do_maskAllPixels(self, enable, rocid = None): """maskAllPixels [enable] [rocid]: mask/unmask all pixels on given ROC""" self.api.maskAllPixels(enable,rocid) def complete_maskAllPixels(self, text, line, start_index, end_index): # return help for the cmd return [self.do_maskAllPixels.__doc__, ''] @arity(1,1,[int]) def do_getNEnabledPixels(self, rocid): """getNEnabledPixels [ROC id]: returns number of enabled pixels for ROC id""" print self.api.getNEnabledPixels(rocid) def complete_getNEnabledPixels(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getNEnabledPixels.__doc__, ''] @arity(0,0,[]) def do_getTbmType(self): """getTbmType: returns device code for the TBM programmed""" print self.api.getTbmType() def complete_getTbmType(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTbmType.__doc__, ''] @arity(0,0,[]) def do_getRocType(self): """getRocType: returns device code for the ROCs programmed""" print self.api.getRocType() def complete_getRocType(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getRocType.__doc__, ''] @arity(1,1,[int]) def do_getNMaskedPixels(self, rocid): """getNMaskedPixels [ROC id]: returns number of masked pixels for ROC id""" print self.api.getNMaskedPixels(rocid) def complete_getNMaskedPixels(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getNMaskedPixels.__doc__, ''] def do_quit(self, arg): """quit: terminates the application""" sys.exit(1) # shortcuts do_q = do_quit
class PxarCoreCmd(cmd.Cmd): """Simple command processor for the pxar core API.""" def __init__(self, api, gui): cmd.Cmd.__init__(self) self.fullOutput=False self.prompt = "pxarCore =>> " self.intro = "Welcome to the pxar core console!" ## defaults to None self.api = api self.window = None if(gui and guiAvailable): self.window = PxarGui(ROOT.gClient.GetRoot(),800,800) elif(gui and not guiAvailable): print "No GUI available (missing ROOT library)" def plot_eventdisplay(self,data): pixels = list() # Multiple events: if(isinstance(data,list)): if(not self.window): for evt in data: print evt return for evt in data: for px in evt.pixels: pixels.append(px) else: if(not self.window): print data return for px in data.pixels: pixels.append(px) self.plot_map(pixels,'Event Display',True) def plot_map(self,data,name,count=False): if(not self.window): print data return # Find number of ROCs present: module = False for px in data: if px.roc > 0: module = True break # Prepare new numpy matrix: d = zeros((416 if module else 52,160 if module else 80)) for px in data: xoffset = 52*(px.roc%8) if module else 0 yoffset = 80*int(px.roc/8) if module else 0 # Flip the ROCs upside down: y = (px.row + yoffset) if (px.roc < 8) else (2*yoffset - px.row - 1) # Reverse order of the upper ROC row: x = (px.column + xoffset) if (px.roc < 8) else (415 - xoffset - px.column) d[x][y] += 1 if count else px.value plot = Plotter.create_th2(d, 0, 415 if module else 51, 0, 159 if module else 79, name, 'pixels x', 'pixels y', name) self.window.histos.append(plot) self.window.update() def plot_1d(self,data,name,dacname,min,max): if(not self.window): print_data(self.fullOutput,data,(max-min)/len(data)) return # Prepare new numpy matrix: d = zeros(len(data)) for idac, dac in enumerate(data): if(dac): d[idac] = dac[0].value plot = Plotter.create_th1(d, min, max, name, dacname, name) self.window.histos.append(plot) self.window.update() def plot_2d(self,data,name,dac1,step1,min1,max1,dac2,step2,min2,max2): if(not self.window): for idac, dac in enumerate(data): dac1 = min1 + (idac/((max2-min2)/step2+1))*step1 dac2 = min2 + (idac%((max2-min2)/step2+1))*step2 s = "DACs " + str(dac1) + ":" + str(dac2) + " - " for px in dac: s += str(px) print s return # Prepare new numpy matrix: bins1 = (max1-min1)/step1+1 bins2 = (max2-min2)/step2+1 d = zeros((bins1,bins2)) for idac, dac in enumerate(data): if(dac): bin1 = (idac/((max2-min2)/step2+1)) bin2 = (idac%((max2-min2)/step2+1)) d[bin1][bin2] = dac[0].value plot = Plotter.create_th2(d, min1, max1, min2, max2, name, dac1, dac2, name) self.window.histos.append(plot) self.window.update() def varyDelays(self,tindelay,toutdelay,verbose=False): self.api.setTestboardDelays({"tindelay":tindelay,"toutdelay":toutdelay}) self.api.daqStart() self.api.daqTrigger(1, 500) try: rawEvent = self.api.daqGetRawEvent() except RuntimeError: pass if verbose: print "raw Event:\t\t",rawEvent nCount = 0 for i in rawEvent: i = i & 0x0fff if i & 0x0800: i -= 4096 rawEvent[nCount] = i nCount += 1 if verbose: print "converted Event:\t",rawEvent self.api.daqStop() return rawEvent ########################################################################################################################## def do_EOF(self, line): """ clean exit when receiving EOF (Ctrl-D) """ return True def do_gui(self, line): """Open the ROOT results browser""" if not guiAvailable: print "No GUI available (missing ROOT library)" return if self.window: return self.window = PxarGui( ROOT.gClient.GetRoot(), 800, 800 ) def do_switchFullOutput(self, line): """Switch between full and suppressed output of all pixels""" if self.fullOutput: set_printoptions(threshold=1000) self.fullOutput = False else: set_printoptions(threshold=nan) self.fullOutput = True @arity(0,0,[]) # decorator for argument verification defined in pxar_helpers.py def do_getVersion(self): """getVersion: returns the pxarcore library version""" print self.api.getVersion() def complete_getVersion(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getVersion.__doc__, ''] @arity(0,0,[]) def do_status(self): """status: returns the pxarcore library status""" print self.api.status() def complete_status(self, text, line, start_index, end_index): # return help for the cmd return [self.do_status.__doc__, ''] @arity(1,1,[str]) def do_flashTB(self, filename): """flashTB [filename]: flash the DTB with new firmware""" self.api.flashTB(filename) def complete_flashTB(self, text, line, start_index, end_index): # tab-completion for the file path: try: # remove specific delimeters from the readline parser # to allow completion of filenames with dashes import readline delims = readline.get_completer_delims( ) delims = delims.replace('-', '') readline.set_completer_delims(delims) except ImportError: pass return get_possible_filename_completions(extract_full_argument(line,end_index)) @arity(1,1,[str]) def do_run(self, filename): """run [filename]: loads a list of commands to be executed on the pxar cmdline""" try: f = open(filename) except IOError: print "Error: cannot open file '" + filename + "'" try: for line in f: if not line.startswith("#") and not line.isspace(): print line.replace('\n', ' ').replace('\r', '') self.onecmd(line) finally: f.close() def complete_run(self, text, line, start_index, end_index): # tab-completion for the file path: try: # remove specific delimeters from the readline parser # to allow completion of filenames with dashes import readline delims = readline.get_completer_delims( ) delims = delims.replace('-', '') readline.set_completer_delims(delims) except ImportError: pass return get_possible_filename_completions(extract_full_argument(line,end_index)) @arity(0,0,[]) def do_HVon(self): """HVon: switch High voltage for sensor bias on""" self.api.HVon() def complete_HVon(self, text, line, start_index, end_index): # return help for the cmd return [self.do_HVon.__doc__, ''] @arity(0,0,[]) def do_Poff(self): """Pon: switch DTB power output off""" self.api.Poff() def complete_Poff(self, text, line, start_index, end_index): # return help for the cmd return [self.do_Poff.__doc__, ''] @arity(0,0,[]) def do_Pon(self): """Pon: switch DTB power output on""" self.api.Pon() def complete_Pon(self, text, line, start_index, end_index): # return help for the cmd return [self.do_Pon.__doc__, ''] @arity(0,0,[]) def do_HVoff(self): """HVoff: switch High voltage for sensor bias off""" self.api.HVoff() def complete_HVoff(self, text, line, start_index, end_index): # return help for the cmd return [self.do_HVoff.__doc__, ''] @arity(0,0,[]) def do_getTBia(self): """getTBia: returns analog DTB current""" print "Analog Current: ", (self.api.getTBia()*1000), " mA" def complete_getTBia(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTBia.__doc__, ''] @arity(0,0,[]) def do_getTBva(self): """getTBva: returns analog DTB voltage""" print "Analog Voltage: ", self.api.getTBva(), " V" def complete_getTBva(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTBva.__doc__, ''] @arity(0,0,[]) def do_getTBid(self): """getTBid: returns digital DTB current""" print "Digital Current: ", (self.api.getTBid()*1000), " mA" def complete_getTBid(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTBid.__doc__, ''] @arity(0,0,[]) def do_getTBvd(self): """getTBvd: returns digital DTB voltage""" print "Digital Voltage: ", self.api.getTBvd(), " V" def complete_getTBvd(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTBvd.__doc__, ''] @arity(1,1,[int]) def do_setExternalClock(self, enable): """setExternalClock [enable]: enables the external DTB clock input, switches off the internal clock. Only switches if external clock is present.""" if self.api.setExternalClock(enable) is True: print "Switched to " + ("external" if enable else "internal") + " clock." else: print "Could not switch to " + ("external" if enable else "internal") + " clock!" def complete_setExternalClock(self, text, line, start_index, end_index): # return help for the cmd return [self.do_setExternalClock.__doc__, ''] @arity(3,3,[int,int,int]) def do_setClockStretch(self, src, delay, width): """setClockStretch [src] [delay] [width]: enables the clock stretch mechanism with the parameters given.""" self.api.setClockStretch(src,delay,width) def complete_setClockStretch(self, text, line, start_index, end_index): # return help for the cmd return [self.do_setClockStretch.__doc__, ''] @arity(0,0,[]) def do_daqStart(self): """daqStart: starts a new DAQ session""" self.api.daqStart() def complete_daqStart(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqStart.__doc__, ''] @arity(0,0,[]) def do_daqStatus(self): """daqStatus: reports status of the running DAQ session""" if self.api.daqStatus(): print "DAQ session is fine" else: print "DAQ session returns faulty state" def complete_daqStatus(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqStatus.__doc__, ''] @arity(1,1,[str]) def do_daqTriggerSource(self, source): """daqTriggerSource: select the trigger source to be used for the DAQ session""" if self.api.daqTriggerSource(source): print "Trigger source \"" + source + "\" selected." else: print "DAQ returns faulty state." def complete_daqTriggerSource(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqTriggerSource.__doc__, ''] @arity(1,1,[str]) def do_daqSingleSignal(self, signal): """daqSingleSignal [signal]: send a single signal to the DUT""" if self.api.daqSingleSignal(signal): print "Trigger signal \"" + signal + "\" sent to DUT." else: print "Trigger signal lookup failed." def complete_daqSingleSignal(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqSingleSignal.__doc__, ''] @arity(0,0,[]) def do_daqStop(self): """daqStop: stops the running DAQ session""" self.api.daqStop() def complete_daqStop(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqStop.__doc__, ''] @arity(1,2,[int, int]) def do_daqTrigger(self, ntrig, period = 0): """daqTrigger [ntrig] [period = 0]: sends ntrig patterns to the device""" self.api.daqTrigger(ntrig,period) def complete_daqTrigger(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqTrigger.__doc__, ''] @arity(1,1,[int]) def do_daqTriggerLoop(self, period): """daqTriggerLoop [period]: starts trigger loop with given period (in BC/40MHz)""" self.api.daqTriggerLoop(period) def complete_daqTriggerLoop(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqTriggerLoop.__doc__, ''] @arity(0,0,[]) def do_daqTriggerLoopHalt(self): """daqTriggerLoopHalt: stops the trigger loop""" self.api.daqTriggerLoopHalt() def complete_daqTriggerLoopHalt(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqTriggerLoopHalt.__doc__, ''] @arity(0,0,[]) def do_daqGetEvent(self): """daqGetEvent: read one event from the event buffer""" try: data = self.api.daqGetEvent() self.plot_eventdisplay(data) except RuntimeError: pass def complete_daqGetEvent(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqGetEvent.__doc__, ''] @arity(0,0,[]) def do_daqGetEventBuffer(self): """daqGetEventBuffer: read all decoded events from the DTB buffer""" try: data = self.api.daqGetEventBuffer() self.plot_eventdisplay(data) except RuntimeError: pass def complete_daqGetEventBuffer(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqGetEventBuffer.__doc__, ''] @arity(0,0,[]) def do_daqGetRawEvent(self): """daqGetRawEvent: read one raw event from the event buffer""" try: dat = self.api.daqGetRawEvent() s = "" for i in dat: s += '{0:03x}'.format(i) + " " print s except RuntimeError: pass def complete_daqGetRawEvent(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqGetRawEvent.__doc__, ''] @arity(0,0,[]) def do_getStatistics(self): """getStatistics: print full statistics accumulated during last DAQ session""" dat = self.api.getStatistics() print dat def complete_getStatistics(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getStatistics.__doc__, ''] @arity(0,0,[]) def do_daqGetBuffer(self): """daqGetBuffer: read full raw data DTB buffer""" try: dat = self.api.daqGetBuffer() s = "" for i in dat: if i & 0x0FF0 == 0x07f0: s += "\n" s += '{:04x}'.format(i) + " " print s except RuntimeError: pass def complete_daqGetBuffer(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqGetBuffer.__doc__, ''] @arity(0,0,[]) def do_daqGetReadback(self): """daqGetReadback: return all ROC readback values for the last DAQ session""" dat = self.api.daqGetReadback() for iroc, roc in enumerate(dat): print "ROC " + str(iroc) + ": (" + str(len(roc)) + " values)" s = "" for i in roc: s += '{:04x}'.format(i) + " " print s def complete_daqGetReadback(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqGetReadback.__doc__, ''] @arity(0,2,[int, int]) def do_getEfficiencyMap(self, flags = 0, nTriggers = 10): """getEfficiencyMap [flags = 0] [nTriggers = 10]: returns the efficiency map""" data = self.api.getEfficiencyMap(flags,nTriggers) self.plot_map(data,"Efficiency") def complete_getEfficiencyMap(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getEfficiencyMap.__doc__, ''] @arity(0,2,[int, int]) def do_getPulseheightMap(self, flags = 0, nTriggers = 10): """getPulseheightMap [flags = 0] [nTriggers = 10]: returns the pulseheight map""" data = self.api.getPulseheightMap(flags,nTriggers) self.plot_map(data,"Pulseheight") def complete_getPulseheightMap(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getPulseheightMap.__doc__, ''] @arity(1,7,[str, int, int, int, int, int, int]) def do_getThresholdMap(self, dacname, dacstep = 1, dacmin = 0, dacmax = 255, threshold = 50, flags = 0, nTriggers = 10): """getThresholdMap [DAC name] [step size] [min] [max] [threshold] [flags = 0] [nTriggers = 10]: returns the threshold map for the given DAC""" data = self.api.getThresholdMap(dacname,dacstep,dacmin,dacmax,threshold,flags,nTriggers) self.plot_map(data,"Threshold " + dacname) def complete_getThresholdMap(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_getThresholdMap.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(4,6,[str, int, int, int, int, int]) def do_getPulseheightVsDAC(self, dacname, dacstep, dacmin, dacmax, flags = 0, nTriggers = 10): """getPulseheightVsDAC [DAC name] [step size] [min] [max] [flags = 0] [nTriggers = 10]: returns the pulseheight over a 1D DAC scan""" data = self.api.getPulseheightVsDAC(dacname, dacstep, dacmin, dacmax, flags, nTriggers) self.plot_1d(data,"Pulseheight",dacname,dacmin,dacmax) def complete_getPulseheightVsDAC(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_getPulseheightVsDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(4,6,[str, int, int, int, int, int]) def do_getEfficiencyVsDAC(self, dacname, dacstep, dacmin, dacmax, flags = 0, nTriggers = 10): """getEfficiencyVsDAC [DAC name] [step size] [min] [max] [flags = 0] [nTriggers = 10]: returns the efficiency over a 1D DAC scan""" data = self.api.getEfficiencyVsDAC(dacname, dacstep, dacmin, dacmax, flags, nTriggers) self.plot_1d(data,"Efficiency",dacname,dacmin,dacmax) def complete_getEfficiencyVsDAC(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_getEfficiencyVsDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(8,11,[str, int, int, int, str, int, int, int, int, int, int]) def do_getThresholdVsDAC(self, dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, threshold = 50, flags = 0, nTriggers = 10): """getThresholdVsDAC [DAC1 name] [step size 1] [min 1] [max 1] [DAC2 name] [step size 2] [min 2] [max 2] [threshold = 50] [flags = 0] [nTriggers = 10]: returns the threshold for DAC1 over a 1D DAC2 scan""" data = self.api.getThresholdVsDAC(dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, threshold, flags, nTriggers) self.plot_1d(data,"Threshold " + dac1name,dac2name,dac2min,dac2max) def complete_getThresholdVsDAC(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] elif text and len(line.split(" ")) == 6: # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if (len(line.split(" ")) > 2 and len(line.split(" ")) < 6) or len(line.split(" ")) > 6: # return help for the cmd return [self.do_getThresholdVsDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(8,10,[str, int, int, int, str, int, int, int, int, int]) def do_getPulseheightVsDACDAC(self, dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, flags = 0, nTriggers = 10): """getPulseheightVsDACDAC [DAC1 name] [step size 1] [min 1] [max 1] [DAC2 name] [step size 2] [min 2] [max 2] [flags = 0] [nTriggers = 10]: returns the pulseheight over a 2D DAC1-DAC2 scan""" data = self.api.getPulseheightVsDACDAC(dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, flags, nTriggers) self.plot_2d(data,"Pulseheight",dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max) def complete_getPulseheightVsDACDAC(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] elif text and len(line.split(" ")) == 6: # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if (len(line.split(" ")) > 2 and len(line.split(" ")) < 6) or len(line.split(" ")) > 6: # return help for the cmd return [self.do_getPulseheightVsDACDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(8,10,[str, int, int, int, str, int, int, int, int, int]) def do_getEfficiencyVsDACDAC(self, dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, flags = 0, nTriggers = 10): """getEfficiencyVsDACDAC [DAC1 name] [step size 1] [min 1] [max 1] [DAC2 name] [step size 2] [min 2] [max 2] [flags = 0] [nTriggers = 10]: returns the efficiency over a 2D DAC1-DAC2 scan""" data = self.api.getEfficiencyVsDACDAC(dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, flags, nTriggers) self.plot_2d(data,"Efficiency",dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max) def complete_getEfficiencyVsDACDAC(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] elif text and len(line.split(" ")) == 6: # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if (len(line.split(" ")) > 2 and len(line.split(" ")) < 6) or len(line.split(" ")) > 6: # return help for the cmd return [self.do_getEfficiencyVsDACDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(0,0,[]) def do_analogLevelScan(self): """analogLevelScan: scan the ADC levels of an analog ROC""" self.api.daqStart() self.api.daqTrigger(5000,500) plotdata = zeros(1024) try: while True: s = "" p = "" pos = -3 dat = self.api.daqGetRawEvent() for i in dat: i = i & 0x0fff # Remove PH from hits: if pos == 5: pos = 0 continue if i & 0x0800: i -= 4096 plotdata[500+i] += 1 pos += 1 except RuntimeError: pass plot = Plotter.create_th1(plotdata, -512, +512, "Address Levels", "ADC", "#") self.window.histos.append(plot) self.window.update() def complete_analogLevelScan(self, text, line, start_index, end_index): # return help for the cmd return [self.do_analogLevelScan.__doc__, ''] @arity(2,3,[str, str, int]) def do_setSignalMode(self, signal, mode, speed = 0): """setSignalMode [signal] [mode] [speed]: Set the DTB signal to given mode (normal, low, high, random). The [speed] parameter is only necessary for random signal mode.""" self.api.setSignalMode(signal, mode, speed) def complete_setSignalMode(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [sig for sig in dacdict.getAllDTBNames() if sig.startswith(text)] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_setSignalMode.__doc__, ''] else: # return all signals return dacdict.getAllDTBNames() @arity(2,2,[str, str]) def do_SignalProbe(self, probe, name): """SignalProbe [probe] [name]: Switches DTB probe output [probe] to signal [name]""" self.api.SignalProbe(probe,name) def complete_SignalProbe(self, text, line, start_index, end_index): probes = ["d1","d2","a1","a2"] if len(line.split(" ")) <= 2: # first argument if text: # started to type # list matching entries return [pr for pr in probes if pr.startswith(text)] else: # list all probes return probes elif len(line.split(" ")) <= 3: # second argument p = "".join(line.split(" ")[1:2]) if text: # started to type if p.startswith("a"): return [pr for pr in probedict.getAllAnalogNames() if pr.startswith(text)] elif p.startswith("d"): return [pr for pr in probedict.getAllDigitalNames() if pr.startswith(text)] else: return [self.do_SignalProbe.__doc__, ''] else: # return all signals: if p.startswith("a"): return probedict.getAllAnalogNames() elif p.startswith("d"): return probedict.getAllDigitalNames() else: return [self.do_SignalProbe.__doc__, ''] else: # return help for the cmd return [self.do_SignalProbe.__doc__, ''] @arity(2,3,[str, int, int]) def do_setDAC(self, dacname, value, rocid = None): """setDAC [DAC name] [value] [ROCID]: Set the DAC to given value for given roc ID""" self.api.setDAC(dacname, value, rocid) def complete_setDAC(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_setDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(2,3,[str, int, int]) def do_setTbmReg(self, regname, value, tbmid = None): """setTbmReg [Reg. name] [value] [TBMID]: Set the register to given value for given TBM ID""" self.api.setTbmReg(regname, value, tbmid) def complete_setTbmReg(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllTBMNames() if dac.startswith(text)] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_setTbmReg.__doc__, ''] else: # return all DACS return dacdict.getAllTBMNames() @arity(1,1,[str]) def do_getDACRange(self, dacname): """getDACRange [DAC name]: Get the valid value range for the given DAC""" print "DAC ", dacname, ": 0 -", self.api.getDACRange(dacname) def complete_getDACRange(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [dac for dac in dacdict.getAllROCNames() if dac.startswith(text)] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_getDACRange.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(2,3,[str, int, int]) def do_setTbmReg(self, regname, value, tbmid = None): """setTbmReg [register name] [value] [TBM ID]: Set the register to given value for given TBM ID""" self.api.setTbmReg(regname, value, tbmid) def complete_setTbmReg(self, text, line, start_index, end_index): if text and len(line.split(" ")) <= 2: # first argument and started to type # list matching entries return [reg for reg in dacdict.getAllTBMNames() if reg.startswith(text)] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_setTbmReg.__doc__, ''] else: # return all registers return dacdict.getAllTBMNames() @arity(1,1,[int]) def do_getTbmDACs(self, tbmid): """getTbmDACs [id]: get the currently programmed register settings for TBM #id""" print self.api.getTbmDACs(tbmid) def complete_getTbmDACs(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTbmDACs.__doc__, ''] @arity(0,0,[]) def do_info(self): """info: print pxarCore DUT info""" self.api.info() def complete_info(self, text, line, start_index, end_index): # return help for the cmd return [self.do_info.__doc__, ''] @arity(0,0,[]) def do_getEnabledRocIDs(self): """info: print ROC IDs of all enabled ROCs""" data = self.api.getEnabledRocIDs() print data def complete_getEnabledRocIDs(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getEnabledRocIDs.__doc__, ''] @arity(0,0,[]) def do_getEnabledRocI2Caddr(self): """info: print ROC IDs of all enabled ROCs""" data = self.api.getEnabledRocI2Caddr() print data def complete_getEnabledRocI2Caddr(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getEnabledRocI2Caddr.__doc__, ''] @arity(2,2,[int, int]) def do_setROCEnable(self, rocid, enable): """setROCEnable [ROC id] [enable]: enable/disable the ROC with given ID""" self.api.setROCEnable(rocid,enable) def complete_setROCEnable(self, text, line, start_index, end_index): # return help for the cmd return [self.do_setROCEnable.__doc__, ''] @arity(2,2,[int, int]) def do_setTBMEnable(self, tbmid, enable): """setTBMEnable [ROC id] [enable]: enable/disable the ROC with given ID""" self.api.setTBMEnable(tbmid,enable) def complete_setTBMEnable(self, text, line, start_index, end_index): # return help for the cmd return [self.do_setTBMEnable.__doc__, ''] @arity(3,4,[int, int, int, int]) def do_testPixel(self, col, row, enable, rocid = None): """testPixel [column] [row] [enable] [ROC id]: enable/disable testing of pixel""" self.api.testPixel(col,row,enable,rocid) def complete_testPixel(self, text, line, start_index, end_index): # return help for the cmd return [self.do_testPixel.__doc__, ''] @arity(1,2,[int, int]) def do_testAllPixels(self, enable, rocid = None): """testAllPixels [enable] [rocid]: enable/disable tesing for all pixels on given ROC""" self.api.testAllPixels(enable,rocid) def complete_testAllPixels(self, text, line, start_index, end_index): # return help for the cmd return [self.do_testAllPixels.__doc__, ''] @arity(3,4,[int, int, int, int]) def do_maskPixel(self, col, row, enable, rocid = None): """maskPixel [column] [row] [enable] [ROC id]: mask/unmask pixel""" self.api.maskPixel(col,row,enable,rocid) def complete_maskPixel(self, text, line, start_index, end_index): # return help for the cmd return [self.do_maskPixel.__doc__, ''] @arity(1,2,[int, int]) def do_maskAllPixels(self, enable, rocid = None): """maskAllPixels [enable] [rocid]: mask/unmask all pixels on given ROC""" self.api.maskAllPixels(enable,rocid) def complete_maskAllPixels(self, text, line, start_index, end_index): # return help for the cmd return [self.do_maskAllPixels.__doc__, ''] @arity(1,1,[int]) def do_getNEnabledPixels(self, rocid): """getNEnabledPixels [ROC id]: returns number of enabled pixels for ROC id""" print self.api.getNEnabledPixels(rocid) def complete_getNEnabledPixels(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getNEnabledPixels.__doc__, ''] @arity(0,0,[]) def do_getTbmType(self): """getTbmType: returns device code for the TBM programmed""" print self.api.getTbmType() def complete_getTbmType(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTbmType.__doc__, ''] @arity(0,0,[]) def do_getRocType(self): """getRocType: returns device code for the ROCs programmed""" print self.api.getRocType() def complete_getRocType(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getRocType.__doc__, ''] @arity(1,1,[int]) def do_getNMaskedPixels(self, rocid): """getNMaskedPixels [ROC id]: returns number of masked pixels for ROC id""" print self.api.getNMaskedPixels(rocid) def complete_getNMaskedPixels(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getNMaskedPixels.__doc__, ''] @arity(0,0,[]) def do_findAnalogueTBDelays(self): """findAnalogueTBDelays: configures tindelay and toutdelay""" print "" bestTin = 10 #default value if algorithm should fail print "scan tindelay:" print "tindelay\ttoutdelay\trawEvent[0]" for tin in range(5,20): rawEvent = self.varyDelays(tin, 20,verbose=False) print str(tin)+"\t\t20\t\t"+str(rawEvent[0]) if (rawEvent[0] < -100): #triggers for UB, the first one should always be UB bestTin = tin break print "" bestTout = 20 #default value if algorithm should fail tout = bestTin+5 print "scan toutdelay" print "tindelay\ttoutdelay\trawEvent[-1]" for i in range (15): rawEvent = self.varyDelays(bestTin, tout,verbose=False) print str(bestTin)+"\t\t"+str(tout)+"\t\t"+str(rawEvent[-1]) if rawEvent[-1] > 20: #triggers for PH, the last one should always be a pos PH bestTout = tout break tout -= 1 print "" self.api.setTestboardDelays({"tindelay":bestTin,"toutdelay":bestTout}) print "set tindelay to: ", bestTin print "set toutdelay to: ", bestTout def complete_findAnalogueTBDelays(self, text, line, start_index, end_index): # return help for the cmd return [self.do_findAnalogueTBDelays.__doc__, ''] @arity(0,3,[int, int, int]) def do_wbcScan(self, minWBC = 90, maxWBC = 255, maxTriggers = 10, triggersignal = "extern"): """ do_wbcScan [minWBC] [maxWBC] [maxTriggers] [signal]: sets the values of wbc from minWBC until it finds the wbc which has more than 90% filled events or it reaches 255 (default minWBC 90)""" self.api.daqTriggerSource(triggersignal) self.api.HVon(); wbcScan = [] print "wbc \tyield" # loop over wbc for wbc in range (minWBC,maxWBC): self.api.setDAC("wbc", wbc) self.api.daqStart() nHits = 0 nTriggers = 0 #loop until you find maxTriggers while nTriggers < maxTriggers: try: data = self.api.daqGetEvent() if len(data.pixels) > 0: nHits += 1 nTriggers += 1 except RuntimeError: pass hitYield = 100*nHits/maxTriggers wbcScan.append(hitYield) print '{0:03d}'.format(wbc),"\t", '{0:3.0f}%'.format(hitYield) self.api.daqStop() if(self.window): self.window = PxarGui( ROOT.gClient.GetRoot(), 1000, 800 ) plot = Plotter.create_tgraph(wbcScan, "wbc scan", "wbc", "evt/trig [%]", minWBC) self.window.histos.append(plot) self.window.update() def complete_wbcScan(self, text, line, start_index, end_index): # return help for the cmd return [self.do_wbcScan.__doc__, ''] @arity(0,4,[int, int, int, str]) def do_latencyScan(self, minlatency = 50, maxlatency = 100, triggers = 10, triggersignal = "extern"): """ do_latencyScan [min] [max] [triggers] [signal]: scan the trigger latency from min to max with set number of triggers)""" self.api.testAllPixels(0,None) self.api.HVon(); latencyScan = [] print "latency \tyield" # loop over latency for latency in range (minlatency,maxlatency): delay = {} delay["triggerlatency"] = latency self.api.setTestboardDelays(delay) self.api.daqTriggerSource(triggersignal) self.api.daqStart() nHits = 0 nTriggers = 0 #loop until you find maxTriggers while nTriggers < triggers: try: data = self.api.daqGetEvent() if len(data.pixels) > 0: nHits += 1 nTriggers += 1 except RuntimeError: pass hitYield = 100*nHits/triggers latencyScan.append(hitYield) print '{0:03d}'.format(latency),"\t", '{0:3.0f}%'.format(hitYield) self.api.daqStop() if(self.window): self.window = PxarGui( ROOT.gClient.GetRoot(), 1000, 800 ) plot = Plotter.create_tgraph(latencyScan, "latency scan", "trigger latency", "evt/trig [%]", minlatency) self.window.histos.append(plot) self.window.update() def complete_latencyScan(self, text, line, start_index, end_index): # return help for the cmd return [self.do_latencyScan.__doc__, ''] def do_quit(self, arg): """quit: terminates the application""" sys.exit(1) # shortcuts do_q = do_quit
class PxarCoreCmd(cmd.Cmd): """Simple command processor for the pxar core API.""" def __init__(self, api, gui): cmd.Cmd.__init__(self) self.fullOutput = False self.prompt = "pxarCore =>> " self.intro = "Welcome to the pxar core console!" ## defaults to None self.api = api self.window = None if (gui and guiAvailable): self.window = PxarGui(ROOT.gClient.GetRoot(), 800, 800) elif (gui and not guiAvailable): print "No GUI available (missing ROOT library)" def plot_eventdisplay(self, data): pixels = list() # Multiple events: if (isinstance(data, list)): if (not self.window): for evt in data: print evt return for evt in data: for px in evt.pixels: pixels.append(px) else: if (not self.window): print data return for px in data.pixels: pixels.append(px) self.plot_map(pixels, 'Event Display', True) def plot_map(self, data, name, count=False): if (not self.window): print data return # Find number of ROCs present: module = False for px in data: if px.roc > 0: module = True break # Prepare new numpy matrix: d = zeros((416 if module else 52, 160 if module else 80)) for px in data: xoffset = 52 * (px.roc % 8) if module else 0 yoffset = 80 * int(px.roc / 8) if module else 0 # Flip the ROCs upside down: y = (px.row + yoffset) if (px.roc < 8) else (2 * yoffset - px.row - 1) # Reverse order of the upper ROC row: x = (px.column + xoffset) if (px.roc < 8) else (415 - xoffset - px.column) d[x][y] += 1 if count else px.value plot = Plotter.create_th2(d, 0, 415 if module else 51, 0, 159 if module else 79, name, 'pixels x', 'pixels y', name) self.window.histos.append(plot) self.window.update() def plot_1d(self, data, name, dacname, min, max): if (not self.window): print_data(self.fullOutput, data, (max - min) / len(data)) return # Prepare new numpy matrix: d = zeros(len(data)) for idac, dac in enumerate(data): if (dac): d[idac] = dac[0].value plot = Plotter.create_th1(d, min, max, name, dacname, name) self.window.histos.append(plot) self.window.update() def plot_2d(self, data, name, dac1, step1, min1, max1, dac2, step2, min2, max2): if (not self.window): for idac, dac in enumerate(data): dac1 = min1 + (idac / ((max2 - min2) / step2 + 1)) * step1 dac2 = min2 + (idac % ((max2 - min2) / step2 + 1)) * step2 s = "DACs " + str(dac1) + ":" + str(dac2) + " - " for px in dac: s += str(px) print s return # Prepare new numpy matrix: bins1 = (max1 - min1) / step1 + 1 bins2 = (max2 - min2) / step2 + 1 d = zeros((bins1, bins2)) for idac, dac in enumerate(data): if (dac): bin1 = (idac / ((max2 - min2) / step2 + 1)) bin2 = (idac % ((max2 - min2) / step2 + 1)) d[bin1][bin2] = dac[0].value plot = Plotter.create_th2(d, min1, max1, min2, max2, name, dac1, dac2, name) self.window.histos.append(plot) self.window.update() def varyDelays(self, tindelay, toutdelay, verbose=False): self.api.setTestboardDelays({ "tindelay": tindelay, "toutdelay": toutdelay }) self.api.daqStart() self.api.daqTrigger(1, 500) try: rawEvent = self.api.daqGetRawEvent() except RuntimeError: pass if verbose: print "raw Event:\t\t", rawEvent nCount = 0 for i in rawEvent: i = i & 0x0fff if i & 0x0800: i -= 4096 rawEvent[nCount] = i nCount += 1 if verbose: print "converted Event:\t", rawEvent self.api.daqStop() return rawEvent ########################################################################################################################## def do_EOF(self, line): """ clean exit when receiving EOF (Ctrl-D) """ return True def do_gui(self, line): """Open the ROOT results browser""" if not guiAvailable: print "No GUI available (missing ROOT library)" return if self.window: return self.window = PxarGui(ROOT.gClient.GetRoot(), 800, 800) def do_switchFullOutput(self, line): """Switch between full and suppressed output of all pixels""" if self.fullOutput: set_printoptions(threshold=1000) self.fullOutput = False else: set_printoptions(threshold=nan) self.fullOutput = True @arity(0, 0, [] ) # decorator for argument verification defined in pxar_helpers.py def do_getVersion(self): """getVersion: returns the pxarcore library version""" print self.api.getVersion() def complete_getVersion(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getVersion.__doc__, ''] @arity(0, 0, []) def do_status(self): """status: returns the pxarcore library status""" print self.api.status() def complete_status(self, text, line, start_index, end_index): # return help for the cmd return [self.do_status.__doc__, ''] @arity(1, 1, [str]) def do_flashTB(self, filename): """flashTB [filename]: flash the DTB with new firmware""" self.api.flashTB(filename) def complete_flashTB(self, text, line, start_index, end_index): # tab-completion for the file path: try: # remove specific delimeters from the readline parser # to allow completion of filenames with dashes import readline delims = readline.get_completer_delims() delims = delims.replace('-', '') readline.set_completer_delims(delims) except ImportError: pass return get_possible_filename_completions( extract_full_argument(line, end_index)) @arity(1, 1, [str]) def do_run(self, filename): """run [filename]: loads a list of commands to be executed on the pxar cmdline""" try: f = open(filename) except IOError: print "Error: cannot open file '" + filename + "'" try: for line in f: if not line.startswith("#") and not line.isspace(): print line.replace('\n', ' ').replace('\r', '') self.onecmd(line) finally: f.close() def complete_run(self, text, line, start_index, end_index): # tab-completion for the file path: try: # remove specific delimeters from the readline parser # to allow completion of filenames with dashes import readline delims = readline.get_completer_delims() delims = delims.replace('-', '') readline.set_completer_delims(delims) except ImportError: pass return get_possible_filename_completions( extract_full_argument(line, end_index)) @arity(0, 0, []) def do_HVon(self): """HVon: switch High voltage for sensor bias on""" self.api.HVon() def complete_HVon(self, text, line, start_index, end_index): # return help for the cmd return [self.do_HVon.__doc__, ''] @arity(0, 0, []) def do_Poff(self): """Pon: switch DTB power output off""" self.api.Poff() def complete_Poff(self, text, line, start_index, end_index): # return help for the cmd return [self.do_Poff.__doc__, ''] @arity(0, 0, []) def do_Pon(self): """Pon: switch DTB power output on""" self.api.Pon() def complete_Pon(self, text, line, start_index, end_index): # return help for the cmd return [self.do_Pon.__doc__, ''] @arity(0, 0, []) def do_HVoff(self): """HVoff: switch High voltage for sensor bias off""" self.api.HVoff() def complete_HVoff(self, text, line, start_index, end_index): # return help for the cmd return [self.do_HVoff.__doc__, ''] @arity(0, 0, []) def do_getTBia(self): """getTBia: returns analog DTB current""" print "Analog Current: ", (self.api.getTBia() * 1000), " mA" def complete_getTBia(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTBia.__doc__, ''] @arity(0, 0, []) def do_getTBva(self): """getTBva: returns analog DTB voltage""" print "Analog Voltage: ", self.api.getTBva(), " V" def complete_getTBva(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTBva.__doc__, ''] @arity(0, 0, []) def do_getTBid(self): """getTBid: returns digital DTB current""" print "Digital Current: ", (self.api.getTBid() * 1000), " mA" def complete_getTBid(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTBid.__doc__, ''] @arity(0, 0, []) def do_getTBvd(self): """getTBvd: returns digital DTB voltage""" print "Digital Voltage: ", self.api.getTBvd(), " V" def complete_getTBvd(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTBvd.__doc__, ''] @arity(1, 1, [int]) def do_setExternalClock(self, enable): """setExternalClock [enable]: enables the external DTB clock input, switches off the internal clock. Only switches if external clock is present.""" if self.api.setExternalClock(enable) is True: print "Switched to " + ("external" if enable else "internal") + " clock." else: print "Could not switch to " + ("external" if enable else "internal") + " clock!" def complete_setExternalClock(self, text, line, start_index, end_index): # return help for the cmd return [self.do_setExternalClock.__doc__, ''] @arity(3, 3, [int, int, int]) def do_setClockStretch(self, src, delay, width): """setClockStretch [src] [delay] [width]: enables the clock stretch mechanism with the parameters given.""" self.api.setClockStretch(src, delay, width) def complete_setClockStretch(self, text, line, start_index, end_index): # return help for the cmd return [self.do_setClockStretch.__doc__, ''] @arity(0, 0, []) def do_daqStart(self): """daqStart: starts a new DAQ session""" self.api.daqStart() def complete_daqStart(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqStart.__doc__, ''] @arity(0, 0, []) def do_daqStatus(self): """daqStatus: reports status of the running DAQ session""" if self.api.daqStatus(): print "DAQ session is fine" else: print "DAQ session returns faulty state" def complete_daqStatus(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqStatus.__doc__, ''] @arity(1, 1, [str]) def do_daqTriggerSource(self, source): """daqTriggerSource: select the trigger source to be used for the DAQ session""" if self.api.daqTriggerSource(source): print "Trigger source \"" + source + "\" selected." else: print "DAQ returns faulty state." def complete_daqTriggerSource(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqTriggerSource.__doc__, ''] @arity(1, 1, [str]) def do_daqSingleSignal(self, signal): """daqSingleSignal [signal]: send a single signal to the DUT""" if self.api.daqSingleSignal(signal): print "Trigger signal \"" + signal + "\" sent to DUT." else: print "Trigger signal lookup failed." def complete_daqSingleSignal(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqSingleSignal.__doc__, ''] @arity(0, 0, []) def do_daqStop(self): """daqStop: stops the running DAQ session""" self.api.daqStop() def complete_daqStop(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqStop.__doc__, ''] @arity(1, 2, [int, int]) def do_daqTrigger(self, ntrig, period=0): """daqTrigger [ntrig] [period = 0]: sends ntrig patterns to the device""" self.api.daqTrigger(ntrig, period) def complete_daqTrigger(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqTrigger.__doc__, ''] @arity(1, 1, [int]) def do_daqTriggerLoop(self, period): """daqTriggerLoop [period]: starts trigger loop with given period (in BC/40MHz)""" self.api.daqTriggerLoop(period) def complete_daqTriggerLoop(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqTriggerLoop.__doc__, ''] @arity(0, 0, []) def do_daqTriggerLoopHalt(self): """daqTriggerLoopHalt: stops the trigger loop""" self.api.daqTriggerLoopHalt() def complete_daqTriggerLoopHalt(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqTriggerLoopHalt.__doc__, ''] @arity(0, 0, []) def do_daqGetEvent(self): """daqGetEvent: read one event from the event buffer""" try: data = self.api.daqGetEvent() self.plot_eventdisplay(data) except RuntimeError: pass def complete_daqGetEvent(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqGetEvent.__doc__, ''] @arity(0, 0, []) def do_daqGetEventBuffer(self): """daqGetEventBuffer: read all decoded events from the DTB buffer""" try: data = self.api.daqGetEventBuffer() self.plot_eventdisplay(data) except RuntimeError: pass def complete_daqGetEventBuffer(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqGetEventBuffer.__doc__, ''] @arity(0, 0, []) def do_daqGetRawEvent(self): """daqGetRawEvent: read one raw event from the event buffer""" try: dat = self.api.daqGetRawEvent() s = "" for i in dat: s += '{0:03x}'.format(i) + " " print s except RuntimeError: pass def complete_daqGetRawEvent(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqGetRawEvent.__doc__, ''] @arity(0, 0, []) def do_getStatistics(self): """getStatistics: print full statistics accumulated during last DAQ session""" dat = self.api.getStatistics() print dat def complete_getStatistics(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getStatistics.__doc__, ''] @arity(0, 0, []) def do_daqGetBuffer(self): """daqGetBuffer: read full raw data DTB buffer""" try: dat = self.api.daqGetBuffer() s = "" for i in dat: if i & 0x0FF0 == 0x07f0: s += "\n" s += '{:04x}'.format(i) + " " print s except RuntimeError: pass def complete_daqGetBuffer(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqGetBuffer.__doc__, ''] @arity(0, 0, []) def do_daqGetReadback(self): """daqGetReadback: return all ROC readback values for the last DAQ session""" dat = self.api.daqGetReadback() for iroc, roc in enumerate(dat): print "ROC " + str(iroc) + ": (" + str(len(roc)) + " values)" s = "" for i in roc: s += '{:04x}'.format(i) + " " print s def complete_daqGetReadback(self, text, line, start_index, end_index): # return help for the cmd return [self.do_daqGetReadback.__doc__, ''] @arity(0, 2, [int, int]) def do_getEfficiencyMap(self, flags=0, nTriggers=10): """getEfficiencyMap [flags = 0] [nTriggers = 10]: returns the efficiency map""" data = self.api.getEfficiencyMap(flags, nTriggers) self.plot_map(data, "Efficiency") def complete_getEfficiencyMap(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getEfficiencyMap.__doc__, ''] @arity(0, 2, [int, int]) def do_getPulseheightMap(self, flags=0, nTriggers=10): """getPulseheightMap [flags = 0] [nTriggers = 10]: returns the pulseheight map""" data = self.api.getPulseheightMap(flags, nTriggers) self.plot_map(data, "Pulseheight") def complete_getPulseheightMap(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getPulseheightMap.__doc__, ''] @arity(1, 7, [str, int, int, int, int, int, int]) def do_getThresholdMap(self, dacname, dacstep=1, dacmin=0, dacmax=255, threshold=50, flags=0, nTriggers=10): """getThresholdMap [DAC name] [step size] [min] [max] [threshold] [flags = 0] [nTriggers = 10]: returns the threshold map for the given DAC""" data = self.api.getThresholdMap(dacname, dacstep, dacmin, dacmax, threshold, flags, nTriggers) self.plot_map(data, "Threshold " + dacname) def complete_getThresholdMap(self, text, line, start_index, end_index): if text and len( line.split(" ")) <= 2: # first argument and started to type # list matching entries return [ dac for dac in dacdict.getAllROCNames() if dac.startswith(text) ] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_getThresholdMap.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(4, 6, [str, int, int, int, int, int]) def do_getPulseheightVsDAC(self, dacname, dacstep, dacmin, dacmax, flags=0, nTriggers=10): """getPulseheightVsDAC [DAC name] [step size] [min] [max] [flags = 0] [nTriggers = 10]: returns the pulseheight over a 1D DAC scan""" data = self.api.getPulseheightVsDAC(dacname, dacstep, dacmin, dacmax, flags, nTriggers) self.plot_1d(data, "Pulseheight", dacname, dacmin, dacmax) def complete_getPulseheightVsDAC(self, text, line, start_index, end_index): if text and len( line.split(" ")) <= 2: # first argument and started to type # list matching entries return [ dac for dac in dacdict.getAllROCNames() if dac.startswith(text) ] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_getPulseheightVsDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(4, 6, [str, int, int, int, int, int]) def do_getEfficiencyVsDAC(self, dacname, dacstep, dacmin, dacmax, flags=0, nTriggers=10): """getEfficiencyVsDAC [DAC name] [step size] [min] [max] [flags = 0] [nTriggers = 10]: returns the efficiency over a 1D DAC scan""" data = self.api.getEfficiencyVsDAC(dacname, dacstep, dacmin, dacmax, flags, nTriggers) self.plot_1d(data, "Efficiency", dacname, dacmin, dacmax) def complete_getEfficiencyVsDAC(self, text, line, start_index, end_index): if text and len( line.split(" ")) <= 2: # first argument and started to type # list matching entries return [ dac for dac in dacdict.getAllROCNames() if dac.startswith(text) ] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_getEfficiencyVsDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(8, 11, [str, int, int, int, str, int, int, int, int, int, int]) def do_getThresholdVsDAC(self, dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, threshold=50, flags=0, nTriggers=10): """getThresholdVsDAC [DAC1 name] [step size 1] [min 1] [max 1] [DAC2 name] [step size 2] [min 2] [max 2] [threshold = 50] [flags = 0] [nTriggers = 10]: returns the threshold for DAC1 over a 1D DAC2 scan""" data = self.api.getThresholdVsDAC(dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, threshold, flags, nTriggers) self.plot_1d(data, "Threshold " + dac1name, dac2name, dac2min, dac2max) def complete_getThresholdVsDAC(self, text, line, start_index, end_index): if text and len( line.split(" ")) <= 2: # first argument and started to type # list matching entries return [ dac for dac in dacdict.getAllROCNames() if dac.startswith(text) ] elif text and len(line.split(" ")) == 6: # list matching entries return [ dac for dac in dacdict.getAllROCNames() if dac.startswith(text) ] else: if (len(line.split(" ")) > 2 and len(line.split(" ")) < 6) or len(line.split(" ")) > 6: # return help for the cmd return [self.do_getThresholdVsDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(8, 10, [str, int, int, int, str, int, int, int, int, int]) def do_getPulseheightVsDACDAC(self, dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, flags=0, nTriggers=10): """getPulseheightVsDACDAC [DAC1 name] [step size 1] [min 1] [max 1] [DAC2 name] [step size 2] [min 2] [max 2] [flags = 0] [nTriggers = 10]: returns the pulseheight over a 2D DAC1-DAC2 scan""" data = self.api.getPulseheightVsDACDAC(dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, flags, nTriggers) self.plot_2d(data, "Pulseheight", dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max) def complete_getPulseheightVsDACDAC(self, text, line, start_index, end_index): if text and len( line.split(" ")) <= 2: # first argument and started to type # list matching entries return [ dac for dac in dacdict.getAllROCNames() if dac.startswith(text) ] elif text and len(line.split(" ")) == 6: # list matching entries return [ dac for dac in dacdict.getAllROCNames() if dac.startswith(text) ] else: if (len(line.split(" ")) > 2 and len(line.split(" ")) < 6) or len(line.split(" ")) > 6: # return help for the cmd return [self.do_getPulseheightVsDACDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(8, 10, [str, int, int, int, str, int, int, int, int, int]) def do_getEfficiencyVsDACDAC(self, dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, flags=0, nTriggers=10): """getEfficiencyVsDACDAC [DAC1 name] [step size 1] [min 1] [max 1] [DAC2 name] [step size 2] [min 2] [max 2] [flags = 0] [nTriggers = 10]: returns the efficiency over a 2D DAC1-DAC2 scan""" data = self.api.getEfficiencyVsDACDAC(dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max, flags, nTriggers) self.plot_2d(data, "Efficiency", dac1name, dac1step, dac1min, dac1max, dac2name, dac2step, dac2min, dac2max) def complete_getEfficiencyVsDACDAC(self, text, line, start_index, end_index): if text and len( line.split(" ")) <= 2: # first argument and started to type # list matching entries return [ dac for dac in dacdict.getAllROCNames() if dac.startswith(text) ] elif text and len(line.split(" ")) == 6: # list matching entries return [ dac for dac in dacdict.getAllROCNames() if dac.startswith(text) ] else: if (len(line.split(" ")) > 2 and len(line.split(" ")) < 6) or len(line.split(" ")) > 6: # return help for the cmd return [self.do_getEfficiencyVsDACDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(0, 0, []) def do_analogLevelScan(self): """analogLevelScan: scan the ADC levels of an analog ROC""" self.api.daqStart() self.api.daqTrigger(5000, 500) plotdata = zeros(1024) try: while True: s = "" p = "" pos = -3 dat = self.api.daqGetRawEvent() for i in dat: i = i & 0x0fff # Remove PH from hits: if pos == 5: pos = 0 continue if i & 0x0800: i -= 4096 plotdata[500 + i] += 1 pos += 1 except RuntimeError: pass plot = Plotter.create_th1(plotdata, -512, +512, "Address Levels", "ADC", "#") self.window.histos.append(plot) self.window.update() def complete_analogLevelScan(self, text, line, start_index, end_index): # return help for the cmd return [self.do_analogLevelScan.__doc__, ''] @arity(2, 3, [str, str, int]) def do_setSignalMode(self, signal, mode, speed=0): """setSignalMode [signal] [mode] [speed]: Set the DTB signal to given mode (normal, low, high, random). The [speed] parameter is only necessary for random signal mode.""" self.api.setSignalMode(signal, mode, speed) def complete_setSignalMode(self, text, line, start_index, end_index): if text and len( line.split(" ")) <= 2: # first argument and started to type # list matching entries return [ sig for sig in dacdict.getAllDTBNames() if sig.startswith(text) ] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_setSignalMode.__doc__, ''] else: # return all signals return dacdict.getAllDTBNames() @arity(2, 2, [str, str]) def do_SignalProbe(self, probe, name): """SignalProbe [probe] [name]: Switches DTB probe output [probe] to signal [name]""" self.api.SignalProbe(probe, name) def complete_SignalProbe(self, text, line, start_index, end_index): probes = ["d1", "d2", "a1", "a2"] if len(line.split(" ")) <= 2: # first argument if text: # started to type # list matching entries return [pr for pr in probes if pr.startswith(text)] else: # list all probes return probes elif len(line.split(" ")) <= 3: # second argument p = "".join(line.split(" ")[1:2]) if text: # started to type if p.startswith("a"): return [ pr for pr in probedict.getAllAnalogNames() if pr.startswith(text) ] elif p.startswith("d"): return [ pr for pr in probedict.getAllDigitalNames() if pr.startswith(text) ] else: return [self.do_SignalProbe.__doc__, ''] else: # return all signals: if p.startswith("a"): return probedict.getAllAnalogNames() elif p.startswith("d"): return probedict.getAllDigitalNames() else: return [self.do_SignalProbe.__doc__, ''] else: # return help for the cmd return [self.do_SignalProbe.__doc__, ''] @arity(2, 3, [str, int, int]) def do_setDAC(self, dacname, value, rocid=None): """setDAC [DAC name] [value] [ROCID]: Set the DAC to given value for given roc ID""" self.api.setDAC(dacname, value, rocid) def complete_setDAC(self, text, line, start_index, end_index): if text and len( line.split(" ")) <= 2: # first argument and started to type # list matching entries return [ dac for dac in dacdict.getAllROCNames() if dac.startswith(text) ] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_setDAC.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(2, 3, [str, int, int]) def do_setTbmReg(self, regname, value, tbmid=None): """setTbmReg [Reg. name] [value] [TBMID]: Set the register to given value for given TBM ID""" self.api.setTbmReg(regname, value, tbmid) def complete_setTbmReg(self, text, line, start_index, end_index): if text and len( line.split(" ")) <= 2: # first argument and started to type # list matching entries return [ dac for dac in dacdict.getAllTBMNames() if dac.startswith(text) ] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_setTbmReg.__doc__, ''] else: # return all DACS return dacdict.getAllTBMNames() @arity(1, 1, [str]) def do_getDACRange(self, dacname): """getDACRange [DAC name]: Get the valid value range for the given DAC""" print "DAC ", dacname, ": 0 -", self.api.getDACRange(dacname) def complete_getDACRange(self, text, line, start_index, end_index): if text and len( line.split(" ")) <= 2: # first argument and started to type # list matching entries return [ dac for dac in dacdict.getAllROCNames() if dac.startswith(text) ] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_getDACRange.__doc__, ''] else: # return all DACS return dacdict.getAllROCNames() @arity(2, 3, [str, int, int]) def do_setTbmReg(self, regname, value, tbmid=None): """setTbmReg [register name] [value] [TBM ID]: Set the register to given value for given TBM ID""" self.api.setTbmReg(regname, value, tbmid) def complete_setTbmReg(self, text, line, start_index, end_index): if text and len( line.split(" ")) <= 2: # first argument and started to type # list matching entries return [ reg for reg in dacdict.getAllTBMNames() if reg.startswith(text) ] else: if len(line.split(" ")) > 2: # return help for the cmd return [self.do_setTbmReg.__doc__, ''] else: # return all registers return dacdict.getAllTBMNames() @arity(1, 1, [int]) def do_getTbmDACs(self, tbmid): """getTbmDACs [id]: get the currently programmed register settings for TBM #id""" print self.api.getTbmDACs(tbmid) def complete_getTbmDACs(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTbmDACs.__doc__, ''] @arity(0, 0, []) def do_info(self): """info: print pxarCore DUT info""" self.api.info() def complete_info(self, text, line, start_index, end_index): # return help for the cmd return [self.do_info.__doc__, ''] @arity(0, 0, []) def do_getEnabledRocIDs(self): """info: print ROC IDs of all enabled ROCs""" data = self.api.getEnabledRocIDs() print data def complete_getEnabledRocIDs(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getEnabledRocIDs.__doc__, ''] @arity(0, 0, []) def do_getEnabledRocI2Caddr(self): """info: print ROC IDs of all enabled ROCs""" data = self.api.getEnabledRocI2Caddr() print data def complete_getEnabledRocI2Caddr(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getEnabledRocI2Caddr.__doc__, ''] @arity(2, 2, [int, int]) def do_setROCEnable(self, rocid, enable): """setROCEnable [ROC id] [enable]: enable/disable the ROC with given ID""" self.api.setROCEnable(rocid, enable) def complete_setROCEnable(self, text, line, start_index, end_index): # return help for the cmd return [self.do_setROCEnable.__doc__, ''] @arity(2, 2, [int, int]) def do_setTBMEnable(self, tbmid, enable): """setTBMEnable [ROC id] [enable]: enable/disable the ROC with given ID""" self.api.setTBMEnable(tbmid, enable) def complete_setTBMEnable(self, text, line, start_index, end_index): # return help for the cmd return [self.do_setTBMEnable.__doc__, ''] @arity(3, 4, [int, int, int, int]) def do_testPixel(self, col, row, enable, rocid=None): """testPixel [column] [row] [enable] [ROC id]: enable/disable testing of pixel""" self.api.testPixel(col, row, enable, rocid) def complete_testPixel(self, text, line, start_index, end_index): # return help for the cmd return [self.do_testPixel.__doc__, ''] @arity(1, 2, [int, int]) def do_testAllPixels(self, enable, rocid=None): """testAllPixels [enable] [rocid]: enable/disable tesing for all pixels on given ROC""" self.api.testAllPixels(enable, rocid) def complete_testAllPixels(self, text, line, start_index, end_index): # return help for the cmd return [self.do_testAllPixels.__doc__, ''] @arity(3, 4, [int, int, int, int]) def do_maskPixel(self, col, row, enable, rocid=None): """maskPixel [column] [row] [enable] [ROC id]: mask/unmask pixel""" self.api.maskPixel(col, row, enable, rocid) def complete_maskPixel(self, text, line, start_index, end_index): # return help for the cmd return [self.do_maskPixel.__doc__, ''] @arity(1, 2, [int, int]) def do_maskAllPixels(self, enable, rocid=None): """maskAllPixels [enable] [rocid]: mask/unmask all pixels on given ROC""" self.api.maskAllPixels(enable, rocid) def complete_maskAllPixels(self, text, line, start_index, end_index): # return help for the cmd return [self.do_maskAllPixels.__doc__, ''] @arity(1, 1, [int]) def do_getNEnabledPixels(self, rocid): """getNEnabledPixels [ROC id]: returns number of enabled pixels for ROC id""" print self.api.getNEnabledPixels(rocid) def complete_getNEnabledPixels(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getNEnabledPixels.__doc__, ''] @arity(0, 0, []) def do_getTbmType(self): """getTbmType: returns device code for the TBM programmed""" print self.api.getTbmType() def complete_getTbmType(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getTbmType.__doc__, ''] @arity(0, 0, []) def do_getRocType(self): """getRocType: returns device code for the ROCs programmed""" print self.api.getRocType() def complete_getRocType(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getRocType.__doc__, ''] @arity(1, 1, [int]) def do_getNMaskedPixels(self, rocid): """getNMaskedPixels [ROC id]: returns number of masked pixels for ROC id""" print self.api.getNMaskedPixels(rocid) def complete_getNMaskedPixels(self, text, line, start_index, end_index): # return help for the cmd return [self.do_getNMaskedPixels.__doc__, ''] @arity(0, 0, []) def do_findAnalogueTBDelays(self): """findAnalogueTBDelays: configures tindelay and toutdelay""" print "" bestTin = 10 #default value if algorithm should fail print "scan tindelay:" print "tindelay\ttoutdelay\trawEvent[0]" for tin in range(5, 20): rawEvent = self.varyDelays(tin, 20, verbose=False) print str(tin) + "\t\t20\t\t" + str(rawEvent[0]) if (rawEvent[0] < -100): #triggers for UB, the first one should always be UB bestTin = tin break print "" bestTout = 20 #default value if algorithm should fail tout = bestTin + 5 print "scan toutdelay" print "tindelay\ttoutdelay\trawEvent[-1]" for i in range(15): rawEvent = self.varyDelays(bestTin, tout, verbose=False) print str(bestTin) + "\t\t" + str(tout) + "\t\t" + str( rawEvent[-1]) if rawEvent[ -1] > 20: #triggers for PH, the last one should always be a pos PH bestTout = tout break tout -= 1 print "" self.api.setTestboardDelays({ "tindelay": bestTin, "toutdelay": bestTout }) print "set tindelay to: ", bestTin print "set toutdelay to: ", bestTout def complete_findAnalogueTBDelays(self, text, line, start_index, end_index): # return help for the cmd return [self.do_findAnalogueTBDelays.__doc__, ''] @arity(0, 3, [int, int, int]) def do_wbcScan(self, minWBC=90, maxWBC=255, maxTriggers=10, triggersignal="extern"): """ do_wbcScan [minWBC] [maxWBC] [maxTriggers] [signal]: sets the values of wbc from minWBC until it finds the wbc which has more than 90% filled events or it reaches 255 (default minWBC 90)""" self.api.daqTriggerSource(triggersignal) self.api.HVon() wbcScan = [] print "wbc \tyield" # loop over wbc for wbc in range(minWBC, maxWBC): self.api.setDAC("wbc", wbc) self.api.daqStart() nHits = 0 nTriggers = 0 #loop until you find maxTriggers while nTriggers < maxTriggers: try: data = self.api.daqGetEvent() if len(data.pixels) > 0: nHits += 1 nTriggers += 1 except RuntimeError: pass hitYield = 100 * nHits / maxTriggers wbcScan.append(hitYield) print '{0:03d}'.format(wbc), "\t", '{0:3.0f}%'.format(hitYield) self.api.daqStop() if (self.window): self.window = PxarGui(ROOT.gClient.GetRoot(), 1000, 800) plot = Plotter.create_tgraph(wbcScan, "wbc scan", "wbc", "evt/trig [%]", minWBC) self.window.histos.append(plot) self.window.update() def complete_wbcScan(self, text, line, start_index, end_index): # return help for the cmd return [self.do_wbcScan.__doc__, ''] @arity(0, 4, [int, int, int, str]) def do_latencyScan(self, minlatency=50, maxlatency=100, triggers=10, triggersignal="extern"): """ do_latencyScan [min] [max] [triggers] [signal]: scan the trigger latency from min to max with set number of triggers)""" self.api.testAllPixels(0, None) self.api.HVon() latencyScan = [] print "latency \tyield" # loop over latency for latency in range(minlatency, maxlatency): delay = {} delay["triggerlatency"] = latency self.api.setTestboardDelays(delay) self.api.daqTriggerSource(triggersignal) self.api.daqStart() nHits = 0 nTriggers = 0 #loop until you find maxTriggers while nTriggers < triggers: try: data = self.api.daqGetEvent() if len(data.pixels) > 0: nHits += 1 nTriggers += 1 except RuntimeError: pass hitYield = 100 * nHits / triggers latencyScan.append(hitYield) print '{0:03d}'.format(latency), "\t", '{0:3.0f}%'.format(hitYield) self.api.daqStop() if (self.window): self.window = PxarGui(ROOT.gClient.GetRoot(), 1000, 800) plot = Plotter.create_tgraph(latencyScan, "latency scan", "trigger latency", "evt/trig [%]", minlatency) self.window.histos.append(plot) self.window.update() def complete_latencyScan(self, text, line, start_index, end_index): # return help for the cmd return [self.do_latencyScan.__doc__, ''] def do_quit(self, arg): """quit: terminates the application""" sys.exit(1) # shortcuts do_q = do_quit