# Set default histogram behavior import ROOT as r r.TH1.SetDefaultSumw2(False) r.gROOT.SetBatch(True) r.gStyle.SetOptStat(1111111) dacScanFile = r.TFile(args.infilename, "READ") if len(args.infilename.split('/')) > 1 and len( args.infilename.split('/')[len(args.infilename.split('/')) - 2].split('.')) == 5: scandate = args.infilename.split('/')[len(args.infilename.split('/')) - 2] else: scandate = 'noscandate' from gempython.gemplotting.utils.anautilities import dacAnalysis from gempython.gemplotting.utils.exceptions import VFATDACBiasCannotBeReached try: dacAnalysis(args, dacScanFile.dacScanTree, chamber_config, scandate=scandate) except VFATDACBiasCannotBeReached as err: from gempython.utils.gemlogger import printRed printRed(err.message) printRed("VFATs above may *NOT* be properly biased") dacScanFile.Close() print("\nAnalysis completed. Goodbye")
default="current") args = parser.parse_args() # Set logging level to INFO if debug requested if args.debug: gemlogger = getGEMLogger(__name__) gemlogger.setLevel(logging.INFO) # Check to make sure (shelf,slot,key) exists in chamber_config from gempython.gemplotting.mapping.chamberInfo import chamber_config ohKey = (args.shelf, args.slot, args.link) import os if ohKey not in chamber_config: printRed( "I did not find (shelf,slot,link) = {0} in the chamber_config dictionary.\nExiting" .format(ohKey)) exit(os.EX_USAGE) cName = chamber_config[ohKey] # Determine Card Name from gempython.vfatqc.utils.qcutilities import getCardName cardName = getCardName(args.shelf, args.slot) from gempython.tools.hw_constants import maxVfat3DACSize from gempython.gemplotting.utils.anautilities import getDataPath from gempython.vfatqc.utils.confUtils import updateVFAT3ConfFilesOnAMC dataPath = getDataPath() if args.dacSelect is None: # Send IREF values filename_iref = "{0}/{1}/NominalValues-CFG_IREF.txt".format(
import numpy as np import root_numpy as rp print("Getting histograms and making output canvases") for oh in range(0, 12): # Skip masked OH's if (not ((args.ohMask >> oh) & 0x1)): continue # Make base directory baseDir[args.slot][oh] = "AMC13-{0}/AMC-{1}/GEB-{2}/".format( args.amc13, args.slot, oh) # Check to make sure this AMC13 & AMC exist in the file currentDir = infile.GetDirectory(baseDir[args.slot][oh]) if currentDir == 0: printRed("Directory: {0} in file {1} does not exist".format( baseDir[slot][oh], args.infile)) printRed("Skipping AMC{0} OH{1}".format(args.slot, oh)) continue # Make mean & RMS lat dist latencyMean[args.slot][oh] = r.TH1D( "latencyMean_AMC{0}_OH{1}".format(args.slot, oh), "Latency spread across all VFATs for #left(AMC{0},OH{1}#right)". format(args.slot, oh), (args.scanmax - args.scanmin) * 10, args.scanmin - 0.5, args.scanmax - 0.5) latencyRMS[args.slot][oh] = r.TH1D( "latencyRMS_AMC{0}_OH{1}".format(args.slot, oh), "Latency RMS across all VFATs for #left(AMC{0},OH{1}#right)". format(args.slot, oh), 100, -0.5, 9.5) allVFATsLatency[args.slot][oh] = None
print('Set link {0} VFAT{1} CFG_THR_ARM_DAC to {2}'.format( args.link, event.vfatN, event.vt1)) vfatBoard.setVFATThreshold(chip=int(event.vfatN), vt1=int(event.vt1)) # Get all chip IDs dict_vfatIDvals[ohN] = vfatBoard.getAllChipIDs(args.vfatmask) # Get CFG_CAL_DAC calibration constants if args.calFileCAL: calDacCalFile = "{0}/{1}/calFile_calDac_{1}.txt".format( dataPath, chamber_config[ohKey]) calDacCalFileExists = os.path.isfile(calDacCalFile) if not calDacCalFileExists: printRed( "Missing CFG_CAL_DAC calibration file for shelf{0} slot{1} OH{2}, detector {3}:\n\t{4}" .format(args.shelf, args.slot, ohN, chamber_config[ohKey], calDacCalFile)) raise Exception("Missing CFG_CAL_DAC Calibration file.") ohKey = (args.shelf, args.slot, ohN) dict_calFiles[ohKey] = calDacCalFile pass # Get initial channel registers if args.zeroChan: print( "zero'ing all channel registers on shelf{0} slot{1} in ohMask: 0x{2:x}" .format(args.shelf, args.slot, args.ohMask)) for ohN in range(0, amcBoard.nOHs): # Skip masked OH's if (not ((args.ohMask >> ohN) & 0x1)):
def iterativeTrim(args, dict_dirPaths, identifier, dict_chanRegData=None, dict_calFiles=None): """ Takes an scurve at a given set of channel registers (all 0's if not provided) and returns a dictionary of numpy arrays with fit results (see gempythong.gemplotting.fitting.fitScanData for details on the output container). args - Namespace produced by ArgumentParser.parse_args dirPath - Output filepath location that scurve raw data should be saved at identifier - Unique string identifier to be used for each iteration chanRegData - structure numpy array containing channel register data, expected dtype values are: [('CALPULSE_ENABLE','bool'),('MASK','bool'),('ZCC_TRIM_POLARITY','bool'), ('ZCC_TRIM_AMPLITUDE','uint8'),('ARM_TRIM_POLARITY','bool'),('ARM_TRIM_AMPLITUDE','uint8')]. If provided these values will be written to the channel registers of all unmaksed VFATs. calInfo - Tuple of numpy arrays providing CFG_CAL_DAC calibration info, idx = 0 (1) for slopw (intercept) indexed by VFAT position """ from ctypes import c_uint32 import root_numpy as rp from gempython.vfatqc.utils.scanUtils import launchSCurve dictOfFiles = {} for ohN in range(0, amcBoard.nOHs): # Skip masked OH's if (not ((args.ohMask >> ohN) & 0x1)): continue ohKey = (args.shelf, args.slot, ohN) # Get Channel Register Info if dict_chanRegData is None: setChanRegs = False cArray_trimVal = None cArray_trimPol = None else: setChanRegs = True detName = chamber_config[ohKey] gemType = detName[:detName.find('-')].lower() cArray_trimVal = ( c_uint32 * (vfatsPerGemVariant[gemType] * CHANNELS_PER_VFAT))( *dict_chanRegData[ohN]["ARM_TRIM_AMPLITUDE"]) cArray_trimPol = ( c_uint32 * (vfatsPerGemVariant[gemType] * CHANNELS_PER_VFAT))( *dict_chanRegData[ohN]["ARM_TRIM_POLARITY"]) pass # Set filename of this scurve isZombie = True filename = "{:s}/SCurveData_{:s}.root".format(dict_dirPaths[ohN], identifier) dictOfFiles[ohKey] = (filename, chamber_config[ohKey], GEBtype[ohKey]) if os.path.isfile(filename): scurveRawFile = r.TFile(filename, "READ") isZombie = scurveRawFile.IsZombie() # Take the scurves in sequence (it is not possible to take scurves in parallel) if not isZombie: try: thisTree = scurveRawFile.scurveTree except AttributeError as error: print("Caught exception {:s}".format(error)) print("Going to re-take scurve corresponding to: {:s}".format( filename)) launchSCurve(calSF=args.calSF, cardName=getCardName(args.shelf, args.slot), chMax=args.chMax, chMin=args.chMin, debug=args.debug, filename=filename, latency=args.latency, link=ohN, mspl=args.pulseStretch, nevts=args.nevts, setChanRegs=setChanRegs, trimARM=cArray_trimVal, trimARMPol=cArray_trimPol, vfatmask=args.vfatmask, voltageStepPulse=not args.currentPulse) print("scurve finished") else: print("File {:s} either doesn't exist or is a zombie".format( filename)) print("Going to re-take scurve corresponding to: {:s}".format( filename)) launchSCurve(calSF=args.calSF, cardName=getCardName(args.shelf, args.slot), chMax=args.chMax, chMin=args.chMin, debug=args.debug, filename=filename, latency=args.latency, link=ohN, mspl=args.pulseStretch, nevts=args.nevts, setChanRegs=setChanRegs, trimARM=cArray_trimVal, trimARMPol=cArray_trimPol, vfatmask=args.vfatmask, voltageStepPulse=not args.currentPulse) print("scurve finished") pass # Make the analysis output directories and set permissions from gempython.utils.wrappers import runCommand for scurveFile in dictOfFiles.values(): runCommand( ["mkdir", "-p", "{0}".format(scurveFile[0].replace(".root", ""))]) os.system("chmod -R g+rw {0} 2> /dev/null".format( scurveFile[0].replace(".root", ""))) # Do the analysis in parallel from multiprocessing import Pool from gempython.gemplotting.utils.anautilities import getNumCores2Use, init_worker pool = Pool(getNumCores2Use(args), initializer=init_worker ) # Allocate number of CPU's based on getNumCores2Use() from gempython.gemplotting.utils.scurveAlgos import anaUltraScurveStar import itertools, sys, traceback try: print( "Launching scurve analysis processes, this may take some time, please be patient" ) pool.map_async( anaUltraScurveStar, itertools.izip( [args for geoAddr in dictOfFiles.keys()], # args namespace [scurveFile[0] for scurveFile in dictOfFiles.values()], # scurveFilename [dict_calFiles[geoAddr] for geoAddr in dictOfFiles.keys()], # calFile [scurveFile[2] for scurveFile in dictOfFiles.values()], # GEBtype [ scurveFile[0].replace(".root", "") for scurveFile in dictOfFiles.values() ], # outputDir [None for geoAddr in dictOfFiles.keys()] # vfatList )).get(7200) # wait at most 2 hours except KeyboardInterrupt: printRed("Caught KeyboardInterrupt, terminating workers") pool.terminate() raise Exception("Analysis failed.") except Exception as err: printRed("Caught {0}: {1}, terminating workers".format( type(err), err.message)) pool.terminate() traceback.print_exc(file=sys.stdout) raise Exception("Analysis failed.") except: # catch *all* exceptions e = sys.exc_info()[0] printRed("Caught non-Python Exception %s" % (e)) pool.terminate() traceback.print_exc(file=sys.stdout) raise Exception("Analysis failed.") else: printGreen("Analysis Completed Successfully") pool.close() pool.join() scurveFitResults = {} for ohN in range(0, amcBoard.nOHs): # Skip masked OH's if (not ((args.ohMask >> ohN) & 0x1)): continue from gempython.gemplotting.utils.anaInfo import tree_names filename = "{0}/{1}".format( dict_dirPaths[ohN], tree_names["itertrimAna"][0].format(IDENTIFIER=identifier)) # Load the file r.TH1.AddDirectory(False) scanFile = r.TFile(filename, "READ") if not scanFile.IsOpen(): raise IOError( "iterativeTrim(): File {0} is not open or is not readable". format(filename)) if scanFile.IsZombie(): raise IOError( "iterativeTrim(): File {0} is a zombie".format(filename)) # Determine vfatID list_bNames = ['vfatN', 'vfatID'] array_vfatData = rp.tree2array(tree=scanFile.scurveFitTree, branches=list_bNames) array_vfatData = np.unique(array_vfatData) # Get scurve data for this arm dac value (used for boxplots) list_bNames = ['vfatCH', 'vfatN', 'threshold', 'noise'] scurveFitData = rp.tree2array(tree=scanFile.scurveFitTree, branches=list_bNames) scurveFitResults[ohN] = scurveFitData return scurveFitResults
help="String that defines the GEM variant, available from the list: {0}" .format(gemVariants.keys()), default="ge11") parser.add_argument( "--detType", type=str, help= "Detector type within gemType. If gemType is 'ge11' then this should be from list {0}; if gemType is 'ge21' then this should be from list {1}; and if type is 'me0' then this should be from the list {2}" .format(gemVariants['ge11'], gemVariants['ge21'], gemVariants['me0']), default=None) args = parser.parse_args() from gempython.utils.gemlogger import printRed if ((args.dacSelect not in maxVfat3DACSize.keys()) and (args.dacSelect is not None)): printRed("Input DAC selection {0} not understood".format( args.dacSelect)) printRed("possible options include:") from gempython.vfatqc.utils.qcutilities import printDACOptions printDACOptions() exit(os.EX_USAGE) # Open rpc connection to hw from gempython.vfatqc.utils.qcutilities import getCardName, inputOptionsValid cardName = getCardName(args.shelf, args.slot) from gempython.tools.vfat_user_functions_xhal import * vfatBoard = HwVFAT(cardName, 0, args.debug, args.gemType, args.detType) # Assign link 0; we will update later print 'opened connection' amcBoard = vfatBoard.parentOH.parentAMC if amcBoard.fwVersion < 3: printRed("DAC Scan of v2b electronics is not supported, exiting!!!")
# Make output directory from gempython.utils.wrappers import runCommand filePath = args.infilename.replace('.root','') runCommand(["mkdir", "-p", "{0}".format(filePath)]) runCommand(["chmod", "g+rw", "{0}".format(filePath)]) if args.vfatList is not None: vfatList = [int(vfat) for vfat in args.vfatList.split(",")] else: vfatList = None # Run Analysis from gempython.utils.gemlogger import printRed import os, sys, traceback try: args.func(args,args.infilename,args.calFile,args.GEBtype,filePath,vfatList) except RuntimeError as err: printRed("RuntimeError: {0}".format(err.message)) traceback.print_exc(file=sys.stdout) sys.exit(os.EX_SOFTWARE) except IOError as err: printRed("IOError: {0}".format(err.message)) traceback.print_exc(file=sys.stdout) sys.exit(os.EX_IOERR) else: print('Analysis Completed Successfully') finally: from gempython.gemplotting.utils.anautilities import cleanup cleanup( [filePath] )
def readBackCheckV3(rootTree, dict_Names, vfatBoard, mask=0x0, vt1bump=0): """ Given an input set of registers, and expected values of those registers, read from all VFATs on vfatBoard to see if there are any differences between written and read values. Specifically for v3 electronics rootTree - name of a TTree that has values that should have been written dict_Names - dictionary where key names are the branch names in rootTree and the values are the register names they correspond too vfatBoard - instance of the HwVFAT class mask - vfatmask to use, 24 bit number, if the n^th bit is 1 the n^th VFAT is not considered vt1bump - value that has been added to CFG_THR_ARM_DAC """ import numpy as np import root_numpy as rp import os, sys # Check that the requested register is supported list_KnownRegs = [ "CFG_PULSE_STRETCH", "CFG_SYNC_LEVEL_MODE", "CFG_SELF_TRIGGER_MODE", "CFG_DDR_TRIGGER_MODE", "CFG_SPZS_SUMMARY_ONLY", "CFG_SPZS_MAX_PARTITIONS", "CFG_SPZS_ENABLE", "CFG_SZP_ENABLE", "CFG_SZD_ENABLE", "CFG_TIME_TAG", "CFG_EC_BYTES", "CFG_BC_BYTES", "CFG_FP_FE", "CFG_RES_PRE", "CFG_CAP_PRE", "CFG_PT", "CFG_EN_HYST", "CFG_SEL_POL", "CFG_FORCE_EN_ZCC", "CFG_FORCE_TH", "CFG_SEL_COMP_MODE", "CFG_VREF_ADC", "CFG_MON_GAIN", "CFG_MONITOR_SELECT", "CFG_IREF", "CFG_THR_ZCC_DAC", "CFG_THR_ARM_DAC", "CFG_HYST", "CFG_LATENCY", "CFG_CAL_SEL_POL", "CFG_CAL_PHI", "CFG_CAL_EXT", "CFG_CAL_DAC", "CFG_CAL_MODE", "CFG_CAL_FS", "CFG_CAL_DUR", "CFG_BIAS_CFD_DAC_2", "CFG_BIAS_CFD_DAC_1", "CFG_BIAS_PRE_I_BSF", "CFG_BIAS_PRE_I_BIT", "CFG_BIAS_PRE_I_BLCC", "CFG_BIAS_PRE_VREF", "CFG_BIAS_SH_I_BFCAS", "CFG_BIAS_SH_I_BDIFF", "CFG_BIAS_SH_I_BFAMP", "CFG_BIAS_SD_I_BDIFF", "CFG_BIAS_SD_I_BSF", "CFG_BIAS_SD_I_BFCAS", "CFG_RUN", "HW_CHIP_ID", "VFAT_CHANNELS.CHANNEL"] for regName in dict_Names.values(): if regName not in list_KnownRegs: raise Exception("{2}readBackCheckV3() does not understand {0}; only supported for registers: {1}{3}".format(regName, list_KnownRegs,colors.RED,colors.ENDC),os.EX_USAGE) # Get data from tree list_bNames = dict_Names.keys() list_bNames.append('vfatN') if "mask" in dict_Names.keys() or "trimDAC" in dict_Names.keys() or "trimPolarity" in dict_Names.keys(): list_bNames.append('vfatCH') array_writeVals = rp.tree2array(tree=rootTree, branches=list_bNames) # Get data from VFATs for bName,regName in dict_Names.iteritems(): printBlue("Reading back (%s,%s) from all VFATs, any potential mismatches will be reported below"%(bName,regName)) print "="*40 regMap = [] regValues = [] if regName == "VFAT_CHANNELS.CHANNEL": #Channel Register regValues = getChannelRegisters(vfatBoard,mask) for vfat in range(0,24): if (mask >> vfat) & 0x1: continue for chan in range(0,128): writeValsPerVFAT = array_writeVals[ array_writeVals['vfatN'] == vfat] writeValsPerVFAT = writeValsPerVFAT[ writeValsPerVFAT['vfatCH'] == chan] writeValOfReg = np.asscalar(writeValsPerVFAT['%s'%bName]) if bName == "mask": if writeValOfReg != regValues[128*vfat+chan]['MASK']: printRed("VFAT%i Chan%i: %s mismatch, write val = %i, readback = %i"%(vfat, chan, bName, writeValOfReg, regValues[128*vfat+chan]['MASK'])) elif bName == "trimDAC": if writeValOfReg != regValues[128*vfat+chan]['ARM_TRIM_AMPLITUDE']: printRed("VFAT%i Chan%i: %s mismatch, write val = %i, readback = %i"%(vfat, chan, bName, writeValOfReg, regValues[128*vfat+chan]['ARM_TRIM_AMPLITUDE'])) elif bName == "trimPolarity": if writeValOfReg != regValues[128*vfat+chan]['ARM_TRIM_POLARITY']: printRed("VFAT%i Chan%i: %s mismatch, write val = %i, readback = %i"%(vfat, chan, bName, writeValOfReg, regValues[128*vfat+chan]['ARM_TRIM_POLARITY'])) elif regName == "HW_CHIP_ID": #ChipID regValues = vfatBoard.getAllChipIDs(mask) for vfat,readBackVal in enumerate(regValues): if (mask >> vfat) & 0x1: continue valsPerVFAT = array_writeVals[ array_writeVals['vfatN'] == vfat] valOfReg = int(np.asscalar(np.unique(valsPerVFAT['%s'%bName]))) if valOfReg != readBackVal: printRed("VFAT%i: %s mismatch, expected = %s, readback = %s"%(vfat, regName, hex(valOfReg), hex(readBackVal))) else: #VFAT Register regValues = vfatBoard.readAllVFATs(regName, mask) for vfat,readBackVal in enumerate(regValues): if (mask >> vfat) & 0x1: continue writeValsPerVFAT = array_writeVals[ array_writeVals['vfatN'] == vfat] writeValOfReg = np.asscalar(writeValsPerVFAT['%s'%bName]) if regName == "CFG_THR_ARM_DAC": writeValOfReg+=vt1bump if writeValOfReg != readBackVal: printRed("VFAT%i: %s mismatch, write val = %i, readback = %i"%(vfat, regName, writeValOfReg, readBackVal)) return
def configure(args, vfatBoard): """ Configures the front-end detector args - namespace returned by ArgumentParser::parse_args(), expects to contain following fields: applyMasks - If True channel masks in chConfig will be applied chConfig - Text file containing the channel configuration register information compare - If True only compares provided config file(s) with currently loaded parameters in frontend, does not write debug - Prints additional debugging information filename - TFile containing the scurveFitTree, used in writing channel registers run - Places front-end ASIC into run mode if true vt1 - For V3 (V2) electronics this is CFG_THR_ARM_DAC (VThreshold1) value to write vt1bump - Adds this value to the CFG_THR_ARM_DAC or VThreshold1 value that will be written vt2 - For V3 (V2) electronics this is not used (VThreshold2 value to write) vfatConfig - For V3 (V2) electronics contains CFG_THR_ARM_DAC (VThreshold1 & trimRange) values to write per VFAT vfatmask - 24 bit number specifying which vfats to mask, a 1 in the N^th bit means ignore that vfat zeroChan - Sets all bits of all channel registers to 0 vfatBoard - An instance of HwVFAT class """ shelf = vfatBoard.parentOH.parentAMC.getShelf() slot = vfatBoard.parentOH.parentAMC.getSlot() ohN = vfatBoard.parentOH.link ohKey = (shelf,slot,ohN) from gempython.gemplotting.mapping.chamberInfo import chamber_vfatDACSettings if ohKey in chamber_vfatDACSettings.keys(): print "Configuring VFATs on (shelf{0}, slot{1}, OH{2}) with chamber_vfatDACSettings dictionary values".format(shelf,slot,ohN) for key in chamber_vfatDACSettings[ohKey]: vfatBoard.paramsDefVals[key] = chamber_vfatDACSettings[ohKey][key] vfatBoard.biasAllVFATs(args.vfatmask) print 'biased VFATs on (shelf{0}, slot{1}, OH{2})'.format(shelf,slot,ohN) if not args.compare: vfatBoard.setVFATThresholdAll(args.vfatmask, args.vt1, args.vt2) if vfatBoard.parentOH.parentAMC.fwVersion > 2: print('Set CFG_THR_ARM_DAC to %i'%args.vt1) else: print('Set VThreshold1 to %i'%args.vt1) print('Set VThreshold2 to %i'%args.vt2) if args.run: vfatBoard.setRunModeAll(args.vfatmask, True) print 'VFATs on (shelf{0}, slot{1}, OH{2}) set to run mode'.format(shelf,slot,ohN) else: vfatBoard.setRunModeAll(args.vfatmask, False) import ROOT as r if args.filename: try: inF = r.TFile(args.filename) chTree = inF.Get("scurveFitTree") if not args.compare: print 'Configuring Channel Registers on (shelf{0}, slot{1}, OH{2}) based on {3}'.format(shelf,slot,ohN, args.filename) setChannelRegisters(vfatBoard, chTree, args.vfatmask, args.applyMasks) dict_readBack = {} if vfatBoard.parentOH.parentAMC.fwVersion > 2: dict_readBack = { "trimDAC":"VFAT_CHANNELS.CHANNEL", "trimPolarity":"VFAT_CHANNELS.CHANNEL", "vfatID":"HW_CHIP_ID" } if args.applyMasks: dict_readBack["mask"]="VFAT_CHANNELS.CHANNEL" print 'Comparing Currently Stored Channel Registers with %s'%args.chConfig readBackCheckV3(chTree, dict_readBack, vfatBoard, args.vfatmask) except IOError as e: printRed( '%s does not seem to exist'%args.filename ) printRed( e ) exit(os.EX_IOERR) if args.chConfig: try: chTree = r.TTree('chTree','Tree holding Channel Configuration Parameters') chTree.ReadFile(args.chConfig) if not args.compare: print 'Configuring Channel Registers on (shelf{0}, slot{1}, OH{2}) based on {3}'.format(shelf,slot,ohN,args.chConfig) setChannelRegisters(vfatBoard, chTree, args.vfatmask, args.applyMasks) dict_readBack = {} if vfatBoard.parentOH.parentAMC.fwVersion > 2: dict_readBack = { "trimDAC":"VFAT_CHANNELS.CHANNEL", "trimPolarity":"VFAT_CHANNELS.CHANNEL", "vfatID":"HW_CHIP_ID" } if args.applyMasks: dict_readBack["mask"]="VFAT_CHANNELS.CHANNEL" print 'Comparing Currently Stored Channel Registers on (shelf{0}, slot{1}, OH{2}) with {3}'.format(shelf,slot,ohN,args.chConfig) readBackCheckV3(chTree, dict_readBack, vfatBoard, args.vfatmask) except IOError as e: printRed( '%s does not seem to exist'%args.filename ) printRed( e ) exit(os.EX_IOERR) if args.zeroChan: print("zero'ing all channel registers on (shelf{0}, slot{1}, OH{2})".format(shelf,slot,ohN)) rpcResp = vfatBoard.setAllChannelRegisters(vfatMask=args.vfatmask) if rpcResp != 0: raise Exception("{0}RPC response was non-zero, zero'ing all channel registers failed{1}".format(colors.RED,colors.ENDC)) pass if args.vfatConfig: try: vfatTree = r.TTree('vfatTree','Tree holding VFAT Configuration Parameters') vfatTree.ReadFile(args.vfatConfig) if not args.compare: print 'Configuring VFAT Registers on (shelf{0}, slot{1}, OH{2}) based on {3}'.format(shelf,slot,ohN,args.vfatConfig) for event in vfatTree : # Skip masked vfats if (args.vfatmask >> int(event.vfatN)) & 0x1: continue # Tell user whether CFG_THR_ARM_DAC or VThreshold1 is being written if vfatBoard.parentOH.parentAMC.fwVersion > 2: print 'Set link %d VFAT%d CFG_THR_ARM_DAC to %i'%(ohN,event.vfatN,event.vt1+args.vt1bump) else: print 'Set link %d VFAT%d VThreshold1 to %i'%(ohN,event.vfatN,event.vt1+args.vt1bump) # Write CFG_THR_ARM_DAC or VThreshold1 vfatBoard.setVFATThreshold(chip=int(event.vfatN), vt1=int(event.vt1+args.vt1bump)) # Write trimRange (only supported for v2b electronics right now) if not (vfatBoard.parentOH.parentAMC.fwVersion > 2): vfatBoard.writeVFAT(int(event.vfatN), "ContReg3", int(event.trimRange),args.debug) if vfatBoard.parentOH.parentAMC.fwVersion > 2: print 'Comparing Curently Stored VFAT Registers on (shelf{0}, slot{1}, OH{2}) with {3}'.format(shelf,slot,ohN,args.vfatConfig) #dict_readBack = { "vfatID":"HW_CHIP_ID", "vt1":"CFG_THR_ARM_DAC" } # Future refactoring of gemplotting will include this dict_readBack = { "vt1":"CFG_THR_ARM_DAC" } readBackCheckV3(vfatTree, dict_readBack, vfatBoard, args.vfatmask, args.vt1bump) except IOError as e: printRed( '%s does not seem to exist'%args.filename ) printRed( e ) exit(os.EX_IOERR) pass pass return
sbitSize[0] = ((word >> 11) & 0x7) chHitPerCluster[0] = 2*(sbitSize[0]+1) L1Delay[0] = ((word >> 14) & 0xFFF) eta = vfat_to_etaphi[vfatN[0]][0] phi = vfat_to_etaphi[vfatN[0]][1] # SBIT always includes doublet of adjacent channels vfatCH[0] = 2*(sbitAddr % 64) vfatCH[1] = vfatCH[0] + 1 strip[0] = vfat_ch_strips[vfatN[0]]['Strip'][vfatCH[0]] strip[1] = vfat_ch_strips[vfatN[0]]['Strip'][vfatCH[1]] # In case of wrong mapping adjacent channels may not be adjacent strips, which is physically inconsistent if(np.abs(strip[0] - strip[1]) > 1): if args.debug: printRed("WARNING: not adjacent strips") # filling vfat 1Dhistos vfat_h_strip[vfatN[0]].Fill(strip[0]) vfat_h_strip[vfatN[0]].Fill(strip[1]) vfat_h_ch[vfatN[0]].Fill(vfatCH[0]) vfat_h_ch[vfatN[0]].Fill(vfatCH[1]) vfat_h_delay[vfatN[0]].Fill(L1Delay[0]) vfat_h_sbitSize[vfatN[0]].Fill(sbitSize[0]) # filling ieta 1Dhistos ieta_h_strip[eta].Fill((phi-1)*maxChans+strip[0]) ieta_h_strip[eta].Fill((phi-1)*maxChans+strip[1]) ieta_h_ch[eta].Fill((phi-1)*maxChans+vfatCH[0]) ieta_h_ch[eta].Fill((phi-1)*maxChans+vfatCH[1]) ieta_h_delay[eta].Fill(L1Delay[0])
def readBackCheck(rootTree, dict_Names, device, gtx, vt1bump=0): """ Given an input set of registers, and expected values of those registers, read from all VFATs on device.gtx to see if there are any differences between written and read values. rootTree - name of a TTree that has values that should have been written dict_Names - dictionary where key names are the branch names in rootTree and the values are the register names they correspond too device - optohybrid the vfats belong to that you want to check gtx - link of this optohybrid """ import numpy as np import root_numpy as rp import sys # Check that the requested register is supported list_KnownRegs = parameters.defaultValues.keys() list_KnownRegs.append("VThreshold1") list_KnownRegs.append("VFATChannels.ChanReg") list_KnownRegs.append("ChipID") for regName in dict_Names.values(): if regName not in list_KnownRegs: raise Exception("{2}readBackCheck() does not understand {0}; only supported for registers: {1}{3}".format(regName, list_KnownRegs,colors.RED,colors.ENDC),os.EX_USAGE) # Get data from tree list_bNames = dict_Names.keys() list_bNames.append('vfatN') list_bNames.append('vfatID') if "trimDAC" in dict_Names.keys() or "mask" in dict_Names.keys(): list_bNames.append('vfatCH') array_writeVals = rp.tree2array(tree=rootTree, branches=list_bNames) # Get data from VFATs perreg = "0x%02x" for bName,regName in dict_Names.iteritems(): printBlue("Reading back (%s,%s) from all VFATs, any potential mismatches will be reported below"%(bName,regName)) print "="*40 regMap = [] regValues = [] if regName == "VFATChannels.ChanReg": #Channel Register, use 0x1f for chan in range(0,128): regValues = readAllVFATs(device, gtx, regName+"%d"%(chan), 0x0) #regMap = map(lambda chip: chip&0x1f, regValues) for vfat,readBackVal in enumerate(regValues): writeValsPerVFAT = array_writeVals[ array_writeVals['vfatN'] == vfat] writeValsPerVFAT = writeValsPerVFAT[ writeValsPerVFAT['vfatCH'] == chan] writeValOfReg = np.asscalar(writeValsPerVFAT['%s'%bName]) if bName == "mask": if writeValOfReg != ((readBackVal&0x20)%31): #trimDAC goes from 0 -> 31, leftover is mask printRed("VFAT%i Chan%i: %s mismatch, write val = %i, readback = %i"%(vfat, chan, bName, writeValOfReg, (readBackVal&0x20)%31)) else: if writeValOfReg != (readBackVal&0x1f): printRed("VFAT%i Chan%i: %s mismatch, write val = %i, readback = %i"%(vfat, chan, bName, writeValOfReg, readBackVal&0x1f)) elif regName == "ChipID": #ChipID regValues = getAllChipIDs(device, gtx, 0x0) # dict of { vfatN:chipID } for vfat in regValues: valsPerVFAT = array_writeVals[ array_writeVals['vfatN'] == vfat] valOfReg = int(np.asscalar(np.unique(valsPerVFAT['%s'%bName]))) if valOfReg != regValues[vfat]: printRed("VFAT%i: %s mismatch, expected = %s, readback = %s"%(vfat, regName, hex(valOfReg), hex(regValues[vfat]))) else: #VFAT Register, use 0xff regValues = readAllVFATs(device, gtx, regName, 0x0) regMap = map(lambda chip: chip&0xff, regValues) for vfat,readBackVal in enumerate(regMap): writeValsPerVFAT = array_writeVals[ array_writeVals['vfatN'] == vfat] writeValOfReg = np.asscalar(writeValsPerVFAT['%s'%bName]) if regName == "VThreshold1": writeValOfReg+=vt1bump if writeValOfReg != readBackVal: printRed("VFAT%i: %s mismatch, write val = %i, readback = %i"%(vfat, regName, writeValOfReg, readBackVal)) return
if args.zeroChan: configType |= 0x8 pass # consider only the shelf of interest from gempython.gemplotting.mapping.chamberInfo import chamber_config chambers2Configure = {} for ohKey, cName in chamber_config.iteritems(): if args.shelf == ohKey[0]: chambers2Configure[ohKey] = cName pass pass from gempython.utils.gemlogger import printRed if (len(chambers2Configure) == 0): printRed("No chambers for shelf{0} exist".format(args.shelf)) printRed("Nothing to do, exiting") exit(os.EX_USAGE) import itertools if args.debug: print list( itertools.izip([ohKey[0] for ohKey in chambers2Configure], [ohKey[1] for ohKey in chambers2Configure], [ohKey[2] for ohKey in chambers2Configure], [args.run for ohKey in chambers2Configure], [args.armDAC for ohKey in chambers2Configure], [args.armDACBump for ohKey in chambers2Configure], [configType for ohKey in chambers2Configure], [ chambers2Configure[ohKey] for ohKey in chambers2Configure.keys()
from gempython.gemplotting.utils.threshAlgos import calibrateThrDAC from gempython.utils.gemlogger import printGreen, printRed from gempython.utils.wrappers import runCommand from gempython.gemplotting.utils.namespace import Namespace import os, sys, traceback ns = Namespace(inputFile=args.inputFile, fitRange=args.fitRange, listOfVFATs=args.listOfVFATs, maxEffPedPercent=args.maxEffPedPercent, highNoiseCut=args.highNoiseCut, deadChanCutLow=args.deadChanCutLow, deadChanCutHigh=args.deadChanCutHigh, noLeg=args.noLeg, outputDir=outputDir, savePlots=args.savePlots, debug=args.debug) try: retCode = calibrateThrDAC(ns) except IOError as err: printRed("IOError: {0}".format(err.message)) printRed("Analysis failed with error code {0}".format(retCode)) traceback.print_exc(file=sys.stdout) sys.exit(os.EX_IOERR) else: printGreen("Analysis completed successfully") finally: from gempython.gemplotting.utils.anautilities import cleanup cleanup([outputDir])
args = parser.parse_args() from gempython.gemplotting.utils.anautilities import getDataPath dataPath = getDataPath() import logging from gempython.utils.gemlogger import getGEMLogger gemlogger = getGEMLogger(__name__) gemlogger.setLevel(logging.ERROR) import os, sys from gempython.gemplotting.mapping.chamberInfo import chamber_config from gempython.utils.wrappers import runCommand if args.chConfigScandate is None and args.vfatConfigScandate is None: printRed( "No scandates provided for either chConfig or vfatConfig. Nothing to do, exiting" ) sys.exit(os.EX_USAGE) if args.chConfigScandate is not None: chConfigDict = getChConfigFileDict(chamber_config, args.chConfigScandate, args.debug, not args.updatedChConfig, args.trimChConfig) for cName, chConfig in chConfigDict.iteritems(): cmd = [ "ln", "-sf", chConfig, "{}/configs/chConfig_{}.txt".format(dataPath, cName) ] runCommand(cmd) pass pass
# Make output directory from gempython.utils.wrappers import runCommand filePath = args.infilename.replace('.root', '') runCommand(["mkdir", "-p", "{0}".format(filePath)]) runCommand(["chmod", "g+rw", "{0}".format(filePath)]) # Run Analysis from gempython.utils.gemlogger import printRed import os, sys, traceback try: args.func(infilename=args.infilename, debug=args.debug, latSigMaskRange=args.latSigMaskRange, latSigRange=args.latSigRange, outputDir=filePath, outfilename=args.outfilename, performFit=args.performFit) except IndexError as err: printRed("IndexError: {0}".format(err.message)) traceback.print_exc(file=sys.stdout) sys.exit(os.EX_SOFTWARE) except IOError as err: printRed("IOError: {0}".format(err.message)) traceback.print_exc(file=sys.stdout) sys.exit(os.EX_IOERR) else: print('Analysis Completed Successfully') finally: from gempython.gemplotting.utils.anautilities import cleanup cleanup([filePath])
args = parser.parse_args() # Load the input file import ROOT as r inF = r.TFile(args.inputfile,"READ") # Set default histogram behavior r.TH1.SetDefaultSumw2(False) r.gROOT.SetBatch(True) r.gStyle.SetOptStat(1111111) # Check if file loaded okay from gempython.utils.gemlogger import colors, printGreen, printRed, printYellow import os if not inF.IsOpen() or inF.IsZombie(): printRed("File {0} did not load properly, exiting".format(args.inputfile)) exit(os.EX_IOERR) pass # Determine layer if args.allLayers: plotTimeSeriesHV(args,"Top") args.update=True plotTimeSeriesHV(args,"Bot") elif args.bot: plotTimeSeriesHV(args,"Bot") elif args.top: plotTimeSeriesHV(args,"Top") pass print("Goodbye")