def makeDSASignal2DPlots():
for quantity in ('pT', 'eta', 'trkChi2'):
hkey = 'DSA-12-' + quantity
HISTS = HG.getAddedSignalHistograms(FILES[fs], fs, (hkey, ))
if 'trkChi2' not in hkey: HISTS[hkey].Rebin2D(10, 10)
for sp in SIGNALPOINTS:
HISTS[sp] = HG.getHistogram(FILES[fs], (fs, sp), hkey).Clone()
if 'trkChi2' not in hkey: HISTS[sp].Rebin2D(10, 10)
opt = 'colz'
#opt = 'scat=0.2'
PLOTS = {hkey: Plotter.Plot(HISTS[hkey], '', '', opt)}
for sp in SIGNALPOINTS:
PLOTS[sp] = Plotter.Plot(HISTS[sp], '', '', opt)
for sp in [
hkey,
] + SIGNALPOINTS:
canvas = Plotter.Canvas(lumi=fs + lumiExtra.get(CUTSTRING) if
type(sp) != tuple else SPLumiStr(fs, *sp))
canvas.addMainPlot(PLOTS[sp])
canvas.mainPad.SetLogz()
if quantity == 'trkChi2':
canvas.firstPlot.GetXaxis().SetRangeUser(0., 10.)
canvas.firstPlot.GetYaxis().SetRangeUser(0., 10.)
canvas.scaleMargins(1.75, edges='R')
canvas.scaleMargins(0.8, edges='L')
canvas.cleanup('pdfs/ZEP_2D_{}_{}_{}_{}.pdf'.format(
quantity, CUTSTRING, fs,
'Global' if type(sp) != tuple else SPStr(sp)))
def fillPlots(fs, sp, HList, FNAME):
# get file and tree
f = R.TFile.Open(FNAME.format('HTo2XTo' + fs + '_' + SPStr(sp)))
t = f.Get('SimpleNTupler/DDTree')
# set basic particle aliases
RT.setGenAliases(t, fs)
# set additional aliases from HAliases
for alias, expr in HAliases.iteritems():
t.SetAlias(alias, expr)
# define histogram configurations for this signal point
HConfig = HistogramConfigurations(fs, sp)
# declare histograms
# make sure histograms don't get deleted when file is closed
# fill histograms using TTree::Draw
for key in HList:
if key not in HConfig.data:
raise Exception('At least one histogram key: ' + key +
' not known')
nAxes = str(HConfig.data[key]['nAxes'])
HISTS[(fs, sp)][key] = getattr(R, 'TH' + nAxes + 'F')(*HConfig[key])
Draw(t, HConfig, key, HExpressions[key])
HISTS[(fs, sp)][key].SetDirectory(0)
# cleanup
del t
f.Close()
del f
def makeColorPlots(key):
for ref in HISTS:
if not type(ref) == tuple: continue
if type(ref) == tuple:
if ref[0] == '4Mu':
name = 'HTo2XTo4Mu_'
latexFS = '4#mu'
elif ref[0] == '2Mu2J':
name = 'HTo2XTo2Mu2J_'
latexFS = '2#mu2j'
if TRIGGER:
name = 'Trig-' + name
name += SPStr(ref[1])
lumi = SPLumiStr(ref[0], *ref[1])
else:
name = ref
lumi = HistogramGetter.PLOTCONFIG[ref]['LATEX']
if '_Matched' in key: continue
h = HISTS[ref][key].Clone()
h.Rebin2D(10, 10)
p = Plotter.Plot(h, '', '', 'colz')
canvas = Plotter.Canvas(lumi=lumi)
#canvas.mainPad.SetLogz(True)
canvas.addMainPlot(p)
canvas.scaleMargins(1.75, edges='R')
canvas.scaleMargins(0.8, edges='L')
fname = 'pdfs/{}{}_{}.pdf'.format(key, CUTSTRING, name)
canvas.cleanup(fname)
def makeLxyEffPlot(key, colorAxis, fs, sp, pTCut=''):
config = {
'Correct': ('Correct', 'Matches'),
}
if colorAxis == 'nMuons':
num, den = config[key]
nums = ['Lxy' + pTCut + '_n' + num + '_' + m for m in mnames]
dens = ['Lxy' + pTCut + '_n' + den + '_' + m for m in mnames]
tags = list(set(nums + dens))
legs = {
num: m if 'All' in m else m + ' #mu'
for num, m in zip(nums, mnames)
}
cols = {num: c for num, c in zip(nums, colors)}
if sp is None:
h = {}
for tag in tags:
h[tag] = HistogramGetter.getHistogram(f, (fs, SIGNALPOINTS[0]),
tag).Clone()
for SP in SIGNALPOINTS[1:]:
for tag in tags:
h[tag].Add(HistogramGetter.getHistogram(f, (fs, SP), tag))
else:
h = {}
for tag in tags:
h[tag] = HistogramGetter.getHistogram(f, (fs, sp), tag).Clone()
for z in h:
h[z].Rebin(10)
p = {}
graphs = {}
for num, den in zip(nums, dens):
realDen = h[den].Clone()
graphs[num] = R.TGraphAsymmErrors(h[num], realDen, 'cp')
p[num] = Plotter.Plot(graphs[num], legs[num], 'l', 'px')
canvas = Plotter.Canvas(lumi=SPLumiStr(fs, sp) if sp is not None else fs)
for tag in nums:
canvas.addMainPlot(p[tag])
canvas.firstPlot.SetMaximum(1.01)
canvas.firstPlot.SetMinimum(0.)
canvas.firstPlot.setTitles(X=h[tags[0]].GetXaxis().GetTitle(),
Y='Efficiency')
for tag in p:
p[tag].setColor(cols[tag], which='LM')
canvas.makeLegend(lWidth=.275, pos='tr')
canvas.legend.resizeHeight()
canvas.cleanup('pdfs/RA_{}-Lxy{}-{}{}_HTo2XTo{}_{}.pdf'.format(
'ComboMu' if colorAxis == 'nMuons' else 'ComboEff', pTCut, key,
ARGS.CUTSTRING, fs,
SPStr(sp) if sp is not None else 'Global'))
def makeDistPlot(quantity, criteria, fs, sp=None):
# configy type stuff
legs = ('All', 'Matched', 'NotMatched')
tags = [
quantity + '_' + ('All' + ('-4' if '-4' in criteria else '')
if 'All' in leg else criteria + '_' + leg)
for leg in legs
]
cols = (R.kBlack, R.kBlue, R.kRed)
# get/add histograms
if sp is None:
h = {}
for tag in tags:
h[tag] = HistogramGetter.getHistogram(f, (fs, SIGNALPOINTS[0]),
tag).Clone()
for SP in SIGNALPOINTS[1:]:
for tag in tags:
h[tag].Add(HistogramGetter.getHistogram(f, (fs, SP), tag))
else:
h = {}
for tag in tags:
h[tag] = HistogramGetter.getHistogram(f, (fs, sp), tag).Clone()
# make plots
p = {}
for i, tag in enumerate(tags):
p[tag] = Plotter.Plot(h[tag], legs[i], 'l', 'hist')
# canvas, plots, min max
logy = True
canvas = Plotter.Canvas(lumi=SPLumiStr(fs, sp) if sp is not None else fs,
logy=logy)
for tag in tags:
canvas.addMainPlot(p[tag])
canvas.setMaximum()
if not logy:
canvas.firstPlot.SetMinimum(0)
else:
canvas.firstPlot.SetMinimum(1.)
if 'Lxy' in quantity:
canvas.firstPlot.GetXaxis().SetRangeUser(0., 330.)
# colors
for i, tag in enumerate(tags):
p[tag].SetLineColor(cols[i])
# legend, cleanup
canvas.makeLegend(lWidth=.2, pos='tr')
canvas.legend.resizeHeight()
canvas.cleanup('pdfs/LCD_{}Dist_{}{}_HTo2XTo{}_{}.pdf'.format(
quantity, criteria, ARGS.CUTSTRING, fs,
SPStr(sp) if sp is not None else 'Global'))
def makePerSignalPlots(fs):
for sp in SIGNALPOINTS:
for key in HISTS[(fs, sp)]:
h = HISTS[(fs, sp)][key]
RT.addFlows(h)
p = Plotter.Plot(h, '', 'p', 'hist')
canvas = Plotter.Canvas(lumi=SPLumiStr(fs, *sp))
canvas.addMainPlot(p)
p.SetLineColor(R.kBlue)
RT.addBinWidth(p)
pave = canvas.makeStatsBox(p, color=R.kBlue)
canvas.cleanup('pdfs/Gen_{}_{}HTo2XTo{}_{}.pdf'.format(
key, 'Trig-' if TRIGGER else '', fs, SPStr(sp)))
def makeEffPlot(fs, sp):
if sp is None:
hNum = HG.getAddedSignalHistograms(FILES[fs], fs, 'Lxy-Num')['Lxy-Num']
hDen = HG.getAddedSignalHistograms(FILES[fs], fs, 'Lxy-Den')['Lxy-Den']
else:
hNum = HG.getHistogram(FILES[fs], (fs, sp), 'Lxy-Num').Clone()
hDen = HG.getHistogram(FILES[fs], (fs, sp), 'Lxy-Den').Clone()
hNumInt = hNum.Integral(hNum.GetXaxis().FindBin(65.),
hNum.GetNbinsX() + 1)
hDenInt = hDen.Integral(hDen.GetXaxis().FindBin(65.),
hDen.GetNbinsX() + 1)
#if sp == (sp[0], sp[1], SIGNALS[sp[0]][sp[1]][0]): return
print '{:5s} {:4d} {:3d} {:4d} ::: {:5.0f} {:5.0f} {:7.2%}'.format(
fs, sp[0], sp[1], sp[2], hNumInt, hDenInt,
hNumInt / hDenInt if hDenInt != 0. else 0.)
return
hNum.Rebin(2)
hDen.Rebin(2)
g = R.TGraphAsymmErrors(hNum, hDen, 'cp')
p = Plotter.Plot(g, '', '', 'p')
prettyFS = '2#mu' if '2Mu' in fs else '4#mu'
if sp is not None:
lumi = 'H#rightarrow2X#rightarrow{} ({} GeV, {} GeV, {} mm)'.format(
prettyFS, *sp)
else:
lumi = 'H#rightarrow2X#rightarrow{}, all samples combined'.format(
prettyFS)
c = Plotter.Canvas(lumi=lumi, cWidth=600 if ARGS.SQUARE else 800)
c.addMainPlot(p)
p.setColor(R.kBlue, which='LM')
c.firstPlot.SetMinimum(0.)
c.firstPlot.SetMaximum(1.)
c.firstPlot.setTitles(X='', copy=hNum)
c.firstPlot.setTitles(
Y='Efficiency for pairing criteria to select correct dimuons')
if ARGS.SQUARE:
c.firstPlot.scaleTitleOffsets(1.1, 'X')
c.cleanup('pdfs/PC_Lxy_{}_{}.pdf'.format(
fs, 'Global' if sp is None else SPStr(sp)),
mode='LUMI')
def makePTCutPlot(fs, sp=None):
# configy type stuff
legs = ('All', 'Matched', 'Wrong', 'Right', 'Hopeless', 'Lost')
tags = ['pT_' + tag for tag in legs]
cols = (R.kBlack, R.kGreen, R.kOrange, R.kBlue, R.kRed, R.kMagenta)
# get/add histograms
if sp is None:
h = {}
for tag in tags:
h[tag] = HistogramGetter.getHistogram(f, (fs, SIGNALPOINTS[0]),
tag).Clone()
for SP in SIGNALPOINTS[1:]:
for tag in tags:
h[tag].Add(HistogramGetter.getHistogram(f, (fs, SP), tag))
else:
h = {}
for tag in tags:
h[tag] = HistogramGetter.getHistogram(f, (fs, sp), tag).Clone()
# make plots
p = {}
for i, tag in enumerate(tags):
p[tag] = Plotter.Plot(h[tag], legs[i], 'l', 'hist')
# canvas, plots, min max
logy = True
canvas = Plotter.Canvas(lumi=SPLumiStr(fs, sp) if sp is not None else fs,
logy=logy)
for tag in tags:
canvas.addMainPlot(p[tag])
canvas.setMaximum()
if not logy:
canvas.firstPlot.SetMinimum(0)
else:
canvas.firstPlot.SetMinimum(1.)
#canvas.firstPlot.GetXaxis().SetRangeUser(0., 200.)
canvas.firstPlot.GetXaxis().SetRangeUser(0., 30.)
# colors
for i, tag in enumerate(tags):
p[tag].SetLineColor(cols[i])
# legend, cleanup
canvas.makeLegend(lWidth=.2, pos='tr')
canvas.legend.resizeHeight()
canvas.cleanup('pdfs/HPD_pTDist_HTo2XTo{}_{}.pdf'.format(
fs,
SPStr(sp) if sp is not None else 'Global'))
def makePerSamplePlots():
for ref in HISTS:
for key in HISTS[ref]:
if 'DenVS' in key: continue
matches = re.match(r'(.*)EffVS(.*)', key)
cut = matches.group(1)
val = matches.group(2)
if cut in Selections.CutLists['MuonCutList'] and val == 'Lxy':
continue
if cut in Selections.CutLists['DimuonCutList'] and val in ('pT',
'eta',
'd0'):
continue
if type(ref) == tuple:
if ref[0] == '4Mu': name = 'HTo2XTo4Mu_'
elif ref[0] == '2Mu2J': name = 'HTo2XTo2Mu2J_'
name += SPStr(ref[1])
if TRIGGER:
name = 'Trig-' + name
lumi = SPLumiStr(ref[0], *ref[1])
legName = HistogramGetter.PLOTCONFIG['HTo2XTo' +
ref[0]]['LATEX']
else:
name = ref
lumi = HistogramGetter.PLOTCONFIG[ref]['LATEX']
legName = HistogramGetter.PLOTCONFIG[ref]['LATEX']
h = HISTS[ref][key].Clone()
RT.addFlows(h)
d = HISTS[ref][key.replace('Eff', 'Den')].Clone()
RT.addFlows(d)
g = R.TGraphAsymmErrors(h, d, 'cp')
g.SetNameTitle(
'g_' + key,
';' + h.GetXaxis().GetTitle() + ';' + h.GetYaxis().GetTitle())
p = Plotter.Plot(g, '', 'pe', 'pe')
canvas = Plotter.Canvas(lumi=lumi)
canvas.addMainPlot(p)
p.setColor(R.kBlue)
canvas.firstPlot.SetMinimum(0.)
canvas.firstPlot.SetMaximum(1.)
fname = 'pdfs/NM1E_{}_{}.pdf'.format(key, name)
canvas.cleanup(fname)
def makeGenRecoPlots():
for ref in HISTS:
if not type(ref) == tuple: continue
if ref[0] == '4Mu':
name = 'HTo2XTo4Mu_'
latexFS = '4#mu'
elif ref[0] == '2Mu2J':
name = 'HTo2XTo2Mu2J_'
latexFS = '2#mu2j'
if TRIGGER:
name = 'Trig-' + name
name += SPStr(ref[1])
lumi = SPLumiStr(ref[0], *ref[1])
colors = {'Matched': R.kRed, 'Closest': R.kBlue}
KEYS = ('Matched', 'Closest')
for MUON in ('DSA', 'REF'):
h, p = {}, {}
for key in KEYS:
h[key] = HISTS[ref]['{}_{}_{}'.format(MUON, 'deltaRGR',
key)].Clone()
RT.addFlows(h[key])
if h[key].GetNbinsX() > 100: h.Rebin(10)
p[key] = Plotter.Plot(h[key], key, 'l', 'hist')
fname = 'pdfs/{}{}_{}_{}_{}.pdf'.format(MUON, CUTSTRING,
'deltaRGR', 'Matched',
name)
canvas = Plotter.Canvas(lumi=lumi)
for key in KEYS:
canvas.addMainPlot(p[key])
p[key].SetLineColor(colors[key])
canvas.makeLegend(lWidth=.25, pos='tr')
canvas.legend.resizeHeight()
canvas.setMaximum()
RT.addBinWidth(canvas.firstPlot)
LPOS = (canvas.legend.GetX1NDC() + .01,
canvas.legend.GetY1NDC() - .04)
for i, key in enumerate(KEYS):
canvas.drawText(text='#color[{}]{{n = {:d}}}'.format(
colors[key], int(p[key].GetEntries())),
pos=(LPOS[0], LPOS[1] - i * 0.04))
canvas.cleanup(fname)
def makeEffPlot(quantity, den, fs, sp=None):
tags = (quantity + '_MSD', quantity + '_LCD', quantity + '_CID')
effTag = quantity + '_CID'
# get/add histograms
if sp is None:
h = {}
for tag in tags:
h[tag] = HistogramGetter.getHistogram(f, (fs, SIGNALPOINTS[0]),
tag).Clone()
for SP in SIGNALPOINTS[1:]:
for tag in tags:
h[tag].Add(HistogramGetter.getHistogram(f, (fs, SP), tag))
else:
h = {}
for tag in tags:
h[tag] = HistogramGetter.getHistogram(f, (fs, sp), tag).Clone()
hNum = h[quantity + '_CID']
h[quantity + '_' + den].Add(h[quantity + '_CID'])
hDen = h[quantity + '_' + den]
graph = R.TGraphAsymmErrors(hNum, hDen, 'cp')
# make plots
p = Plotter.Plot(graph, '', 'l', 'px')
# canvas, plots, min max
canvas = Plotter.Canvas(lumi=SPLumiStr(fs, sp) if sp is not None else fs)
canvas.addMainPlot(p)
canvas.setMaximum()
canvas.firstPlot.SetMinimum(0)
# set titles
canvas.firstPlot.setTitles(X=hNum.GetXaxis().GetTitle(), Y='Efficiency')
# colors
p.setColor(R.kBlue, which='M')
# legend, cleanup
#canvas.makeLegend(lWidth=.2, pos='tr')
#canvas.legend.resizeHeight()
canvas.cleanup('pdfs/3Mu_{}Eff-{}{}_HTo2XTo{}_{}.pdf'.format(
quantity, den, ARGS.CUTSTRING, fs,
SPStr(sp) if sp is not None else 'Global'))
def makeEffPlot(fs, sp):
if sp is None:
hNum = HG.getAddedSignalHistograms(FILES[fs], fs,
['nRec' + MUON for MUON in MUONS])
hDen = HG.getAddedSignalHistograms(FILES[fs], fs,
['nGen' + MUON for MUON in MUONS])
prettyFS = '2#mu' if '2Mu' in fs else '4#mu'
lumi = 'H#rightarrow2X#rightarrow{}, all samples combined{}'.format(
prettyFS, ' + trigger' if ARGS.TRIGGER else '')
else:
hNum, hDen = {}, {}
for MUON in MUONS:
hNum['nRec' + MUON] = HG.getHistogram(FILES[fs], (fs, sp),
'nRec' + MUON).Clone()
hDen['nGen' + MUON] = HG.getHistogram(FILES[fs], (fs, sp),
'nGen' + MUON).Clone()
prettyFS = '2#mu' if '2Mu' in fs else '4#mu'
lumi = 'H#rightarrow2X#rightarrow{} ({} GeV, {} GeV, {} mm){}'.format(
prettyFS, sp[0], sp[1], sp[2],
' + trigger' if ARGS.TRIGGER else '')
c = Plotter.Canvas(lumi=lumi, cWidth=600 if ARGS.SQUARE else 800)
pretty = {'DSA': {'col': R.kBlue}, 'RSA': {'col': R.kRed}}
g, p = {}, {}
for MUON in MUONS:
hNum['nRec' + MUON].Rebin(10)
hDen['nGen' + MUON].Rebin(10)
g[MUON] = R.TGraphAsymmErrors(hNum['nRec' + MUON], hDen['nGen' + MUON],
'cp')
p[MUON] = Plotter.Plot(g[MUON], MUON, 'l', 'p')
c.addMainPlot(p[MUON])
p[MUON].setColor(pretty[MUON]['col'], which='LM')
c.makeLegend(lWidth=0.125, pos='bl')
c.legend.resizeHeight()
c.firstPlot.SetMinimum(0.)
c.firstPlot.SetMaximum(1.)
c.firstPlot.setTitles(X='', Y='', copy=hNum['nRecDSA'])
if ARGS.SQUARE:
c.firstPlot.scaleTitleOffsets(1.1, 'X')
c.cleanup('pdfs/REFF_Lxy{}_{}_{}.pdf'.format(
'_Trig' if ARGS.TRIGGER else '', fs,
'Global' if sp is None else SPStr(sp)),
mode='LUMI')
def makeEffPlots(quantity, fs, SP=None):
HKeys = {
'Eff': '{}Eff',
'Den': '{}Den',
}
for key in HKeys:
HKeys[key] = HKeys[key].format(quantity)
h = {}
p = {}
g = {}
if SP is None:
for i, sp in enumerate(SIGNALPOINTS):
if i == 0:
for key in HKeys:
h[key] = HISTS[(fs, sp)][HKeys[key]].Clone()
h[key].SetDirectory(0)
else:
for key in HKeys:
h[key].Add(HISTS[(fs, sp)][HKeys[key]])
else:
sp = SP
for key in HKeys:
h[key] = HISTS[(fs, sp)][HKeys[key]].Clone()
h[key].SetDirectory(0)
for key in HKeys:
RT.addFlows(h[key])
h[key].Rebin(10)
g['Eff'] = R.TGraphAsymmErrors(h['Eff'], h['Den'], 'cp')
g['Eff'].SetNameTitle(
'g_Eff',
';' + h['Eff'].GetXaxis().GetTitle() + ';Vertex Fit Efficiency')
p['Eff'] = Plotter.Plot(g['Eff'], '', 'elp', 'pe')
canvas = Plotter.Canvas(lumi=fs if SP is None else SPLumiStr(fs, *SP))
canvas.addMainPlot(p['Eff'])
p['Eff'].setColor(R.kBlue)
RT.addBinWidth(canvas.firstPlot)
canvas.firstPlot.SetMinimum(0.)
canvas.firstPlot.SetMaximum(1.)
canvas.cleanup('pdfs/SVFE_{}Eff{}_{}HTo2XTo{}_{}.pdf'.format(
quantity, CUTSTRING, 'Trig-' if TRIGGER else '', fs,
'Global' if SP is None else SPStr(SP)))
def makePlot(fs, sp, quantity):
# configy type stuff
tags = ('Matched', 'Junk')
legs = {'Matched': 'Matched', 'Junk': 'Incorrect Pair'}
cols = {'Matched': R.kBlue, 'Junk': R.kRed}
# get/add histograms
if sp is None:
h = {}
for tag in tags:
h[tag] = HistogramGetter.getHistogram(
f, (fs, SIGNALPOINTS[0]), quantity + '_' + tag).Clone()
for SP in SIGNALPOINTS[1:]:
for tag in tags:
h[tag].Add(
HistogramGetter.getHistogram(f, (fs, SP),
quantity + '_' + tag))
else:
h = {}
for tag in tags:
h[tag] = HistogramGetter.getHistogram(f, (fs, sp), quantity + '_' +
tag).Clone()
# make plots
p = {}
for tag in tags:
p[tag] = Plotter.Plot(h[tag], legs[tag], 'l', 'hist')
# canvas, plots, min max
canvas = Plotter.Canvas(lumi=SPLumiStr(fs, sp) if sp is not None else fs,
logy=True)
for tag in tags:
canvas.addMainPlot(p[tag])
canvas.setMaximum()
# colors
for tag in tags:
p[tag].SetLineColor(cols[tag])
# legend, cleanup
canvas.makeLegend(lWidth=.2, pos='tr')
canvas.legend.resizeHeight()
canvas.cleanup('pdfs/PV_{}{}_HTo2XTo{}_{}.pdf'.format(
quantity, args.CUTSTRING, fs,
SPStr(sp) if sp is not None else 'Global'))
def makeRepEffectPlots(sp=None):
lumi = 'H#rightarrow2X#rightarrow2#mu'
if sp is None:
lumi += ', all samples combined'
else:
lumi += ' ({} GeV, {} GeV, {} mm)'.format(*sp)
hkeys = ('Lxy-before', 'Lxy-after')
if sp is None:
HISTS = HG.getAddedSignalHistograms(FILES['Signal'], '2Mu2J', hkeys)
else:
HISTS = {}
for key in hkeys:
HISTS[key] = HG.getHistogram(FILES['Signal'], ('2Mu2J', sp),
key).Clone()
nPass = HISTS['Lxy-after'].Integral(
HISTS['Lxy-after'].GetXaxis().FindBin(65.),
HISTS['Lxy-after'].GetNbinsX() + 1)
nTot = HISTS['Lxy-before'].Integral(
HISTS['Lxy-before'].GetXaxis().FindBin(65.),
HISTS['Lxy-before'].GetNbinsX() + 1)
print nPass / nTot
for key in hkeys:
HISTS[key].Rebin(2)
g = R.TGraphAsymmErrors(HISTS['Lxy-after'], HISTS['Lxy-before'], 'cp')
p = Plotter.Plot(g, '', '', 'p')
canvas = Plotter.Canvas(lumi=lumi, cWidth=600 if ARGS.SQUARE else 800)
canvas.addMainPlot(p)
p.setColor(R.kBlue)
canvas.firstPlot.setTitles(X='generated L_{xy} [cm]',
Y='Dimuons after / before association')
canvas.firstPlot.SetMaximum(1.)
canvas.firstPlot.SetMinimum(0.)
if ARGS.SQUARE:
canvas.firstPlot.scaleTitleOffsets(1.1, 'X')
canvas.cleanup('pdfs/REPEFF_Signal_{}.pdf'.format(
'Global' if sp is None else SPStr(sp)),
mode='LUMI')
def makeSplit4Plot(quantity, fs, sp=None):
tags = [quantity + '_' + tag for tag in ('CID', 'MSD', 'LCD', 'UMD')]
legs = dict(
zip(tags, ('correct', 'signal', 'lowest #chi^{2}/dof', 'unmatched')))
cols = dict(zip(tags, (R.kBlue, R.kGreen, R.kMagenta, R.kRed)))
# get/add histograms
if sp is None:
h = {}
for tag in tags:
h[tag] = HistogramGetter.getHistogram(f, (fs, SIGNALPOINTS[0]),
tag).Clone()
for SP in SIGNALPOINTS[1:]:
for tag in tags:
h[tag].Add(HistogramGetter.getHistogram(f, (fs, SP), tag))
else:
h = {}
for tag in tags:
h[tag] = HistogramGetter.getHistogram(f, (fs, sp), tag).Clone()
# make plots
p = {}
for tag in tags:
p[tag] = Plotter.Plot(h[tag], legs[tag], 'l', 'hist')
# canvas, plots, min max
canvas = Plotter.Canvas(lumi=SPLumiStr(fs, sp) if sp is not None else fs,
logy=True)
for tag in tags:
canvas.addMainPlot(p[tag])
canvas.setMaximum(scale=2.)
canvas.firstPlot.SetMinimum(1.)
# colors
for tag in tags:
p[tag].setColor(cols[tag], which='L')
# legend, cleanup
canvas.makeLegend(lWidth=.2, pos='tr')
canvas.legend.resizeHeight()
canvas.cleanup('pdfs/3Mu_{}Dist{}_HTo2XTo{}_{}.pdf'.format(
quantity, ARGS.CUTSTRING, fs,
SPStr(sp) if sp is not None else 'Global'))
def makeResPlot(fs, sp):
if sp is None:
h = HG.getAddedSignalHistograms(FILES[fs], fs,
['pTRes-' + MUON for MUON in MUONS])
prettyFS = '2#mu' if '2Mu' in fs else '4#mu'
lumi = 'H#rightarrow2X#rightarrow{}, all samples combined{}'.format(
prettyFS, ' + trigger' if ARGS.TRIGGER else '')
else:
h = {}
for MUON in MUONS:
h['pTRes-' + MUON] = HG.getHistogram(FILES[fs], (fs, sp),
'pTRes-' + MUON).Clone()
prettyFS = '2#mu' if '2Mu' in fs else '4#mu'
lumi = 'H#rightarrow2X#rightarrow{} ({} GeV, {} GeV, {} mm){}'.format(
prettyFS, sp[0], sp[1], sp[2],
' + trigger' if ARGS.TRIGGER else '')
c = Plotter.Canvas(lumi=lumi, cWidth=600 if ARGS.SQUARE else 800)
pretty = {'DSA': {'col': R.kBlue}, 'RSA': {'col': R.kRed}}
p = {}
for MUON in MUONS:
h['pTRes-' + MUON].Scale(
1. /
h['pTRes-' + MUON].Integral(0, h['pTRes-' + MUON].GetNbinsX() + 1))
#h['pTRes-'+MUON].Rebin(10)
p[MUON] = Plotter.Plot(h['pTRes-' + MUON], MUON, 'l', 'hist')
c.addMainPlot(p[MUON])
p[MUON].setColor(pretty[MUON]['col'], which='LM')
c.makeLegend(lWidth=0.125, pos='tr')
c.legend.resizeHeight()
c.setMaximum()
c.firstPlot.setTitles(X='', Y='', copy=h['pTRes-DSA'])
RT.addBinWidth(c.firstPlot)
if ARGS.SQUARE:
c.firstPlot.scaleTitleOffsets(1.1, 'X')
c.firstPlot.scaleTitleOffsets(1.3, 'Y')
c.cleanup('pdfs/PTRES{}_{}_{}.pdf'.format(
'_Trig' if ARGS.TRIGGER else '', fs,
'Global' if sp is None else SPStr(sp)),
mode='LUMI')
def makePTCutPlot(fs, sp=None, PC=False, extra=''):
# configy type stuff
tags = TAGS[ARGS.FS + ('' if not PC else 'PC') + extra]
legs = [CONFIG[tag]['LEG_H'] for tag in tags]
cols = [CONFIG[tag]['COL'] for tag in tags]
# get/add histograms
if sp is None:
h = {}
for tag in tags:
h[tag] = HistogramGetter.getHistogram(f, (fs, SIGNALPOINTS[0]),
tag).Clone()
for SP in SIGNALPOINTS[1:]:
for tag in tags:
h[tag].Add(HistogramGetter.getHistogram(f, (fs, SP), tag))
else:
h = {}
for tag in tags:
h[tag] = HistogramGetter.getHistogram(f, (fs, sp), tag).Clone()
# make plots
p = {}
for i, tag in enumerate(tags):
p[tag] = Plotter.Plot(h[tag], legs[i], 'l', 'hist')
# canvas, plots, min max
canvas = Plotter.Canvas(lumi=SPLumiStr(fs, sp) if sp is not None else fs)
for tag in tags:
canvas.addMainPlot(p[tag])
canvas.setMaximum()
canvas.setMinimum()
# colors
for i, tag in enumerate(tags):
p[tag].SetLineColor(cols[i])
# legend, cleanup
canvas.makeLegend(lWidth=.275, pos='tr')
canvas.legend.resizeHeight()
canvas.cleanup('pdfs/PC_Match{}{}_HTo2XTo{}_{}.pdf'.format(
'-PC' if PC else '', extra, fs,
SPStr(sp) if sp is not None else 'Global'))
def makePerSamplePlots():
for ref in HISTS:
if not type(ref) == tuple: continue
for key in HISTS[ref]:
if 'deltaRGR' in key: continue
if 'VS' in key: continue
if type(ref) == tuple:
if ref[0] == '4Mu':
name = 'HTo2XTo4Mu_'
latexFS = '4#mu'
elif ref[0] == '2Mu2J':
name = 'HTo2XTo2Mu2J_'
latexFS = '2#mu2j'
if TRIGGER:
name = 'Trig-' + name
name += SPStr(ref[1])
lumi = SPLumiStr(ref[0], *ref[1])
legName = HistogramGetter.PLOTCONFIG['HTo2XTo' +
ref[0]]['LATEX']
else:
if '_Matched' in key: continue
name = ref
lumi = HistogramGetter.PLOTCONFIG[ref]['LATEX']
legName = HistogramGetter.PLOTCONFIG[ref]['LATEX']
h = HISTS[ref][key].Clone()
RT.addFlows(h)
if h.GetNbinsX() > 100: h.Rebin(10)
p = Plotter.Plot(h, legName, 'l', 'hist')
fname = 'pdfs/{}{}_{}.pdf'.format(key, CUTSTRING, name)
canvas = Plotter.Canvas(lumi=lumi)
canvas.addMainPlot(p)
canvas.makeLegend(lWidth=.25, pos='tr')
canvas.legend.moveLegend(Y=-.3)
canvas.legend.resizeHeight()
p.SetLineColor(R.kBlue)
RT.addBinWidth(p)
pave = canvas.makeStatsBox(p, color=R.kBlue)
canvas.cleanup(fname)
def makePerSamplePlots():
for ref in HISTS:
for key in HISTS[ref]:
if type(ref) == tuple:
if ref[0] == '4Mu': name = 'HTo2XTo4Mu_'
elif ref[0] == '2Mu2J': name = 'HTo2XTo2Mu2J_'
name += SPStr(ref[1])
if TRIGGER:
name = 'Trig-' + name
lumi = SPLumiStr(ref[0], *ref[1])
legName = HistogramGetter.PLOTCONFIG['HTo2XTo' +
ref[0]]['LATEX']
else:
name = ref
lumi = HistogramGetter.PLOTCONFIG[ref]['LATEX']
legName = HistogramGetter.PLOTCONFIG[ref]['LATEX']
h = HISTS[ref][key].Clone()
RT.addFlows(h)
p = Plotter.Plot(h, legName, 'l', 'hist')
fname = 'pdfs/NM1_{}_{}.pdf'.format(key, name)
canvas = Plotter.Canvas(lumi=lumi)
canvas.lumi += ' : |#Delta#Phi| ' + ('<' if '_Less' in key else
'>') + ' #pi/2'
canvas.addMainPlot(p)
canvas.makeLegend(lWidth=.25, pos='tr')
canvas.legend.moveLegend(Y=-.3)
canvas.legend.resizeHeight()
p.SetLineColor(R.kBlue)
RT.addBinWidth(p)
cutKey = key.replace('_Less', '').replace('_More', '')
cutVal = Selections.CUTS[cutKey].val
l = R.TLine(cutVal, p.GetMinimum(), cutVal, p.GetMaximum() * 1.05)
l.SetLineStyle(2)
l.SetLineWidth(2)
l.Draw()
canvas.cleanup(fname)
def makeSignal2DPlots():
for quantity in ('normChi2', 'nTrkLay', 'nPxlHit', 'highPurity',
'isGlobal', 'isMedium', 'hitsBeforeVtx',
'missingHitsAfterVtx'):
if quantity == 'nTrkLay':
R.gStyle.SetPaintTextFormat('.1f')
else:
R.gStyle.SetPaintTextFormat('g')
hkey = 'PAT-12-' + quantity
HISTS = HG.getAddedSignalHistograms(FILES[fs], fs, (hkey, ))
for sp in SIGNALPOINTS:
HISTS[sp] = HG.getHistogram(FILES[fs], (fs, sp), hkey).Clone()
if quantity != 'normChi2':
opt = 'colz text'
else:
opt = 'colz'
PLOTS = {hkey: Plotter.Plot(HISTS[hkey], '', '', opt)}
for sp in SIGNALPOINTS:
PLOTS[sp] = Plotter.Plot(HISTS[sp], '', '', opt)
for sp in [
hkey,
] + SIGNALPOINTS:
canvas = Plotter.Canvas(lumi=fs + lumiExtra.get(CUTSTRING) if
type(sp) != tuple else SPLumiStr(fs, *sp))
canvas.addMainPlot(PLOTS[sp])
canvas.firstPlot.SetMarkerColor(R.kWhite)
if quantity == 'normChi2':
canvas.firstPlot.GetXaxis().SetRangeUser(0., 10.)
canvas.firstPlot.GetYaxis().SetRangeUser(0., 10.)
canvas.scaleMargins(1.75, edges='R')
canvas.scaleMargins(0.8, edges='L')
canvas.cleanup('pdfs/ZEP_2D_{}_{}_{}_{}.pdf'.format(
quantity, CUTSTRING, fs,
'Global' if type(sp) != tuple else SPStr(sp)))
def makeResPlots(metric, quantity, sp=None):
PRETTY = {
'pTRes_hits_less': {
'mnice': 'p_{T} res.',
'qnice': 'N(hits)',
'leg': 'N(hits) #leq 12',
'col': R.kRed
},
'pTRes_hits_more': {
'mnice': 'p_{T} res.',
'qnice': 'N(hits)',
'leg': 'N(hits) > 12',
'col': R.kBlue
},
'pTRes_fpte_less': {
'mnice': 'p_{T} res.',
'qnice': '#sigma_{p_{T}}/p_{T}',
'leg': '#sigma_{p_{T}}/p_{T} < 1',
'col': R.kBlue
},
'pTRes_fpte_more': {
'mnice': 'p_{T} res.',
'qnice': '#sigma_{p_{T}}/p_{T}',
'leg': '#sigma_{p_{T}}/p_{T} #geq 1',
'col': R.kRed
},
'qdiff_hits_less': {
'mnice': 'charge diff.',
'qnice': 'N(hits)',
'leg': 'N(hits) #leq 12',
'col': R.kRed
},
'qdiff_hits_more': {
'mnice': 'charge diff.',
'qnice': 'N(hits)',
'leg': 'N(hits) > 12',
'col': R.kBlue
},
'qdiff_fpte_less': {
'mnice': 'charge diff.',
'qnice': '#sigma_{p_{T}}/p_{T}',
'leg': '#sigma_{p_{T}}/p_{T} < 1',
'col': R.kBlue
},
'qdiff_fpte_more': {
'mnice': 'charge diff.',
'qnice': '#sigma_{p_{T}}/p_{T}',
'leg': '#sigma_{p_{T}}/p_{T} #geq 1',
'col': R.kRed
},
}
witches = ('less', 'more') if quantity == 'fpte' else ('more', 'less')
hkeys = ['{}_{}_{}'.format(metric, quantity, which) for which in witches]
if sp is None:
HISTS = HG.getAddedSignalHistograms(FILES['Signal'], '2Mu2J', hkeys)
else:
HISTS = {}
for key in hkeys:
HISTS[key] = HG.getHistogram(FILES['Signal'], ('2Mu2J', sp),
key).Clone()
PLOTS = {}
for key in hkeys:
HISTS[key].Scale(1. /
HISTS[key].Integral(0, HISTS[key].GetNbinsX() + 1))
#RT.addFlows(HISTS[key])
PLOTS[key] = Plotter.Plot(HISTS[key], PRETTY[key]['leg'], 'l', 'hist')
#canvas = Plotter.Canvas(lumi='{} by {}'.format(PRETTY[hkeys[0]]['mnice'], PRETTY[hkeys[0]]['qnice']))
lumi = 'H#rightarrow2X#rightarrow2#mu'
if sp is None:
lumi += ', all samples combined'
else:
lumi += ' ({} GeV, {} GeV, {} mm)'.format(*sp)
canvas = Plotter.Canvas(lumi=lumi, cWidth=600 if ARGS.SQUARE else 800)
for key in hkeys:
canvas.addMainPlot(PLOTS[key])
PLOTS[key].setColor(PRETTY[key]['col'], which='L')
canvas.firstPlot.SetMinimum(0.)
canvas.setMaximum()
if metric == 'qdiff':
canvas.firstPlot.SetMaximum(1.)
canvas.firstPlot.setTitles(Y='Density')
if 'qdiff' in hkeys[0]:
canvas.firstPlot.SetNdivisions(3)
canvas.makeLegend(lWidth=0.27, pos='tr')
canvas.legend.resizeHeight()
RT.addBinWidth(canvas.firstPlot)
if ARGS.SQUARE:
canvas.firstPlot.scaleTitleOffsets(1.1, 'X')
if metric == 'pTRes':
canvas.firstPlot.scaleTitleOffsets(1.3, 'Y')
canvas.cleanup('pdfs/QCUTRES_Sig_{}_{}_{}.pdf'.format(
metric, quantity, 'Global' if sp is None else SPStr(sp)),
mode='LUMI')
def optimizeCut(fs, sp, quantity):
# get histograms
s = getHistogram(f, fs, sp, quantity, 'Matched')
b = getHistogram(f, fs, sp, quantity, 'Junk' )
# get cumulatives
sCum = s.GetCumulative()
bCum = b.GetCumulative()
fom = sCum.Clone()
# print out suppression
nBins = sCum.GetNbinsX()
if quantity == 'LxyErr':
ibin = 200
else:
ibin = 660
srej = 1.-sCum.GetBinContent(ibin)/sCum.GetBinContent(nBins)
brej = 1.-bCum.GetBinContent(ibin)/bCum.GetBinContent(nBins)
#print '{:5s} {:4d} {:3d} {:4d} :: {:6s} :: reject {:6.2%} of signal, but {:6.2%} of background'.format(
# fs,
# sp[0], sp[1], sp[2],
# quantity,
# 1.-sCum.GetBinContent(ibin)/sCum.GetBinContent(nBins),
# 1.-bCum.GetBinContent(ibin)/bCum.GetBinContent(nBins),
#)
# fill f.o.m. histogram, and keep track of max f.o.m. and cut value
nBins = sCum.GetNbinsX()
xAxis = sCum.GetXaxis()
fom_max = 0.
opt_cut = 0.
for ibin in range(1,nBins+1):
val = FOM(sCum.GetBinContent(ibin), bCum.GetBinContent(ibin))
if val > fom_max:
fom_max = val
opt_cut = xAxis.GetBinCenter(ibin)
fom.SetBinContent(ibin, val)
# make plots
p = {}
p['sig'] = Plotter.Plot(sCum, 'matched' , 'l', 'hist')
p['bg' ] = Plotter.Plot(bCum, 'other' , 'l', 'hist')
p['fom'] = Plotter.Plot(fom , 'S/#sqrt{S+B}', 'l', 'hist')
# make canvas, colors, maximum
canvas = Plotter.Canvas(lumi=SPLumiStr(fs, *sp))
canvas.addMainPlot(p['sig'])
canvas.addMainPlot(p['bg' ])
canvas.addMainPlot(p['fom'])
p['sig'].SetLineColor(R.kBlue )
p['bg' ].SetLineColor(R.kRed )
p['fom'].SetLineColor(R.kGreen)
canvas.setMaximum()
# scale f.o.m. and make new axis
fom.Scale(canvas.firstPlot.GetMaximum()/fom_max/1.05)
axis = R.TGaxis(xAxis.GetXmax(), 0., xAxis.GetXmax(), canvas.firstPlot.GetMaximum(), 0., fom_max*1.05, 510, '+L')
for attr in ('LabelFont', 'LabelOffset', 'TitleFont', 'TitleOffset', 'TitleSize'):
getattr(axis, 'Set'+attr)(getattr(xAxis, 'Get'+attr)())
axis.SetTitle('Figure of Merit')
axis.CenterTitle()
axis.Draw()
canvas.scaleMargins(1.1, edges='R')
# make the legend after
canvas.makeLegend(lWidth=.2, pos='br')
canvas.legend.resizeHeight()
# draw optimum text and line
x, y = canvas.legend.GetX1(), canvas.legend.GetY2()
canvas.drawText(text='#color[{:d}]{{opt. cut = {:.2f}}}'.format(R.kBlack, opt_cut), pos=(x, y+0.05), align='bl')
line = R.TLine(opt_cut, 0., opt_cut, canvas.firstPlot.GetMaximum())
line.SetLineStyle(2)
line.Draw()
# save
canvas.cleanup('OPT_{}_HTo2XTo{}_{}.pdf'.format(quantity, fs, SPStr(sp)))
# save cut val
if sp not in DATA[fs]: DATA[fs][sp] = {}
if quantity not in DATA[fs][sp]: DATA[fs][sp][quantity] = {
'opt':0,
'srej':0,
'brej':0,
}
DATA[fs][sp][quantity]['opt'] = opt_cut
DATA[fs][sp][quantity]['srej'] = srej
DATA[fs][sp][quantity]['brej'] = brej
def getHistogram(f, fs, sp, quantity, which):
return f.Get(quantity+'_'+which+'_HTo2XTo'+fs+'_'+SPStr(sp)).Clone()
def makeBinnedResPlotBinwise(MUONS, outputTag, quantity, q2, fs, sp):
defaultColorOrder = (R.kRed, R.kBlue, R.kGreen, R.kMagenta)
h = {}
for MUON in MUONS:
h[MUON] = HistogramGetter.getHistogram(f, (fs, sp), '{M}_{Q}ResVS{Q2}'.format(M=MUON, Q=quantity, Q2=q2)).Clone()
# leaving space for the bin number
fname = 'pdfs/SRR_{}_{}_{}-Binned-Bin-{{}}_{}HTo2XTo{}_{}.pdf'.format(outputTag, quantity+'Res', q2, 'Trig-' if TRIGGER else '', fs, SPStr(sp))
pretty, binranges, values, colors, colors2, legName = getBinningValues(q2)
for i, key in enumerate(binranges):
canvas = Plotter.Canvas(lumi=SPLumiStr(fs, *sp))
projections, plots = {}, {}
for j, MUON in enumerate(MUONS):
projections[MUON] = h[MUON].ProjectionY('_'+str(i)+'_'+str(j), key[0], key[1])
plots[MUON] = Plotter.Plot(projections[MUON], MUON, 'l', 'hist')
RT.addFlows(plots[MUON])
plots[MUON].Rebin(10)
if plots[MUON].Integral() != 0:
plots[MUON].Scale(1./plots[MUON].Integral())
plots[MUON].SetLineColor(defaultColorOrder[j])
canvas.addMainPlot(plots[MUON])
canvas.makeLegend(lWidth=.25, pos='tr')
canvas.legend.resizeHeight()
canvas.setMaximum(recompute=True)
canvas.drawText(legName.format(Q2=pretty, V1=values[key][0], V2=values[key][1]), (canvas.legend.GetX1NDC()+.01, canvas.legend.GetY1NDC()-.04))
for j, MUON in enumerate(MUONS):
plots[MUON].SetLineColor(defaultColorOrder[j])
plots[MUON].setTitles(X=plots[MUON].GetXaxis().GetTitle(), Y='Normalized Counts')
canvas.drawText('#color[{}]{{'.format(defaultColorOrder[j]) + 'RMS = {:.4f}'.format(plots[MUON].GetStdDev()) + '}',
(canvas.legend.GetX1NDC()+.01, canvas.legend.GetY1NDC()-(j*0.04)-.08)
)
RT.addBinWidth(canvas.firstPlot)
canvas.cleanup(fname.format(i+1))
def makeBinnedResPlot(MUON, fs, sp, quantity, q2):
h = HistogramGetter.getHistogram(f, (fs, sp), '{M}_{Q}ResVS{Q2}'.format(M=MUON, Q=quantity, Q2=q2)).Clone()
fname = 'pdfs/SRR_{}_{}_{}-Binned_{}HTo2XTo{}_{}.pdf'.format(MUON, quantity+'Res', q2, 'Trig-' if TRIGGER else '', fs, SPStr(sp))
pretty, binranges, values, colors, colors2, legName = getBinningValues(q2)
projections = {key:h.ProjectionY('_'+str(i), key[0], key[1]) for i,key in enumerate(binranges)}
plots = {key:Plotter.Plot(projections[key], legName.format(Q2=pretty, V1=values[key][0], V2=values[key][1]), 'l', 'hist') for key in binranges}
canvas = Plotter.Canvas(lumi=SPLumiStr(fs, *sp))
for key in binranges:
RT.addFlows(plots[key])
plots[key].Rebin(10)
if plots[key].Integral() != 0:
plots[key].Scale(1./plots[key].Integral())
canvas.addMainPlot(plots[key])
canvas.makeLegend(lWidth=.25, pos='tr')
canvas.legend.moveLegend(X=-.08)
canvas.legend.resizeHeight()
canvas.setMaximum(recompute=True)
for i, key in enumerate(binranges):
plots[key].SetLineColor(colors[key])
plots[key].setTitles(X=plots[key].GetXaxis().GetTitle(), Y='Normalized Counts')
canvas.drawText('#color[{}]{{'.format(colors2[key]) + 'RMS = {:.4f}'.format(plots[key].GetStdDev()) + '}',
(canvas.legend.GetX1NDC()+.01, canvas.legend.GetY1NDC()-(i*0.04)-.04)
)
RT.addBinWidth(canvas.firstPlot)
canvas.cleanup(fname)
def makeColorPlot(MUON, fs, quantity, sp=None, q2=None):
if q2 is None:
fstring = '{M}_{Q}VS{Q}'.format(M=MUON, Q=quantity)
else:
fstring = '{M}_{Q}ResVS{Q2}'.format(M=MUON, Q=quantity, Q2=q2)
if sp is None:
for i, SP in enumerate(SIGNALPOINTS):
if i == 0:
h = HistogramGetter.getHistogram(f, (fs, SP), fstring).Clone()
else:
h.Add(HistogramGetter.getHistogram(f, (fs, SP), fstring).Clone())
fname = 'pdfs/SRR_{}_{}HTo2XTo{}_Global.pdf'.format(fstring, 'Trig-' if TRIGGER else '', fs)
else:
h = HistogramGetter.getHistogram(f, (fs, sp), fstring).Clone()
fname = 'pdfs/SRR_{}_{}HTo2XTo{}_{}.pdf'.format(fstring, 'Trig-' if TRIGGER else '', fs, SPStr(sp))
h.Rebin2D(10, 10)
p = Plotter.Plot(h, '', '', 'colz')
canvas = Plotter.Canvas(lumi=SPLumiStr(fs, *sp) if sp is not None else fs)
canvas.mainPad.SetLogz(True)
canvas.addMainPlot(p)
canvas.scaleMargins(1.75, edges='R')
canvas.scaleMargins(0.8, edges='L')
canvas.cleanup(fname)
def makeSimplePlots(quantity, fs, SP=None, normalize=False):
range_limits = {
'pT': [0., 300.],
'eta': None,
'phi': None,
'd0': None,
'Lxy': [0., (500. if SP is None else \
SAMPLE_SPECS[fs]['{}_{}_{}'.format(*SP)]['xmax'])],
'deltaR': None,
'mass': None,
'cosAlpha': None,
'dimuonPTOverM': [0, 10],
'XBeta': None,
}
HKeys = {
'GEN_Den' : 'GEN_{}Den',
'DSA_Den' : 'DSA_{}Den',
'RSA_Den' : 'RSA_{}Den',
}
for key in HKeys:
HKeys[key] = HKeys[key].format(quantity, 'HTo2XTo'+fs)
h = {}
p = {}
if SP is None:
for i, sp in enumerate(SIGNALPOINTS):
if i == 0:
for key in HKeys:
h[key] = HISTS[(fs, sp)][HKeys[key]].Clone()
h[key].Sumw2()
h[key].SetDirectory(0)
else:
for key in HKeys:
h[key].Sumw2()
h[key].Add(HISTS[(fs, sp)][HKeys[key]])
else:
for key in HKeys:
h[key] = HISTS[(fs, SP)][HKeys[key]].Clone()
h[key].Sumw2()
if normalize is True and h[key].Integral() != 0:
h[key].Scale(1/h[key].Integral())
h[key].SetDirectory(0)
for key in HKeys:
RT.addFlows(h[key])
nConcatBins = 20 if SP is None else \
SAMPLE_SPECS[fs]['{}_{}_{}'.format(*SP)]['rebin']
h[key].Rebin(nConcatBins)
if quantity == 'deltaR':
ratio_cut = 0.5
hist_ratios = {}
for key in HKeys:
num_before_cut = 0
num_after_cut = 0
for i in range(h[key].GetNbinsX()+1):
if h[key].GetXaxis().GetBinCenter(i) < ratio_cut:
num_before_cut += h[key].GetBinContent(i)
else:
num_after_cut += h[key].GetBinContent(i)
if num_before_cut+num_after_cut != 0:
hist_ratios[key] = 1.0*num_before_cut/(num_before_cut+num_after_cut)
else:
hist_ratios[key] = -1
HistSpecs = (
('GEN_Den', 'GEN', R.kGreen, 'Yield [a.u.]'),
('DSA_Den', 'DSA', R.kBlue, 'Yield [a.u.]'),
('RSA_Den', 'RSA', R.kRed, 'Yield [a.u.]'),
)
for key, leg, col, yTitle in HistSpecs:
if range_limits[quantity] is not None:
h[key].GetXaxis().SetRangeUser(
range_limits[quantity][0],
range_limits[quantity][1])
h[key].SetNameTitle('h_'+key,
';'+h[key].GetXaxis().GetTitle() + '; ' + \
('Normalized ' if normalize is True else '') + yTitle)
# leg += (': yield(#Delta R<0.5) #times 100 / (total yield) = {}'.format(
# round(hist_ratios[key]*100,2)) if quantity == 'deltaR' else '')
p[key] = Plotter.Plot(h[key], leg, '', 'hist e1 x0')
FIRST = (0, 3)
CHARGE = ''
for SECTION in (FIRST,):
fraction_str = '' if SP is None else '[{}%, {}%]'.format(
round(SAMPLE_SPECS[fs]['{}_{}_{}'.format(*SP)]['fractions'][0], 1),
round(SAMPLE_SPECS[fs]['{}_{}_{}'.format(*SP)]['fractions'][1], 1))
canvas = Plotter.Canvas(lumi = fs if SP is None else \
'{} ({} GeV, {} GeV, {} mm) ' \
'#scale[0.7]{{{fraction_str}}}'.format(
fs, *SP, fraction_str=fraction_str))
for i in range(SECTION[0], SECTION[1]):
key = HistSpecs[i][0]
col = HistSpecs[i][2]
yTitle = HistSpecs[i][3]
canvas.addMainPlot(p[key])
p[key].SetMarkerColor(col)
p[key].SetLineColor(col)
# p[key].firstPlot.SetYTitle(yTitle)
canvas.makeLegend(pos='tl')
canvas.legend.moveLegend(X=0.15)
canvas.legend.resizeHeight()
RT.addBinWidth(canvas.firstPlot)
canvas.cleanup(OUTPUT_PATH + FILENAME_OUT.format('STD', LXYMIN, LXYMAX, quantity, fs, 'Global' if SP is None else SPStr(SP)))
def makeEffPlots(quantity, fs, SP=None):
range_limits = {
'pT': [0., 300.],
'eta': None,
'phi': None,
'd0': None,
'Lxy': [0., (500. if SP is None else \
SAMPLE_SPECS[fs]['{}_{}_{}'.format(*SP)]['xmax'])],
'deltaR': None,
'mass': None,
'cosAlpha': None,
'dimuonPTOverM': [0, 10],
'XBeta': None,
}
HKeys = {
'GEN_Eff' : 'GEN_{}Num' ,
'GEN_Den' : 'GEN_{}Den' ,
'DSA_Eff' : 'DSA_{}Num' ,
'DSA_Den' : 'DSA_{}Den' ,
'RSA_Eff' : 'RSA_{}Num' ,
'RSA_Den' : 'RSA_{}Den' ,
}
for key in HKeys:
HKeys[key] = HKeys[key].format(quantity, 'HTo2XTo'+fs)
h = {}
p = {}
g = {}
hm = {}
if SP is None:
for i, sp in enumerate(SIGNALPOINTS):
if i == 0:
for key in HKeys:
h[key] = HISTS[(fs, sp)][HKeys[key]].Clone()
h[key].SetDirectory(0)
else:
for key in HKeys:
h[key].Add(HISTS[(fs, sp)][HKeys[key]])
else:
sp = SP
for key in HKeys:
h[key] = HISTS[(fs, sp)][HKeys[key]].Clone()
h[key].SetDirectory(0)
for key in HKeys:
RT.addFlows(h[key])
nConcatBins = 20 if SP is None else \
SAMPLE_SPECS[fs]['{}_{}_{}'.format(*SP)]['rebin']
h[key].Rebin(nConcatBins)
# h[key].Rebin(30)
NumDens = (
('GEN_Eff' , 'GEN_Den' , 'GEN' , R.kGreen ),
('DSA_Eff' , 'DSA_Den' , 'DSA' , R.kBlue ),
('RSA_Eff' , 'RSA_Den' , 'RSA' , R.kRed ),
)
for num, den, leg, col in NumDens:
g[num] = R.TGraphAsymmErrors(h[num], h[den], 'cp')
g[num].SetNameTitle('g_'+num, ';'+h[num].GetXaxis().GetTitle()+'; Trigger Efficiency')
# g[num].GetXaxis().SetRangeUser(0., 30.)
if range_limits[quantity] is not None:
g[num].GetXaxis().SetLimits(
range_limits[quantity][0],
range_limits[quantity][1])
p[num] = Plotter.Plot(g[num], leg, 'elp', 'pe')
h[num].Sumw2()
h[den].Sumw2()
ratio_hist = R.TEfficiency(h[num], h[den])
eff_sum_num = 0
eff_sum_den = 0
for binx in range(1,h[num].GetXaxis().GetNbins()+2):
# if h[num].GetBinLowEdge(binx) > 250: continue
glob_bin = ratio_hist.GetGlobalBin(binx)
efferror = max(ratio_hist.GetEfficiencyErrorLow(glob_bin),
ratio_hist.GetEfficiencyErrorUp(glob_bin))
if efferror != 0:
eff_sum_num += ratio_hist.GetEfficiency(glob_bin) / \
(efferror*efferror)
if ratio_hist.GetEfficiency(glob_bin) != 0:
eff_sum_den += 1/(efferror*efferror)
if eff_sum_den != 0:
hm[num] = eff_sum_num / eff_sum_den
FIRST = (0, 3)
# SECOND = (3, 5)
CHARGE = ''
for SECTION in (FIRST,):
fraction_str = '' if SP is None else '[{}%, {}%]'.format(
round(SAMPLE_SPECS[fs]['{}_{}_{}'.format(*SP)]['fractions'][0], 1),
round(SAMPLE_SPECS[fs]['{}_{}_{}'.format(*SP)]['fractions'][1], 1))
canvas = Plotter.Canvas(lumi = fs if SP is None else \
'{} ({} GeV, {} GeV, {} mm) ' \
'#scale[0.7]{{{fraction_str}}}'.format(
fs, *SP, fraction_str=fraction_str))
for i in range(SECTION[0], SECTION[1]):
key = NumDens[i][0]
col = NumDens[i][3]
canvas.addMainPlot(p[key])
p[key].SetMarkerColor(col)
p[key].SetLineColor(col)
# if quantity in ['Lxy','pT']:
# axis_min = p[key].GetXaxis().GetBinLowEdge(1)
# axis_max = p[key].GetXaxis().GetBinLowEdge(p[key].GetXaxis().GetNbins()+1)
# hline = R.TLine(axis_min, hm[key], range_limits[quantity][1], hm[key])
# R.SetOwnership(hline, 0)
# hline.SetLineColor(col)
# hline.Draw()
canvas.makeLegend(pos='tr')
canvas.legend.moveLegend(X=-0.18)
canvas.legend.resizeHeight()
canvas.firstPlot.SetMinimum(0.)
canvas.firstPlot.SetMaximum(1.)
RT.addBinWidth(canvas.firstPlot)
if quantity == 'pT':
vline = R.TLine(28.,0.,28.,1.) # draw vertical line at 28 GeV
R.SetOwnership(vline, 0)
vline.SetLineColor(15)
vline.Draw()
canvas.cleanup(OUTPUT_PATH + FILENAME_OUT.format('STE', LXYMIN, LXYMAX, quantity, fs, 'Global' if SP is None else SPStr(SP)))
def makeOverlaidResPlot(MUONS, fs, sp, quantity, outputTag=None):
# whether the plot is dif or res makes a difference wrt binning, fit range, and stats box positions
# only pT is a res type; the others are all dif types
ISDIF = quantity != 'pT'
# what to name the plot. if MUONS is length 1, no sense to pass it twice, so get it automatically
if outputTag is None:
outputTag = MUONS[0]
# colors, in order of MUONS, and also hashed
defaultColorOrder = (R.kBlue, R.kRed, R.kGreen)
colorDict = dict(zip(MUONS, defaultColorOrder))
# get histograms and define plots
h = {}
for MUON in MUONS:
h[MUON] = HistogramGetter.getHistogram(f, (fs, sp), MUON+'_'+quantity+'Res').Clone()
p = {}
for MUON in MUONS:
RT.addFlows(h[MUON])
if not ISDIF:
h[MUON].Rebin(5)
else:
h[MUON].Rebin(10)
p[MUON] = Plotter.Plot(h[MUON], 'Signal MC ({})'.format(MUON[:3]), 'l', 'hist')
# define and fit gaussians to everything. Set FITRANGE to be something useful.
funcs = {}
fplots = {}
for MUON in MUONS:
if quantity == 'pT':
FITRANGE = (-0.4, 0.3)
elif quantity == 'eta':
FITRANGE = (-0.1, 0.1)
else:
FITRANGE = (-20., 20.)
funcs[MUON] = R.TF1('f'+MUON, 'gaus', *FITRANGE)
h[MUON].Fit('f'+MUON, 'R')
fplots[MUON] = Plotter.Plot(funcs[MUON], 'Gaussian fit ({})'.format(MUON[:3]), 'l', '')
# define canvas, add plots. addS is so that statsbox will be drawn later.
# these all should be pretty obvious until...
canvas = Plotter.Canvas(lumi=SPLumiStr(fs, *sp))
for i, MUON in enumerate(MUONS):
canvas.addMainPlot(p[MUON], addS=True if i!=0 else False)
canvas.addMainPlot(fplots[MUON])
if len(MUONS) > 1:
canvas.firstPlot.setTitles(X=canvas.firstPlot.GetXaxis().GetTitle().replace(MUONS[0],'Reco'))
canvas.makeLegend(lWidth=.25, pos='tl')
canvas.legend.resizeHeight()
for MUON in MUONS:
p [MUON].SetLineColor(colorDict[MUON] )
fplots[MUON].SetLineColor(colorDict[MUON]+1)
RT.addBinWidth(canvas.firstPlot)
# dif type: fit boxes go down the left side
# res type: fit boxes go down the middle
# stats boxes are on the right
paves = []
for i, MUON in enumerate(MUONS):
paves.append(canvas.makeStatsBox(p[MUON], color=colorDict[MUON]))
Plotter.MOVE_OBJECT(paves[-1], Y=-.2*i)
if not ISDIF:
canvas.setFitBoxStyle(h[MUON], lWidth=0.275, pos='tr')
else:
canvas.setFitBoxStyle(h[MUON], lWidth=0.275, pos='tl')
sbox = p[MUON].FindObject('stats')
sbox.SetTextColor(colorDict[MUON]+1)
if not ISDIF:
Plotter.MOVE_OBJECT(sbox, Y=-.15*i, X=-.18, NDC=True)
else:
Plotter.MOVE_OBJECT(sbox, Y=-.15*i-0.04*4.1, NDC=True)
fname = 'pdfs/SRR_{}_{}_{}HTo2XTo{}_{}.pdf'.format(outputTag, quantity+'Res', 'Trig-' if TRIGGER else '', fs, SPStr(sp))
canvas.cleanup(fname)