def __init__(self):
super(ScanDataFitter, self).__init__()
from gempython.utils.nesteddict import nesteddict as ndict
r.gStyle.SetOptStat(0)
self.scanHistos = ndict()
self.scanCount = ndict()
self.scanFits = ndict()
for vfat in range(0, 24):
self.scanFits[0][vfat] = np.zeros(128)
self.scanFits[1][vfat] = np.zeros(128)
self.scanFits[2][vfat] = np.zeros(128)
self.scanFits[3][vfat] = np.zeros(128)
self.scanFits[4][vfat] = np.zeros(128)
self.scanFits[5][vfat] = np.zeros(128)
self.scanFits[6][vfat] = np.zeros(128, dtype=bool)
for ch in range(0, 128):
self.scanHistos[vfat][ch] = r.TH1D(
'scurve_%i_%i_h' % (vfat, ch),
'scurve_%i_%i_h' % (vfat, ch), 254, 0.5, 254.5)
self.scanCount[vfat][ch] = 0
self.fitValid = [np.zeros(128, dtype=bool) for vfat in range(24)]
self.Nev = -1
def __init__(self):
super(ScanDataFitter, self).__init__()
from gempython.utils.nesteddict import nesteddict as ndict
r.gStyle.SetOptStat(0)
self.scanFuncs = ndict()
self.scanHistos = ndict()
self.scanCount = ndict()
self.scanFits = ndict()
for vfat in range(0,24):
self.scanFits[0][vfat] = np.zeros(128)
self.scanFits[1][vfat] = np.zeros(128)
self.scanFits[2][vfat] = np.zeros(128)
self.scanFits[3][vfat] = np.zeros(128)
self.scanFits[4][vfat] = np.zeros(128)
self.scanFits[5][vfat] = np.zeros(128)
self.scanFits[6][vfat] = np.zeros(128, dtype=bool)
for ch in range(0,128):
self.scanFuncs[vfat][ch] = r.TF1('scurveFit_vfat%i_chan%i'%(vfat,ch),'[3]*TMath::Erf((TMath::Max([2],x)-[0])/(TMath::Sqrt(2)*[1]))+[3]',1,253)
self.scanHistos[vfat][ch] = r.TH1D('scurve_vfat%i_chan%i_h'%(vfat,ch),'scurve_vfat%i_chan%i_h'%(vfat,ch),254,0.5,254.5)
self.scanCount[vfat][ch] = 0
self.fitValid = [ np.zeros(128, dtype=bool) for vfat in range(24) ]
self.Nev = -1
def __init__(self, calDAC2Q_m=None, calDAC2Q_b=None, isVFAT3=False):
"""
calDAC2Q_m - list of slope values for "fC = m * cal_dac + b" equation, ordered by vfat position
calDAC2Q_b - as calDAC2Q_m but for intercept b
isVFAT3 - if using VFAT3
"""
super(ScanDataFitter, self).__init__()
from gempython.utils.nesteddict import nesteddict as ndict
r.gStyle.SetOptStat(0)
self.Nev = ndict()
self.scanFuncs = ndict()
self.scanHistos = ndict()
self.scanCount = ndict()
self.scanFitResults = ndict()
self.isVFAT3 = isVFAT3
self.calDAC2Q_m = np.ones(24)
if calDAC2Q_m is not None:
self.calDAC2Q_m = calDAC2Q_m
self.calDAC2Q_b = np.zeros(24)
if calDAC2Q_b is not None:
self.calDAC2Q_b = calDAC2Q_b
for vfat in range(0, 24):
self.scanFitResults[0][vfat] = np.zeros(128)
self.scanFitResults[1][vfat] = np.zeros(128)
self.scanFitResults[2][vfat] = np.zeros(128)
self.scanFitResults[3][vfat] = np.zeros(128)
self.scanFitResults[4][vfat] = np.zeros(128)
self.scanFitResults[5][vfat] = np.zeros(128)
self.scanFitResults[6][vfat] = np.zeros(128, dtype=bool)
for ch in range(0, 128):
self.scanCount[vfat][ch] = 0
self.scanFuncs[vfat][ch] = r.TF1(
'scurveFit_vfat%i_chan%i' % (vfat, ch),
'[3]*TMath::Erf((TMath::Max([2],x)-[0])/(TMath::Sqrt(2)*[1]))+[3]',
self.calDAC2Q_m[vfat] * 1 + self.calDAC2Q_b[vfat],
self.calDAC2Q_m[vfat] * 253 + self.calDAC2Q_b[vfat])
self.scanHistos[vfat][ch] = r.TH1D(
'scurve_vfat%i_chan%i_h' % (vfat, ch),
'scurve_vfat%i_chan%i_h' % (vfat, ch), 254,
self.calDAC2Q_m[vfat] * 0.5 + self.calDAC2Q_b[vfat],
self.calDAC2Q_m[vfat] * 254.5 + self.calDAC2Q_b[vfat])
self.fitValid = [np.zeros(128, dtype=bool) for vfat in range(24)]
return
filename = options.filename[:-5]
os.system("mkdir " + filename)
print filename
outfilename = options.outfilename
import ROOT as r
r.TH1.SetDefaultSumw2(False)
r.gROOT.SetBatch(True)
inF = r.TFile(filename+'.root')
outF = r.TFile(filename+'/'+outfilename, 'recreate')
VT1_MAX = 256
print 'Initializing Histograms'
vRate = ndict()
vRate2D = ndict()
for vfat in range(0,24):
#1D distribution
vRate[vfat] = r.TH1D("h_Rate_vs_vthr_VFAT%i"%vfat,"VFAT%i;CFG_THR_ARM_DAC #left[DAC Units#right];Rate #left(Hz#right)"%vfat,VT1_MAX+1,-0.5,VT1_MAX+0.5)
vRate[vfat].GetXaxis().SetRangeUser(1e-1,1e9)
#2D distribution
vRate2D[vfat] = r.TH2D("h2DRate_vthr_vs_chan_VFAT%i"%vfat,"VFAT%i;vfatCH;CFG_THR_ARM_DAC #left[DAC Units#right];Rate #left(Hz#right)"%vfat,128,-0.5,127.5,VT1_MAX+1,-0.5,VT1_MAX+0.5)
vRate2D[vfat].GetYaxis().SetRangeUser(1e-1,1e9)
print 'Filling Histograms'
for event in inF.rateTree :
if event.vfatCH == 128:
vRate[event.vfatN].Fill(event.vth,event.Rate)
else:
args.detType) # Set a dummy link for now
amcBoard = vfatBoard.parentOH.parentAMC
print('opened connection')
import os
if amcBoard.fwVersion < 3:
print(
"temperature monitoring of v2b electronics is not supported, exiting!!!"
)
exit(os.EX_USAGE)
print("Getting VFAT Mask for All Links")
ohVFATMaskArray = amcBoard.getMultiLinkVFATMask(args.ohMask)
print("Getting CHIP IDs of all VFATs")
from gempython.utils.nesteddict import nesteddict as ndict
vfatIDvals = ndict()
for ohN in range(0, 12):
if (not ((args.ohMask >> ohN) & 0x1)):
continue
vfatBoard.parentOH.link = ohN
vfatIDvals[ohN] = vfatBoard.getAllChipIDs(ohVFATMaskArray[ohN])
# Configure DAC Monitoring
print("configuring VFAT ADCs for temperature monitoring")
tempSelect = 37
if args.extTempVFAT:
tempSelect = 38
amcBoard.configureVFAT3DacMonitorMulti(tempSelect, args.ohMask)
print("VFAT ADCs have been configured for temperature monitoring")
print("Enabling SCA Monitoring")
def plotTimeSeriesHV(args,qc8layer):
"""
Makes time series plots of DCS data points
args - namespace obtained from parsing the instane of ArgumentParser in main
layer - string, either "top" or "bot"
"""
# Define known constants
knownLayers = [ "Top", "Bot" ]
knownElectrodes = []
for idx in range(1,4):
for layer in knownLayers:
knownElectrodes.append("G{0}{1}".format(idx,layer))
pass
pass
knownElectrodes.append("Drift")
knownObs = [ "Imon", "Vmon", "Status" ]
if qc8layer not in knownLayers:
raise RuntimeError("Layer '{0}' not understood, known values are {1}".format(qc8layer,knownLayers))
# Try to load all histograms
# ===================================================
cName = "Chamber{0}_{1}_{2}".format(args.row,args.column,qc8layer)
from gempython.gemplotting.utils.anautilities import getCyclicColor
from gempython.utils.nesteddict import nesteddict as ndict
dict_dcsPlots = ndict() # ["Electrode"]["Obs"] = TObject
dict_legend = {} # [Obs] = TLegend
for idx,electrode in enumerate(knownElectrodes):
for obsData in knownObs:
dirName = "{0}/Channel{1}".format(cName,electrode)
plotName= "HV_{0}{1}_{2}_UTC_time".format(obsData,cName,electrode)
try:
dict_dcsPlots[electrode][obsData] = inF.Get("{0}/{1}".format(dirName,plotName))
if args.debug:
print("Loaded plot: {0}/{1}".format(dirName,plotName))
except AttributeError as error:
printYellow("Distribution '{0}' not found in input file {1}. Skipping this distribution".format(
plotName,
args.inputfile))
continue
dict_dcsPlots[electrode][obsData].SetLineColor(getCyclicColor(idx))
dict_dcsPlots[electrode][obsData].SetMarkerColor(getCyclicColor(idx))
if obsData == "Vmon" or obsData == "Status":
dict_dcsPlots[electrode][obsData].GetYaxis().SetRangeUser(0,1e3)
if obsData == "Vmon":
dict_dcsPlots[electrode][obsData].GetYaxis().SetTitle("Vmon #left(V #right)")
elif obsData == "Imon":
dict_dcsPlots[electrode][obsData].GetYaxis().SetRangeUser(-2,2)
dict_dcsPlots[electrode][obsData].GetYaxis().SetTitle("Imon #left(uA #right)")
if obsData in dict_legend.keys():
dict_legend[obsData].AddEntry(dict_dcsPlots[electrode][obsData],electrode,"LPE")
else:
dict_legend[obsData] = r.TLegend(0.7,0.75,0.9,0.9)
dict_legend[obsData].AddEntry(dict_dcsPlots[electrode][obsData],electrode,"LPE")
pass
pass
# Make output TCanvas objects - All Electrodes on one TCanvas per Observable
# ===================================================
dict_dcsCanvas = {} # ["Obs"] = TObject
for obsData in knownObs:
dict_dcsCanvas[obsData] = r.TCanvas("canv_{0}_{1}".format(obsData,cName),"{0}: {1}".format(cName,obsData),900,900)
pass
# Draw the observable onto the corresponding canvas
for obsData in knownObs:
drawOpt = None
dict_dcsCanvas[obsData].cd()
for electrode in knownElectrodes:
if drawOpt is None:
dict_dcsPlots[electrode][obsData].Draw("ALPE1")
drawOpt = "sameLPE1"
else:
dict_dcsPlots[electrode][obsData].Draw(drawOpt)
pass
pass
dict_legend[obsData].Draw("same")
pass
# Make output TCanvas objects - All observables on one TCanvas per Electrode
# ===================================================
dict_electrodeCanvas = {} # ["Electrode"] = TObject
for electrode in knownElectrodes:
dict_electrodeCanvas[electrode] = r.TCanvas("canv_{0}_{1}".format(electrode,cName),"{0}: {1}".format(cName,electrode),900,1800)
dict_electrodeCanvas[electrode].Divide(1,3)
# Draw the observable onto the corresponding canvas
for electrode in knownElectrodes:
for idx,obsData in enumerate(knownObs):
dict_electrodeCanvas[electrode].cd(idx+1)
dict_dcsPlots[electrode][obsData].Draw("ALPE1")
pass
pass
# Make output TCanvas Objects - All electrodes and all observables on one TCanvas
# ===================================================
canv_Summary = r.TCanvas("canv_Summary_{0}".format(cName),"{0}: Summary".format(cName), 900,1800)
canv_Summary.Divide(1,3)
# Draw the observable onto the corresponding canvas
for idx,obsData in enumerate(knownObs):
drawOpt = None
canv_Summary.cd(idx+1)
for electrode in knownElectrodes:
if drawOpt is None:
dict_dcsPlots[electrode][obsData].Draw("ALPE1")
drawOpt = "sameLPE1"
else:
dict_dcsPlots[electrode][obsData].Draw(drawOpt)
pass
pass
dict_legend[obsData].Draw("same")
pass
# Make an output TFile
# ===================================================
if args.update:
rootOpt = "UPDATE"
else:
rootOpt = "RECREATE"
from gempython.gemplotting.utils.anautilities import getElogPath
elogPath = getElogPath()
if args.outfilename is None:
outF = r.TFile("{0}/DCS_Plots.root".format(elogPath),rootOpt)
else:
outF = r.TFile(args.outfilename,rootOpt)
pass
#thisDir = outF.mkdir(cName)
outF.mkdir(cName)
thisDir = outF.GetDirectory(cName)
thisDir.cd()
canv_Summary.Write()
canv_Summary.SaveAs("{0}/{1}.png".format(elogPath,canv_Summary.GetName()))
for obsData in knownObs:
dict_dcsCanvas[obsData].Write()
dict_dcsCanvas[obsData].SaveAs("{0}/{1}.png".format(elogPath,dict_dcsCanvas[obsData].GetName()))
pass
for electrode in knownElectrodes:
dict_electrodeCanvas[electrode].Write()
dict_electrodeCanvas[electrode].SaveAs("{0}/{1}.png".format(elogPath,dict_electrodeCanvas[electrode].GetName()))
pass
return
ohboard = getOHObject(options.slot, options.gtx, options.shelf, options.debug)
if options.dirPath == None:
dirPath = '%s/%s/trimming/z%f/%s' % (dataPath, chamber_config[options.gtx],
ztrim, startTime)
else:
dirPath = options.dirPath
# bias vfats
biasAllVFATs(ohboard, options.gtx, 0x0, enable=False)
writeAllVFATs(ohboard, options.gtx, "VThreshold1", options.vt1, 0)
CHAN_MIN = 0
CHAN_MAX = 128
masks = ndict()
for vfat in range(0, 24):
for ch in range(CHAN_MIN, CHAN_MAX):
masks[vfat][ch] = False
#Find trimRange for each VFAT
tRanges = ndict()
tRangeGood = ndict()
trimVcal = ndict()
trimCH = ndict()
goodSup = ndict()
goodInf = ndict()
for vfat in range(0, 24):
tRanges[vfat] = 0
tRangeGood[vfat] = False
trimVcal[vfat] = 0
# Get run number
fields = args.infile.split("_")
if "run" in fields[0]:
runNo = fields[0]
else:
runNo = "runUnknown"
pass
# Make output dir in $ELOG_PATH
from gempython.utils.wrappers import runCommand
runCommand(["mkdir", "{0}/{1}".format(elogPath, runNo)])
# Make nested containers
from gempython.utils.nesteddict import nesteddict as ndict
baseDir = ndict() # baseDir[slot][oh] -> string
vfatDirs = ["VFAT-{0}".format(x) for x in range(nVFATS)]
allVFATsLatency = ndict() # allVFATsLatency[slot][oh] -> histogram
dictMapping = ndict() # dictMapping[slot][oh] -> mapping dict
latencyMean = ndict() # latencyMean[slot][oh] -> histogram
latencyRMS = ndict() # latencyRMS[slot][oh] -> histogram
vfatHitMulti = ndict() # vfatHitMulti[slot][oh][vfatN] -> histogram
vfatLatHists = ndict() # vfatHists[slot][oh][vfatN] -> histogram
vfatLatHists2D = ndict() # vfatHists2D[slot][oh][vfatN] -> histogram
# Get channel mapping?
from gempython.gemplotting.utils.anautilities import getMapping, getSummaryCanvas
if args.mapping is not None:
print("Getting mapping")
# Try to get the mapping data
pan_lookup[int(mapping[0])][int(mapping[2]) - 1] = int(mapping[3])
if not (options.channels or options.PanPin): #Readout Strips
vfatCh_lookup[int(mapping[0])][int(mapping[1])] = int(mapping[2]) - 1
pass
elif options.channels: #VFAT Channels
vfatCh_lookup[int(mapping[0])][int(mapping[2]) -
1] = int(mapping[2]) - 1
pass
elif options.PanPin: #Panasonic Connector Pins
vfatCh_lookup[int(mapping[0])][int(mapping[3])] = int(mapping[2]) - 1
pass
pass
print 'Initializing Histograms'
vSum = ndict()
hot_channels = []
for vfat in range(0, 24):
hot_channels.append([])
if not (options.channels or options.PanPin):
vSum[vfat] = r.TH2D('vSum%i' % vfat,
'vSum%i;Strip;VThreshold1 [DAC units]' % vfat, 128,
-0.5, 127.5, VT1_MAX + 1, -0.5, VT1_MAX + 0.5)
pass
elif options.channels:
vSum[vfat] = r.TH2D('vSum%i' % vfat,
'vSum%i;Channel;VThreshold1 [DAC units]' % vfat,
128, -0.5, 127.5, VT1_MAX + 1, -0.5, VT1_MAX + 0.5)
pass
elif options.PanPin:
vSum[vfat] = r.TH2D(
startTime = datetime.datetime.now().strftime("%Y.%m.%d.%H.%M")
print startTime
ohboard = getOHObject(options.slot,options.gtx,options.shelf,options.debug)
if options.dirPath == None: dirPath = '%s/%s/trimming/z%f/%s'%(dataPath,chamber_config[options.gtx],ztrim,startTime)
else: dirPath = options.dirPath
# bias vfats
biasAllVFATs(ohboard,options.gtx,0x0,enable=False, debug=options.debug)
writeAllVFATs(ohboard, options.gtx, "VThreshold1", options.vt1, 0x0, options.debug)
CHAN_MIN = 0
CHAN_MAX = 128
masks = ndict()
for vfat in range(0,24):
for ch in range(CHAN_MIN,CHAN_MAX):
masks[vfat][ch] = False
#Find trimRange for each VFAT
tRanges = ndict()
tRangeGood = ndict()
trimVcal = ndict()
trimCH = ndict()
goodSup = ndict()
goodInf = ndict()
for vfat in range(0,24):
tRanges[vfat] = 0
tRangeGood[vfat] = False
trimVcal[vfat] = 0
supportedAnaTypes = ['scurveAna', 'trimAna']
if options.anaType not in supportedAnaTypes:
print("Invalid analysis specificed, please select only from the list:")
print(supportedAnaTypes)
exit(os.EX_USAGE)
pass
# Get info from input file
parsedTuple = parseListOfScanDatesFile(options.filename,
options.alphaLabels)
listChamberAndScanDate = parsedTuple[0]
# Define nested dictioniaries
# Outer key -> (chamberName,scandate) tuple
# Inner key -> vfat position
dict_fitSum = ndict()
dict_ScurveMean = ndict(
) # Inner key: (0,23) follows vfat #, -1 is summary over all det
dict_ScurveSigma = ndict()
dict_ScurveEffPed = ndict()
dict_ScurveMeanByiEta = ndict()
dict_ScurveSigmaByiEta = ndict()
# Get the plots from all files
for idx, chamberAndScanDatePair in enumerate(listChamberAndScanDate):
# Setup the path
dirPath = getDirByAnaType(options.anaType.strip("Ana"),
chamberAndScanDatePair[0], options.ztrim)
if not filePathExists(dirPath, chamberAndScanDatePair[1]):
print 'Filepath %s/%s does not exist!' % (
nameX='scurve mean #left(fC#right)',
nameY='ARM_TRIM_AMPLITUDE',
isGblDac=False,
description='Tree holding arming comparator trim data')
trimDacArmTree.setDefaults(options, thisTime)
calDacCalTree = gemDacCalTreeStructure(
name='calDacCalibration',
nameX='CFG_CAL_DAC',
nameY='charge #left(fC#right)',
storeRoot=True,
description='Tree holding CFG_CAL_DAC Calibration')
calDacCalTree.setDefaults(options, thisTime)
print("Determining trimDAC to fC Calibration")
dict_cal_trimDAC2fC_graph = ndict(
) # dict_cal_trimDAC2fC[vfat][chan] = TGraphErrors object
dict_cal_trimDAC2fC_func = ndict(
) # dict_cal_trimDAC2fC[vfat][chan] = TF1 object
for vfat in range(0, vfatsPerGemVariant[options.gemType]):
func_charge_vs_calDac = r.TF1(
"func_charge_vs_calDac_vfat%d" % (vfat), "[0]*x+[1]",
calDac2Q_Slope[vfat] * 253 + calDac2Q_Intercept[vfat],
calDac2Q_Slope[vfat] * 1 + calDac2Q_Intercept[vfat])
func_charge_vs_calDac.SetParameter(0, calDac2Q_Slope[vfat])
func_charge_vs_calDac.SetParameter(1, calDac2Q_Intercept[vfat])
calDacCalTree.fill(func_dacFit=func_charge_vs_calDac,
vfatID=vfatIDvals[vfat],
vfatN=vfat)
scurveMeansList = []
for chan in range(chMin, chMax):
from gempython.gemplotting.mapping.chamberInfo import gemTypeMapping
if 'gemType' not in inF.sbitDataTree.GetListOfBranches():
gemType = "ge11"
else:
gemType = gemTypeMapping[rp.tree2array(tree=inF.sbitDataTree, branches =[ 'gemType' ] )[0][0]]
print gemType
##### END
from gempython.tools.hw_constants import vfatsPerGemVariant
nVFATS = vfatsPerGemVariant[gemType]
from gempython.gemplotting.mapping.chamberInfo import CHANNELS_PER_VFAT as maxChans
print('Initializing histograms')
from gempython.utils.nesteddict import nesteddict as ndict, flatten
# Summary plots - 2D
dict_h_vfatObsVsVfatPulsed = ndict() #Keys as: [isValid][calEnable][rate]
# VFAT lvl plots - 1D
dict_h_sbitMulti = ndict() #Keys as: [isValid][calEnable][rate][vfat]
dict_h_sbitSize = ndict() #Keys as: [isValid][calEnable][rate][vfat]
# VFAT lvl plots - 2D
dict_g_rateObsCTP7VsRatePulsed = ndict() #Keys as: [isValid][vfat]
dict_g_rateObsFPGAVsRatePulsed = ndict() #Keys as: [isValid][vfat]
dict_g_rateObsVFATVsRatePulsed = ndict() #Keys as: [isValid][vfat]
dict_h_chanVsRatePulsed_ZRateObs = ndict() #Z axis is rate observed; Keys as: [isValid][calEnable][vfat]
dict_h_sbitObsVsChanPulsed = ndict() #Keys as: [isValid][calEnable][rate][vfat]
dict_h_sbitMultiVsSbitSize = ndict() #Keys as: [isValid][calEnable][rate][vfat]
rateMap = {}
from gempython.gemplotting.utils.anautilities import formatSciNotation
os.system("mkdir " + filename)
outfilename = options.outfilename
GEBtype = options.GEBtype
# Create the output File and TTree
outF = r.TFile(filename + '/' + outfilename, 'recreate')
if options.performFit:
myT = r.TTree('scurveFitTree', 'Tree Holding FitData')
tuple_calInfo = parseCalFile(options.calFile)
calDAC2Q_Slope = tuple_calInfo[0]
calDAC2Q_Intercept = tuple_calInfo[1]
# Create output plot containers
vSummaryPlots = ndict()
vSummaryPlotsPanPin2 = ndict()
vSummaryPlotsNoMaskedChan = ndict()
vSummaryPlotsNoMaskedChanPanPin2 = ndict()
vthr_list = getEmptyPerVFATList()
trim_list = getEmptyPerVFATList()
trimrange_list = getEmptyPerVFATList()
# Set default histogram behavior
r.TH1.SetDefaultSumw2(False)
r.gROOT.SetBatch(True)
r.gStyle.SetOptStat(1111111)
# Initialize distributions
for vfat in range(0, 24):
vSummaryPlots[vfat] = r.TH2D(
def compareLatResults(args):
# Suppress all pop-ups from ROOT
import ROOT as r
r.gROOT.SetBatch(True)
# Check Paths
import os, sys
from gempython.utils.wrappers import envCheck
envCheck('DATA_PATH')
envCheck('ELOG_PATH')
elogPath = os.getenv('ELOG_PATH')
# Get info from input file
from gempython.gemplotting.utils.anautilities import getCyclicColor, getDirByAnaType, filePathExists, make3x8Canvas, parseListOfScanDatesFile
parsedTuple = parseListOfScanDatesFile(args.filename,alphaLabels=args.alphaLabels)
listChamberAndScanDate = parsedTuple[0]
chamberName = listChamberAndScanDate[0][0]
legPlot = r.TLegend(0.5,0.5,0.9,0.9)
from gempython.utils.nesteddict import nesteddict as ndict
dict_Histos = ndict()
dict_Graphs = ndict()
dict_MultiGraphs = {}
print("Loading data from input list of scandates file")
from gempython.gemplotting.utils.anaInfo import tree_names
for idx,infoTuple in enumerate(listChamberAndScanDate):
# Setup the path
dirPath = getDirByAnaType("latency", infoTuple[0])
if not filePathExists(dirPath, infoTuple[1]):
print('Filepath {:s}/{:s} does not exist!'.format(dirPath, infoTuple[1]))
print('Please cross-check, exiting!')
sys.exit(os.EX_NOINPUT)
filename = "{:s}/{:s}/{:s}".format(dirPath, infoTuple[1], tree_names["latencyAna"][0])
if not os.path.isfile(filename):
print('File {:s} does not exist!'.format(filename))
print('Please cross-check, exiting!')
sys.exit(os.EX_NOINPUT)
# Load the file
r.TH1.AddDirectory(False)
scanFile = r.TFile(filename,"READ")
if scanFile.IsZombie():
print("{:s} is a zombie!!!".format(filename))
print("Please double check your input list of scandates: {:s}".format(args.filename))
print("And then call this script again")
raise IOError
###################
# Get individual distributions
###################
for vfat in range(24):
baseDir = "VFAT_Plots/VFAT{0:d}".format(vfat)
dict_Histos[infoTuple[2]][vfat] = scanFile.Get("{:s}/vfat{:d}HitsVsLat".format(baseDir,vfat))
dict_Graphs[infoTuple[2]][vfat] = scanFile.Get("{:s}/g_N_vs_Lat_VFAT{:d}".format(baseDir,vfat))
# Make the TMultiGraph Objects
suffix = "VFAT{:d}".format(vfat)
if idx == 0:
dict_MultiGraphs[vfat] = r.TMultiGraph("mGraph_RateVsThrDac_vfat{:s}".format(suffix),suffix)
# Set Style of TGraph
dict_Graphs[infoTuple[2]][vfat].SetLineColor(getCyclicColor(idx))
dict_Graphs[infoTuple[2]][vfat].SetMarkerColor(getCyclicColor(idx))
dict_Graphs[infoTuple[2]][vfat].SetMarkerStyle(20+idx)
dict_Graphs[infoTuple[2]][vfat].SetMarkerSize(0.8)
# Add to the MultiGraph
dict_MultiGraphs[vfat].Add(dict_Graphs[infoTuple[2]][vfat])
###################
# Make an entry in the TLegend
###################
if vfat == 0:
print("infoTuple[2] = ", infoTuple[2])
legPlot.AddEntry(
dict_Graphs[infoTuple[2]][vfat],
"{0}".format(infoTuple[2]),
"LPE")
pass
pass
###################
# Make output ROOT file
###################
outFileName = "{0}/compLatResults_{1}.root".format(elogPath,chamberName)
outFile = r.TFile(outFileName,"RECREATE")
###################
# Now Make plots
###################
print("Making output plots")
dict_canv = {}
for vfat in range(24):
# Make Output Canvas
dict_canv[vfat] = r.TCanvas("canvLatResults_VFAT{0}".format(vfat),"Hits vs. CFG_LATENCY Value",700,700)
dict_canv[vfat].cd()
dict_MultiGraphs[vfat].Draw("APE1")
dict_MultiGraphs[vfat].GetYaxis().SetTitle("Hits #left(A.U.#right)")
dict_MultiGraphs[vfat].GetYaxis().SetRangeUser(0,args.eventsPerLat) # max is 40 MHz
dict_MultiGraphs[vfat].GetXaxis().SetTitle("CFG_LATENCY #left(BX#right)")
dict_MultiGraphs[vfat].Draw("APE1")
# Draw Legend?
if not args.noLeg:
legPlot.Draw("same")
pass
# Make output image?
if args.savePlots:
dict_canv[vfat].SaveAs("{0}/{1}.png".format(elogPath,dict_canv[vfat].GetName()))
pass
# Store Output
thisDirectory = outFile.mkdir("VFAT{0}".format(vfat))
thisDirectory.cd()
dict_MultiGraphs[vfat].Write()
dict_canv[vfat].Write()
pass
# Make summary canvases, always save these
canvLatResults_Summary = make3x8Canvas("canvLatResults_Summary",dict_MultiGraphs.values()[0:24],"APE1")
# Draw Legend?
if not args.noLeg:
canvLatResults_Summary.cd(1)
legPlot.Draw("same")
pass
# Save summary canvases (always)
print("\nSaving Summary TCanvas Objects")
#canvLatResults_Summary.SaveAs("{0}/{1}.png".format(elogPath,canvLatResults_Summary.GetName()))
# Close output files
outFile.Close()
print("You can find all ROOT objects in:")
print("\n\t{0}//compLatResults_{1}.root\n".format(elogPath,chamberName))
print("You can find all plots in:")
print("\n\t{0}\n".format(elogPath))
print("Done")
return
myT.Branch( 'pedestal', pedestal, 'pedestal/F')
ped_eff = array( 'f', [ 0 ] )
myT.Branch( 'ped_eff', ped_eff, 'ped_eff/F')
scurve_h = r.TH1D()
myT.Branch( 'scurve_h', scurve_h)
scurve_fit = r.TF1()
myT.Branch( 'scurve_fit', scurve_fit)
chi2 = array( 'f', [ 0 ] )
myT.Branch( 'chi2', chi2, 'chi2/F')
ndf = array( 'i', [ 0 ] )
myT.Branch( 'ndf', ndf, 'ndf/I')
Nhigh = array( 'i', [ 0 ] )
myT.Branch( 'Nhigh', Nhigh, 'Nhigh/I')
pass
vSummaryPlots = ndict()
vSummaryPlotsPanPin2 = ndict()
vSummaryPlotsPruned = ndict()
vSummaryPlotsPrunedPanPin2 = ndict()
vScurves = []
vScurveFits = []
vthr_list = []
trim_list = []
trimrange_list = []
lines = []
for vfat in range(0,24):
vScurves.append([])
vScurveFits.append([])
vthr_list.append([])
trim_list.append([])
def compareSBitThreshResults(args):
# Suppress all pop-ups from ROOT
import ROOT as r
r.gROOT.SetBatch(True)
# Check Paths
import os, sys
from gempython.utils.wrappers import envCheck
envCheck('DATA_PATH')
envCheck('ELOG_PATH')
elogPath = os.getenv('ELOG_PATH')
# Get info from input file
from gempython.gemplotting.utils.anautilities import getCyclicColor, getDirByAnaType, filePathExists, getSummaryCanvas, parseArmDacCalFile, parseListOfScanDatesFile
parsedTuple = parseListOfScanDatesFile(args.filename,
alphaLabels=args.alphaLabels)
listChamberAndScanDate = parsedTuple[0]
chamberName = listChamberAndScanDate[0][0]
thrDacName = parsedTuple[1]
gemType = "ge11"
from gempython.tools.hw_constants import vfatsPerGemVariant
# Parse calibration file if present
arrayCalInfo = None
if args.calFileARM is not None:
arrayCalInfo = parseArmDacCalFile(
args.calFileARM,
gemType=gemType) # arrayCalInfo[i][vfatN] for coef of x^(4-i)
legPlot = r.TLegend(0.5, 0.5, 0.9, 0.9)
from gempython.utils.nesteddict import nesteddict as ndict
dict_Histos = ndict()
dict_Graphs = ndict()
dict_MultiGraphs = {}
for idx, infoTuple in enumerate(listChamberAndScanDate):
# Setup the path
dirPath = getDirByAnaType("sbitRateor", infoTuple[0])
if not filePathExists(dirPath, infoTuple[1]):
print('Filepath {:s}/{:s} does not exist!'.format(
dirPath, infoTuple[1]))
print('Please cross-check, exiting!')
sys.exit(os.EX_NOINPUT)
filename = "{:s}/{:s}/SBitRatePlots.root".format(dirPath, infoTuple[1])
# Load the file
r.TH1.AddDirectory(False)
scanFile = r.TFile(filename, "READ")
if scanFile.IsZombie():
print("{0} is a zombie!!!".format(filename))
print(
"Please double check your input list of scandates: {0}".format(
args.filename))
print("And then call this script again")
raise IOError
###################
# Get individual distributions
###################
for vfat in range(vfatsPerGemVariant[gemType]):
dict_Histos[infoTuple[2]][vfat] = scanFile.Get(
"VFAT{0}/THR_ARM_DAC/g1D_rate_vs_THR-ARM-DAC_vfat{0}".format(
vfat))
dict_Graphs[infoTuple[2]][vfat] = r.TGraph(
dict_Histos[infoTuple[2]][vfat])
# Do we convert x-axis to charge units?
if arrayCalInfo is not None:
for pt in range(dict_Graphs[infoTuple[2]][vfat].GetN()):
valX = r.Double()
valY = r.Double()
dict_Graphs[infoTuple[2]][vfat].GetPoint(pt, valX, valY)
valX_Q = 0
for coef in range(0, 5):
valX_Q += arrayCalInfo[coef][vfat] * pow(
valX, 4 - coef)
dict_Graphs[infoTuple[2]][vfat].SetPoint(pt, valX_Q, valY)
pass
pass
# Make the TMultiGraph Objects
suffix = "VFAT{0}".format(vfat)
if idx == 0:
dict_MultiGraphs[vfat] = r.TMultiGraph(
"mGraph_RateVsThrDac_vfat{0}".format(suffix), suffix)
# Set Style of TGraph
dict_Graphs[infoTuple[2]][vfat].SetLineColor(getCyclicColor(idx))
dict_Graphs[infoTuple[2]][vfat].SetMarkerColor(getCyclicColor(idx))
dict_Graphs[infoTuple[2]][vfat].SetMarkerStyle(20 + idx)
dict_Graphs[infoTuple[2]][vfat].SetMarkerSize(0.8)
# Add to the MultiGraph
dict_MultiGraphs[vfat].Add(dict_Graphs[infoTuple[2]][vfat])
###################
# Make an entry in the TLegend
###################
if vfat == 0:
legPlot.AddEntry(dict_Graphs[infoTuple[2]][vfat],
"{0} = {1}".format(thrDacName,
infoTuple[2]), "LPE")
pass
pass
###################
# Make output ROOT file
###################
outFileName = "{0}/compSbitThresh_{1}.root".format(elogPath, chamberName)
outFile = r.TFile(outFileName, "RECREATE")
# Plot Containers
dict_canv = {}
###################
# Now Make plots
###################
for vfat in range(vfatsPerGemVariant[gemType]):
# Make Output Canvas
dict_canv[vfat] = r.TCanvas("canvSBitRate_VFAT{0}".format(vfat),
"SBIT Rate by THR DAC", 700, 700)
dict_canv[vfat].cd()
dict_canv[vfat].cd().SetLogy()
dict_MultiGraphs[vfat].Draw("APE1")
dict_MultiGraphs[vfat].GetYaxis().SetTitle("Rate #left(Hz#right)")
dict_MultiGraphs[vfat].GetYaxis().SetRangeUser(1e-1,
5e8) # max is 40 MHz
if arrayCalInfo is not None:
dict_MultiGraphs[vfat].GetXaxis().SetTitle(
"Threshold #left(fC#right)")
dict_MultiGraphs[vfat].GetXaxis().SetRangeUser(0, 20)
else:
dict_MultiGraphs[vfat].GetXaxis().SetTitle(
"CFG_THR_ARM_DAC #left(DAC#right)")
dict_MultiGraphs[vfat].GetXaxis().SetRangeUser(0, 125)
pass
dict_MultiGraphs[vfat].Draw("APE1")
# Draw Legend?
if not args.noLeg:
legPlot.Draw("same")
pass
# Make output image?
if args.savePlots:
dict_canv[vfat].SaveAs("{0}/{1}.png".format(
elogPath, dict_canv[vfat].GetName()))
pass
# Store Output
thisDirectory = outFile.mkdir("VFAT{0}".format(vfat))
thisDirectory.cd()
dict_MultiGraphs[vfat].Write()
dict_canv[vfat].Write()
pass
# Make summary canvases, always save these
canvSBitRate_Summary = getSummaryCanvas(
dict_MultiGraphs.values()[0:vfatsPerGemVariant[gemType]],
name="canvSBitRate_Summary",
drawOpt="APE1",
gemType=gemType)
for vfatCanv in range(1, vfatsPerGemVariant[gemType] + 1):
canvSBitRate_Summary.cd(vfatCanv).SetLogy()
# Draw Legend?
if not args.noLeg:
canvSBitRate_Summary.cd(1)
legPlot.Draw("same")
pass
# Save summary canvases (always)
print("\nSaving Summary TCanvas Objects")
canvSBitRate_Summary.SaveAs("{0}/{1}.png".format(
elogPath, canvSBitRate_Summary.GetName()))
# Close output files
outFile.Close()
print("You can find all ROOT objects in:")
print("\n\t{0}/compSbitThresh_{1}.root\n".format(elogPath, chamberName))
print("You can find all plots in:")
print("\n\t{0}\n".format(elogPath))
print("Done")
return
r.gROOT.SetBatch(True)
r.gStyle.SetOptStat(1111111)
# Loading the dictionary with the mapping
from gempython.gemplotting.utils.anautilities import getSummaryCanvas, getSummaryCanvasByiEta, getMapping
vfat_ch_strips = getMapping(mapping, isVFAT2=False, gemType=gemType)
if args.debug:
print("\nVFAT channels to strips \n"+mapping+"\nMAP loaded")
# Loading and reversing the dictionary with (eta , phi) <-> vfatN
from gempython.gemplotting.mapping.chamberInfo import chamber_iEta2VFATPos, chamber_maxiEtaiPhiPair
from gempython.utils.nesteddict import nesteddict as ndict
maxiEta = chamber_maxiEtaiPhiPair[gemType][0]
maxiPhi = chamber_maxiEtaiPhiPair[gemType][1]
etaphi_to_vfat = ndict()
for i in range(maxiEta):
etaphi_to_vfat[i+1] = {row:ieta for ieta,row in chamber_iEta2VFATPos[i+1].iteritems()}
"""
Now it's time to load all the input files and to merge them into one root TTree
The TTree file it's going to auto extend each time a new file is found
A TFile it's going to hold this TTree
"""
# Creating the output File and TTree
outF = r.TFile(filename+'/'+outfilename, 'recreate')
inT = r.TTree('Packed', 'Tree Holding packed raw data')
# get starting time
import time
start_time = time.time()
(options, args) = parser.parse_args()
filename = options.filename[:-5]
os.system("mkdir " + filename)
print filename
outputfilename = options.outfilename
import ROOT as r
r.TH1.SetDefaultSumw2(False)
r.gROOT.SetBatch(True)
r.gStyle.SetOptStat(1111111)
inF = r.TFile(filename + '.root', "READ")
#Initializing Histograms
print 'Initializing Histograms'
dict_hVFATHitsVsLat = ndict()
for vfat in range(0, 24):
#dict_hVFATHitsVsLat[vfat] = r.TH1F("vfat%iHitsVsLat"%vfat,"vfat%i"%vfat,256,-0.5,255.5)
dict_hVFATHitsVsLat[vfat] = r.TH1F("vfat%iHitsVsLat" % vfat,
"vfat%i" % vfat, 1024, -0.5, 1023.5)
pass
#Filling Histograms
print 'Filling Histograms'
latMin = 1000
latMax = -1
nTrig = -1
dict_vfatID = dict((vfat, 0) for vfat in range(0, 24))
listOfBranches = inF.latTree.GetListOfBranches()
for event in inF.latTree:
dict_hVFATHitsVsLat[int(event.vfatN)].Fill(event.latency, event.Nhits)
(options, args) = parser.parse_args()
filename = options.filename[:-5]
os.system("mkdir " + filename)
print filename
outputfilename = options.outfilename
import ROOT as r
r.gROOT.SetBatch(True)
r.gStyle.SetOptStat(1111111)
inF = r.TFile(filename + '.root', "READ")
#Initializing Histograms
print 'Initializing Histograms'
dict_hVFATHitsVsLat = ndict()
for vfat in range(0, 24):
dict_hVFATHitsVsLat[vfat] = r.TH1F("vfat%iHitsVsLat" % vfat,
"vfat%i" % vfat, 256, -0.5, 255.5)
pass
#Filling Histograms
print 'Filling Histograms'
latMin = 1000
latMax = -1
for event in inF.latTree:
dict_hVFATHitsVsLat[int(event.vfatN)].Fill(event.lat, event.Nhits)
if event.lat < latMin and event.Nhits > 0:
latMin = event.lat
pass
elif event.lat > latMax:
parser.add_option("-x",
"--chi2",
action="store_true",
dest="chi2_plots",
help="Make Chi2 plots",
metavar="chi2_plots")
(options, args) = parser.parse_args()
filename = options.filename[:-5]
import ROOT as r
r.gROOT.SetBatch(True)
inF = r.TFile(filename + '.root')
vSum = ndict()
vNoise = ndict()
vThreshold = ndict()
vChi2 = ndict()
vComparison = ndict()
vNoiseTrim = ndict()
vPedestal = ndict()
for vfat in range(0, 24):
vNoise[vfat] = r.TH1D('Noise%i' % vfat, 'Noise%i;Noise [DAC units]' % vfat,
35, -0.5, 34.5)
vPedestal[vfat] = r.TH1D('Pedestal%i' % vfat,
'Pedestal%i;Pedestal [DAC units]' % vfat, 256,
-0.5, 255.5)
vThreshold[vfat] = r.TH1D('Threshold%i' % vfat,
'Threshold%i;Threshold [DAC units]' % vfat, 60,
def anaUltraLatency(infilename,
debug=False,
latSigMaskRange=None,
latSigRange=None,
outputDir=None,
outfilename="latencyAna.root",
performFit=False):
"""
Analyzes data taken by ultraLatency.py
infilename - Name of input TFile containing the latTree TTree
debug - If True prints additional debugging statements
latSigMaskRange - Comma separated pair of values defining the region
to be masked when trying to fit the noise, e.g.
lat #notepsilon [40,44] is noise (lat < 40 || lat > 44)")
latSigRange - Comma separated pair of values defining expected
signal range, e.g. lat #epsilon [41,43] is signal")
outfilename - Name of output TFile containing analysis results
performFit - Fit the latency distributions
"""
# Determine output filepath
if outputDir is None:
from gempython.gemplotting.utils.anautilities import getElogPath
outputDir = getElogPath()
pass
# Redirect sys.stdout and sys.stderr if necessary
from gempython.gemplotting.utils.multiprocUtils import redirectStdOutAndErr
redirectStdOutAndErr("anaUltraLatency", outputDir)
# Create the output File and TTree
import ROOT as r
outF = r.TFile(outputDir + "/" + outfilename, "RECREATE")
if not outF.IsOpen():
outF.Close()
raise IOError(
"Unable to open output file {1} check to make sure you have write permissions under {0}"
.format(outputDir, outfilename))
if outF.IsZombie():
outF.Close()
raise IOError(
"Output file {1} is a Zombie, check to make sure you have write permissions under {0}"
.format(outputDir, outfilename))
myT = r.TTree('latFitTree', 'Tree Holding FitData')
# Attempt to open input TFile
inFile = r.TFile(infilename, "read")
if not inFile.IsOpen():
outF.Close()
inFile.Close()
raise IOError(
"Unable to open input file {0} check to make sure you have read permissions"
.format(infilename))
if inFile.IsZombie():
outF.Close()
inFile.Close()
raise IOError(
"Input file {0} is a Zombie, check to make sure you have write permissions and file has expected size"
.format(infilename))
from gempython.tools.hw_constants import vfatsPerGemVariant
# Get ChipID's
import numpy as np
import root_numpy as rp
##### FIXME
from gempython.gemplotting.mapping.chamberInfo import gemTypeMapping
if 'gemType' not in inFile.latTree.GetListOfBranches():
gemType = "ge11"
else:
gemType = gemTypeMapping[rp.tree2array(tree=inFile.latTree,
branches=['gemType'])[0][0]]
print gemType
##### END
from gempython.tools.hw_constants import vfatsPerGemVariant
nVFATS = vfatsPerGemVariant[gemType]
from gempython.gemplotting.mapping.chamberInfo import CHANNELS_PER_VFAT as maxChans
listOfBranches = inFile.latTree.GetListOfBranches()
if 'vfatID' in listOfBranches:
array_chipID = np.unique(
rp.tree2array(inFile.latTree, branches=['vfatID', 'vfatN']))
dict_chipID = {}
for entry in array_chipID:
dict_chipID[entry['vfatN']] = entry['vfatID']
else:
dict_chipID = {vfat: 0 for vfat in range(nVFATS)}
if debug:
print("VFAT Position to ChipID Mapping")
for vfat, vfatID in dict_chipID.iteritems():
print(vfat, vfatID)
# Set default histogram behavior
r.TH1.SetDefaultSumw2(False)
r.gROOT.SetBatch(True)
r.gStyle.SetOptStat(1111111)
#Initializing Histograms
print('Initializing Histograms')
from gempython.utils.gemlogger import printYellow
from gempython.utils.nesteddict import nesteddict as ndict
dict_hVFATHitsVsLat = ndict()
for vfat in range(0, nVFATS):
try:
chipID = dict_chipID[vfat]
except KeyError as err:
chipID = 0
if debug:
printYellow(
"No CHIP_ID for VFAT{0}, If you don't expect data from this VFAT there's no problem"
.format(vfat))
dict_hVFATHitsVsLat[vfat] = r.TH1F(
"vfat{0}HitsVsLat".format(vfat),
"VFAT {0}: chipID {1}".format(vfat, chipID), 1024, -0.5, 1023.5)
pass
#Filling Histograms
print('Filling Histograms')
latMin = 1000
latMax = -1
nTrig = -1
for event in inFile.latTree:
dict_hVFATHitsVsLat[int(event.vfatN)].Fill(event.latency, event.Nhits)
if event.latency < latMin and event.Nhits > 0:
latMin = event.latency
pass
elif event.latency > latMax:
latMax = event.latency
pass
if nTrig < 0:
nTrig = event.Nev
pass
pass
from math import sqrt
for vfat in range(0, nVFATS):
for binX in range(1, dict_hVFATHitsVsLat[vfat].GetNbinsX() + 1):
dict_hVFATHitsVsLat[vfat].SetBinError(
binX, sqrt(dict_hVFATHitsVsLat[vfat].GetBinContent(binX)))
hHitsVsLat_AllVFATs = dict_hVFATHitsVsLat[0].Clone("hHitsVsLat_AllVFATs")
hHitsVsLat_AllVFATs.SetTitle("Sum over all VFATs")
for vfat in range(1, nVFATS):
hHitsVsLat_AllVFATs.Add(dict_hVFATHitsVsLat[vfat])
# Set Latency Fitting Bounds - Signal
latFitMin_Sig = latMin
latFitMax_Sig = latMax
if latSigRange is not None:
listLatValues = map(lambda val: float(val), latSigRange.split(","))
if len(listLatValues) != 2:
raise IndexError(
"You must specify exactly two values for determining latency signal range; values given: {0} do not meet this criterion"
.format(listLatValues))
else:
latFitMin_Sig = min(listLatValues)
latFitMax_Sig = max(listLatValues)
# Set Latency Fitting Bounds - Noise
latFitMin_Noise = latFitMin_Sig - 1
latFitMax_Noise = latFitMax_Sig + 1
if latSigMaskRange is not None:
listLatValues = map(lambda val: float(val), latSigMaskRange.split(","))
if len(listLatValues) != 2:
raise IndexError(
"You must specify exactly two values for determining latency signal range; values given: {0} do not meet this criterion"
.format(listLatValues))
else:
latFitMin_Noise = min(listLatValues)
latFitMax_Noise = max(listLatValues)
# Make output TFile and TTree
from array import array
dirVFATPlots = outF.mkdir("VFAT_Plots")
if 'detName' in listOfBranches:
detName = r.vector('string')()
detName.push_back(
rp.tree2array(inFile.latTree, branches=['detName'])[0][0][0])
myT.Branch('detName', detName)
vfatN = array('i', [0])
myT.Branch('vfatN', vfatN, 'vfatN/I')
vfatID = array('L', [0])
myT.Branch('vfatID', vfatID, 'vfatID/i') #Hex Chip ID of VFAT
hitCountMaxLat = array('f', [0])
myT.Branch('hitCountMaxLat', hitCountMaxLat, 'hitCountMaxLat/F')
hitCountMaxLatErr = array('f', [0])
myT.Branch('hitCountMaxLatErr', hitCountMaxLatErr, 'hitCountMaxLatErr/F')
maxLatBin = array('f', [0])
myT.Branch('maxLatBin', maxLatBin, 'maxLatBin/F')
hitCountBkg = array('f', [0])
hitCountBkgErr = array('f', [0])
hitCountSig = array('f', [0])
hitCountSigErr = array('f', [0])
SigOverBkg = array('f', [0])
SigOverBkgErr = array('f', [0])
if performFit:
myT.Branch('hitCountBkg', hitCountBkg, 'hitCountBkg/F')
myT.Branch('hitCountBkgErr', hitCountBkgErr, 'hitCountBkgErr/F')
myT.Branch('hitCountSig', hitCountSig, 'hitCountSig/F')
myT.Branch('hitCountSigErr', hitCountSigErr, 'hitCountSigErr/F')
myT.Branch('SigOverBkg', SigOverBkg, 'SigOverBkg/F')
myT.Branch('SigOverBkgErr', SigOverBkgErr, 'SigOverBkgErr/F')
# Make output plots
from math import sqrt
dict_grNHitsVFAT = ndict()
dict_fitNHitsVFAT_Sig = ndict()
dict_fitNHitsVFAT_Noise = ndict()
grNMaxLatBinByVFAT = r.TGraphErrors(len(dict_hVFATHitsVsLat))
grMaxLatBinByVFAT = r.TGraphErrors(len(dict_hVFATHitsVsLat))
grVFATSigOverBkg = r.TGraphErrors(len(dict_hVFATHitsVsLat))
grVFATNSignalNoBkg = r.TGraphErrors(len(dict_hVFATHitsVsLat))
r.gStyle.SetOptStat(0)
if debug and performFit:
print("VFAT\tSignalHits\tSignal/Noise")
for vfat in dict_hVFATHitsVsLat:
#if we don't have any data for this VFAT, we just need to initialize the TGraphAsymmErrors since it is drawn later
if vfat not in dict_chipID:
dict_grNHitsVFAT[vfat] = r.TGraphAsymmErrors()
continue
# Store VFAT info
vfatN[0] = vfat
vfatID[0] = dict_chipID[vfat]
# Store Max Info
hitCountMaxLat[0] = dict_hVFATHitsVsLat[vfat].GetBinContent(
dict_hVFATHitsVsLat[vfat].GetMaximumBin())
hitCountMaxLatErr[0] = sqrt(hitCountMaxLat[0])
grNMaxLatBinByVFAT.SetPoint(vfat, vfat, hitCountMaxLat[0])
grNMaxLatBinByVFAT.SetPointError(vfat, 0, hitCountMaxLatErr[0])
maxLatBin[0] = dict_hVFATHitsVsLat[vfat].GetBinCenter(
dict_hVFATHitsVsLat[vfat].GetMaximumBin())
grMaxLatBinByVFAT.SetPoint(vfat, vfat, maxLatBin[0])
grMaxLatBinByVFAT.SetPointError(vfat, 0, 0.5) #could be improved upon
# Initialize
dict_fitNHitsVFAT_Sig[vfat] = r.TF1(
"func_N_vs_Lat_VFAT{0}_Sig".format(vfat), "[0]", latFitMin_Sig,
latFitMax_Sig)
dict_fitNHitsVFAT_Noise[vfat] = r.TF1(
"func_N_vs_Lat_VFAT{0}_Noise".format(vfat), "[0]", latMin, latMax)
dict_grNHitsVFAT[vfat] = r.TGraphAsymmErrors(dict_hVFATHitsVsLat[vfat])
dict_grNHitsVFAT[vfat].SetName("g_N_vs_Lat_VFAT{0}".format(vfat))
# Fitting
if performFit:
# Fit Signal
dict_fitNHitsVFAT_Sig[vfat].SetParameter(0, hitCountMaxLat[0])
dict_fitNHitsVFAT_Sig[vfat].SetLineColor(r.kGreen + 1)
dict_grNHitsVFAT[vfat].Fit(dict_fitNHitsVFAT_Sig[vfat], "QR")
# Remove Signal Region
latVal = r.Double()
hitVal = r.Double()
gTempDist = dict_grNHitsVFAT[vfat].Clone(
"g_N_vs_Lat_VFAT{0}_NoSig".format(vfat))
for idx in range(dict_grNHitsVFAT[vfat].GetN() - 1, 0, -1):
gTempDist.GetPoint(idx, latVal, hitVal)
if latFitMin_Noise < latVal and latVal < latFitMax_Noise:
gTempDist.RemovePoint(idx)
# Fit Noise
dict_fitNHitsVFAT_Noise[vfat].SetParameter(0, 0.)
dict_fitNHitsVFAT_Noise[vfat].SetLineColor(r.kRed + 1)
gTempDist.Fit(dict_fitNHitsVFAT_Noise[vfat], "QR")
# Calc Signal & Signal/Noise
hitCountBkg[0] = dict_fitNHitsVFAT_Noise[vfat].GetParameter(0)
hitCountBkgErr[0] = dict_fitNHitsVFAT_Noise[vfat].GetParError(0)
hitCountSig[0] = dict_fitNHitsVFAT_Sig[vfat].GetParameter(
0) - hitCountBkg[0]
hitCountSigErr[0] = sqrt(
(dict_fitNHitsVFAT_Sig[vfat].GetParError(0))**2 +
hitCountBkgErr[0]**2)
SigOverBkg[0] = hitCountSig[0] / hitCountBkg[0]
SigOverBkgErr[0] = sqrt((hitCountSigErr[0] / hitCountBkg[0])**2 +
(hitCountBkgErr[0]**2 *
(hitCountSig[0] / hitCountBkg[0]**2)**2))
# Add to Plot
grVFATSigOverBkg.SetPoint(vfat, vfat, SigOverBkg[0])
grVFATSigOverBkg.SetPointError(vfat, 0, SigOverBkgErr[0])
grVFATNSignalNoBkg.SetPoint(vfat, vfat, hitCountSig[0])
grVFATNSignalNoBkg.SetPointError(vfat, 0, hitCountSigErr[0])
# Print if requested
if debug:
print("{0}\t{1}\t{2}".format(vfat, hitCountSig[0],
SigOverBkg[0]))
pass
# Format
r.gStyle.SetOptStat(0)
dict_grNHitsVFAT[vfat].SetMarkerStyle(21)
dict_grNHitsVFAT[vfat].SetMarkerSize(0.7)
dict_grNHitsVFAT[vfat].SetLineWidth(2)
dict_grNHitsVFAT[vfat].GetXaxis().SetRangeUser(latMin, latMax)
dict_grNHitsVFAT[vfat].GetXaxis().SetTitle("Lat")
dict_grNHitsVFAT[vfat].GetYaxis().SetRangeUser(0, nTrig)
dict_grNHitsVFAT[vfat].GetYaxis().SetTitle("N")
# Write
dirVFAT = dirVFATPlots.mkdir("VFAT{0}".format(vfat))
dirVFAT.cd()
dict_grNHitsVFAT[vfat].Write()
dict_hVFATHitsVsLat[vfat].Write()
if performFit:
dict_fitNHitsVFAT_Sig[vfat].Write()
dict_fitNHitsVFAT_Noise[vfat].Write()
myT.Fill()
pass
# Store - Summary
from gempython.gemplotting.utils.anautilities import getSummaryCanvas, addPlotToCanvas
if performFit:
canv_Summary = getSummaryCanvas(dict_grNHitsVFAT,
name='canv_Summary',
drawOpt='APE1',
gemType=gemType)
canv_Summary = addPlotToCanvas(canv_Summary, dict_fitNHitsVFAT_Noise,
gemType)
canv_Summary.SaveAs(outputDir + '/Summary.png')
else:
canv_Summary = getSummaryCanvas(dict_grNHitsVFAT,
name='canv_Summary',
drawOpt='APE1',
gemType=gemType)
canv_Summary.SaveAs(outputDir + '/Summary.png')
# Store - Sig Over Bkg
if performFit:
canv_SigOverBkg = r.TCanvas("canv_SigOverBkg", "canv_SigOverBkg", 600,
600)
canv_SigOverBkg.cd()
canv_SigOverBkg.cd().SetLogy()
canv_SigOverBkg.cd().SetGridy()
grVFATSigOverBkg.SetTitle("")
grVFATSigOverBkg.SetMarkerStyle(21)
grVFATSigOverBkg.SetMarkerSize(0.7)
grVFATSigOverBkg.SetLineWidth(2)
grVFATSigOverBkg.GetXaxis().SetTitle("VFAT Pos")
grVFATSigOverBkg.GetYaxis().SetTitle("Sig / Bkg)")
grVFATSigOverBkg.GetYaxis().SetTitleOffset(1.25)
grVFATSigOverBkg.GetYaxis().SetRangeUser(1e-1, 1e2)
grVFATSigOverBkg.GetXaxis().SetRangeUser(-0.5, nVFATS + 0.5)
grVFATSigOverBkg.Draw("APE1")
canv_SigOverBkg.SaveAs(outputDir + '/SignalOverBkg.png')
# Store - Signal
if performFit:
canv_Signal = r.TCanvas("canv_Signal", "canv_Signal", 600, 600)
canv_Signal.cd()
grVFATNSignalNoBkg.SetTitle("")
grVFATNSignalNoBkg.SetMarkerStyle(21)
grVFATNSignalNoBkg.SetMarkerSize(0.7)
grVFATNSignalNoBkg.SetLineWidth(2)
grVFATNSignalNoBkg.GetXaxis().SetTitle("VFAT Pos")
grVFATNSignalNoBkg.GetYaxis().SetTitle("Signal Hits")
grVFATNSignalNoBkg.GetYaxis().SetTitleOffset(1.5)
grVFATNSignalNoBkg.GetYaxis().SetRangeUser(0, nTrig)
grVFATNSignalNoBkg.GetXaxis().SetRangeUser(-0.5, nVFATS + 0.5)
grVFATNSignalNoBkg.Draw("APE1")
canv_Signal.SaveAs(outputDir + '/SignalNoBkg.png')
# Store - Sum over all VFATs
canv_LatSum = r.TCanvas("canv_LatSumOverAllVFATs",
"canv_LatSumOverAllVFATs", 600, 600)
canv_LatSum.cd()
hHitsVsLat_AllVFATs.SetXTitle("Latency")
hHitsVsLat_AllVFATs.SetYTitle("N")
hHitsVsLat_AllVFATs.GetXaxis().SetRangeUser(latMin, latMax)
hHitsVsLat_AllVFATs.Draw("hist")
canv_LatSum.SaveAs(outputDir + '/LatSumOverAllVFATs.png')
# Store - Max Hits By Lat Per VFAT
canv_MaxHitsPerLatByVFAT = r.TCanvas("canv_MaxHitsPerLatByVFAT",
"canv_MaxHitsPerLatByVFAT", 1200, 600)
canv_MaxHitsPerLatByVFAT.Divide(2, 1)
canv_MaxHitsPerLatByVFAT.cd(1)
grNMaxLatBinByVFAT.SetTitle("")
grNMaxLatBinByVFAT.SetMarkerStyle(21)
grNMaxLatBinByVFAT.SetMarkerSize(0.7)
grNMaxLatBinByVFAT.SetLineWidth(2)
grNMaxLatBinByVFAT.GetXaxis().SetRangeUser(-0.5, nVFATS + 0.5)
grNMaxLatBinByVFAT.GetXaxis().SetTitle("VFAT Pos")
grNMaxLatBinByVFAT.GetYaxis().SetRangeUser(0, nTrig)
grNMaxLatBinByVFAT.GetYaxis().SetTitle("Hit Count of Max Lat Bin")
grNMaxLatBinByVFAT.GetYaxis().SetTitleOffset(1.7)
grNMaxLatBinByVFAT.Draw("APE1")
canv_MaxHitsPerLatByVFAT.cd(2)
grMaxLatBinByVFAT.SetTitle("")
grMaxLatBinByVFAT.SetMarkerStyle(21)
grMaxLatBinByVFAT.SetMarkerSize(0.7)
grMaxLatBinByVFAT.SetLineWidth(2)
grMaxLatBinByVFAT.GetXaxis().SetTitle("VFAT Pos")
grMaxLatBinByVFAT.GetYaxis().SetTitle("Max Lat Bin")
grMaxLatBinByVFAT.GetYaxis().SetTitleOffset(1.2)
grMaxLatBinByVFAT.GetXaxis().SetRangeUser(-0.5, nVFATS + 0.5)
grMaxLatBinByVFAT.Draw("APE1")
canv_MaxHitsPerLatByVFAT.SaveAs(outputDir + '/MaxHitsPerLatByVFAT.png')
# Store - TObjects
outF.cd()
hHitsVsLat_AllVFATs.Write()
grNMaxLatBinByVFAT.SetName("grNMaxLatBinByVFAT")
grNMaxLatBinByVFAT.Write()
grMaxLatBinByVFAT.SetName("grMaxLatBinByVFAT")
grMaxLatBinByVFAT.Write()
if performFit:
grVFATSigOverBkg.SetName("grVFATSigOverBkg")
grVFATSigOverBkg.Write()
grVFATNSignalNoBkg.SetName("grVFATNSignalNoBkg")
grVFATNSignalNoBkg.Write()
myT.Write()
outF.Close()
def dacScanAllLinks(args, calTree, vfatBoard):
"""
Performs a DAC scan on all VFATs on all unmasked OH's on amcBoard
args - parsed arguments from an ArgumentParser instance
calTree - instance of gemDacCalTreeStructure
vfatBoard - instance of HwVFAT
"""
# Get the AMC
amcBoard = vfatBoard.parentOH.parentAMC
nVFATs = vfatBoard.parentOH.nVFATs
# Get DAC value
dacSelect = args.dacSelect
dacMax = maxVfat3DACSize[dacSelect][0]
dacMin = 0
calTree.nameX[0] = maxVfat3DACSize[dacSelect][1]
calTree.dacSelect[0] = dacSelect
# Get VFAT register values
from gempython.utils.nesteddict import nesteddict as ndict
ohVFATMaskArray = amcBoard.getMultiLinkVFATMask(args.ohMask)
print("Getting CHIP IDs of all VFATs")
vfatIDvals = ndict()
irefVals = ndict()
calSelPolVals = ndict()
for ohN in range(0, amcBoard.nOHs):
# Skip masked OH's
if (not ((args.ohMask >> ohN) & 0x1)):
calSelPolVals[ohN] = [0 for vfat in range(0, nVFATs)]
irefVals[ohN] = [0 for vfat in range(0, nVFATs)]
vfatIDvals[ohN] = [0 for vfat in range(0, nVFATs)]
else:
# update the OH in question
vfatBoard.parentOH.link = ohN
# Get the cal sel polarity
calSelPolVals[ohN] = vfatBoard.readAllVFATs(
"CFG_CAL_SEL_POL", ohVFATMaskArray[ohN])
# Get the IREF values
irefVals[ohN] = vfatBoard.readAllVFATs("CFG_IREF",
ohVFATMaskArray[ohN])
# Get the chip ID's
vfatIDvals[ohN] = vfatBoard.getAllChipIDs(ohVFATMaskArray[ohN])
# Perform DAC Scan
arraySize = amcBoard.nOHs * (dacMax - dacMin + 1) * nVFATs / args.stepSize
scanData = (c_uint32 * arraySize)()
print("Scanning DAC: {0} on all links".format(
maxVfat3DACSize[dacSelect][1]))
rpcResp = amcBoard.performDacScanMultiLink(scanData, dacSelect,
args.stepSize, args.ohMask,
args.extRefADC)
if rpcResp != 0:
raise Exception(
'RPC response was non-zero, this inidcates an RPC exception occurred. DAC Scan of all links failed'
)
#try:
if args.debug:
print(
"| detName | link | vfatN | vfatID | dacSelect | nameX | dacValX | dacValX_Err | nameY | dacValY | dacValY_Err |"
)
print(
"| :-----: | :--: | :---: | :----: | :-------: |:-----: | :-----: | :---------: | :--: | :-----: | :---------: |"
)
for dacWord in scanData:
# Get OH and skip if not in args.ohMask
ohN = ((dacWord >> 23) & 0xf)
if (not ((args.ohMask >> ohN) & 0x1)):
continue
# Get VFAT and skip if in ohVFATMaskArray[ohN]
vfat = ((dacWord >> 18) & 0x1f)
if ((ohVFATMaskArray[ohN] >> vfat) & 0x1):
continue
calTree.fill(
calSelPol=calSelPolVals[ohN][vfat],
dacValX=(dacWord & 0xff),
dacValY=((dacWord >> 8) & 0x3ff),
dacValY_Err=
1, # convert to physical units in analysis, LSB is the error on Y
iref=irefVals[ohN][vfat],
detName=chamber_config[(amcBoard.getShelf(), amcBoard.getSlot(),
ohN)],
link=ohN,
shelf=amcBoard.getShelf(),
slot=amcBoard.getSlot(),
vfatID=vfatIDvals[ohN][vfat],
vfatN=vfat)
if args.debug:
print(
"| {0} | {1} | {2} | 0x{3:x} | {4} | {5} | {6} | {7} | {8} | {9} | {10} |"
.format(calTree.detName[0], calTree.link[0], calTree.vfatN[0],
calTree.vfatID[0], calTree.dacSelect[0],
calTree.nameX[0], calTree.dacValX[0],
calTree.dacValX_Err[0], calTree.nameY[0],
calTree.dacValY[0], calTree.dacValY_Err[0]))
pass
printGreen("DAC scans for optohybrids in 0x{0:x} completed".format(
args.ohMask))
return
def __init__(self,
calDAC2Q_m=None,
calDAC2Q_b=None,
isVFAT3=False,
nVFATS=24,
maxChi2=maxChi2Default):
super(ScanDataFitter, self).__init__(nVFATS)
from gempython.utils.nesteddict import nesteddict as ndict
from gempython.gemplotting.mapping.chamberInfo import CHANNELS_PER_VFAT as maxChans
r.gStyle.SetOptStat(0)
self.Nev = ndict()
self.scanFuncs = ndict()
self.scanHistos = ndict()
self.scanHistosChargeBins = ndict()
self.scanCount = ndict()
self.scanFitResults = ndict()
self.isVFAT3 = isVFAT3
self.nVFATS = nVFATS
self.maxChi2 = maxChi2
self.calDAC2Q_m = np.ones(self.nVFATS)
if calDAC2Q_m is not None:
self.calDAC2Q_m = calDAC2Q_m
self.calDAC2Q_b = np.zeros(self.nVFATS)
if calDAC2Q_b is not None:
self.calDAC2Q_b = calDAC2Q_b
for vfat in range(0, self.nVFATS):
self.scanFitResults[0][vfat] = np.zeros(maxChans)
self.scanFitResults[1][vfat] = np.zeros(maxChans)
self.scanFitResults[2][vfat] = np.zeros(maxChans)
self.scanFitResults[3][vfat] = np.zeros(maxChans)
self.scanFitResults[4][vfat] = np.zeros(maxChans)
self.scanFitResults[5][vfat] = np.zeros(maxChans)
self.scanFitResults[6][vfat] = np.zeros(maxChans, dtype=bool)
for ch in range(0, maxChans):
self.scanCount[vfat][ch] = 0
if self.isVFAT3:
self.scanFuncs[vfat][ch] = r.TF1(
'scurveFit_vfat{0}_chan{1}'.format(vfat, ch),
'[3]*TMath::Erf((TMath::Max([2],x)-[0])/(TMath::Sqrt(2)*[1]))+[3]',
self.calDAC2Q_m[vfat] * 253 + self.calDAC2Q_b[vfat],
self.calDAC2Q_m[vfat] * 1 + self.calDAC2Q_b[vfat])
self.scanHistos[vfat][ch] = r.TH1D(
'scurve_vfat{0}_chan{1}_h'.format(vfat, ch),
'scurve_vfat{0}_chan{1}_h'.format(vfat, ch), 254,
self.calDAC2Q_m[vfat] * 254.5 + self.calDAC2Q_b[vfat],
self.calDAC2Q_m[vfat] * 0.5 + self.calDAC2Q_b[vfat])
else:
self.scanFuncs[vfat][ch] = r.TF1(
'scurveFit_vfat{0}_chan{1}'.format(vfat, ch),
'[3]*TMath::Erf((TMath::Max([2],x)-[0])/(TMath::Sqrt(2)*[1]))+[3]',
self.calDAC2Q_m[vfat] * 1 + self.calDAC2Q_b[vfat],
self.calDAC2Q_m[vfat] * 253 + self.calDAC2Q_b[vfat])
self.scanHistos[vfat][ch] = r.TH1D(
'scurve_vfat{0}_chan{1}_h'.format(vfat, ch),
'scurve_vfat{0}_chan{1}_h'.format(vfat, ch), 254,
self.calDAC2Q_m[vfat] * 0.5 + self.calDAC2Q_b[vfat],
self.calDAC2Q_m[vfat] * 254.5 + self.calDAC2Q_b[vfat])
pass
self.scanHistosChargeBins[vfat][ch] = [
self.scanHistos[vfat][ch].GetXaxis().GetBinLowEdge(binX)
for binX in range(
1, self.scanHistos[vfat][ch].GetNbinsX() + 2)
] #Include overflow
pass
pass
self.fitValid = [
np.zeros(maxChans, dtype=bool) for vfat in range(self.nVFATS)
]
return
