def testHistogramStore():
from plotting.Cut import Cut
from plotting.Dataset import Dataset
from plotting.Variable import Binning, Variable
from plotting.Systematics import nominalSystematics as s
# create some required objects
v = Variable('tau_pt',
title='p_{T}^{#tau}',
unit='GeV',
binning=Binning(20, -3, 3))
histogramTitle = 'TestHistogram'
h = v.createHistogram('TestHistogram')
h.FillRandom('gaus', 1000)
c = Cut('signal_region', cut='|tau_eta| < 2.5')
d = Dataset('test_dataset')
# create a histogram store
storeFileName = 'testHistogramStore.root'
store = HistogramStore(storeFileName)
# store objects by hash value instead of names
store.useHash = True
# store a histogram
store.putHistogram(d, s, v, c, h)
# close the store
store.close()
# retrieve a histogram (automatically opens the file again)
h = store.getHistogram(d, s, v, c)
# clean up
store.close()
os.remove(storeFileName)
# check if everything worked and the histograms are actually the same
return h.GetTitle() == histogramTitle
def __init__(self,
name,
title=None,
unit='',
binning=Binning(),
defaultCut=Cut(),
variables=[]):
## Default constructor
# @param name name
# @param title title used for example in axis lables (default uses name)
# @param unit name of the unit
# @param binning binning object
# @param defaultCut cut that should be applied whenever this variable is plotted
Variable.__init__(self, name, None, title, unit, binning, defaultCut)
self.variables = variables
def storeHistogram(var, lumi, cut, histo, filename):
# Plotting Data
# ------------------
bp = BasicPlot(filename, var)
bp.addHistogram(histo, 'E', copy=True)
bp.titles.append(
"#sqrt{{s}} = 13 TeV, #scale[0.5]{{#int}}Ldt = {0:.2f} fb^{{-1}}".
format(lumi / 1000.))
bp.yVariable = Variable("Events")
bp.normalizeByBinWidth = False
bp.showBinWidthY = False
bp.normalized = False
bp.logY = False
bp.yVariable.binning.low = 0 # start y-axis at 0
bp.draw()
bp.saveAsAll(os.path.join(outFolder, bp.title))
# storing histogram in root file
# ------------------------------
from ROOT import TFile, TObject
rootfile = TFile.Open(outFolder + '/' + filename + '.root', 'update')
if rootfile.IsOpen():
print "writing in file {}".format(outFolder + '/' + filename + '.root')
rootfile.cd()
histogram = histo.Clone('h_' + var.name)
histogram.SetTitle('h_' + var.name)
histogram.Write('h_' + var.name, TObject.kOverwrite)
rootfile.Close()
else:
print "Problem opening file {}".format(outFolder + '/' + filename +
'.root')
def PlotAndStore(var,
filename,
lumi,
h_1,
h_2=None,
h_3=None,
drawOneLine=False,
simulation=False,
yLabel="Fake Rate",
yLow=0,
yHigh=None):
bp = BasicPlot(filename, var)
# Add histos
SetHistStyle(h_1, 0)
bp.addHistogram(h_1, 'E', copy=True)
if h_2:
SetHistStyle(h_2, 1)
bp.addHistogram(h_2, 'E', copy=True)
if h_3:
SetHistStyle(h_3, 2)
bp.addHistogram(h_3, 'E', copy=True)
# Draw a line at 1 e.g. for SF plots
if drawOneLine:
h_tmp = var.createHistogram('')
for i_bin in range(h_tmp.GetNbinsX() + 2):
h_tmp.SetBinContent(i_bin, 1)
h_tmp.SetBinError(i_bin, 0)
h_tmp.SetLineColor(kGray)
bp.addHistogram(h_tmp, 'E')
# Some further settings
bp.titles.append(
'#sqrt{{s}} = 13 TeV, #scale[0.5]{{#int}}Ldt = {0:.2f} fb^{{-1}}'.
format(lumi / 1000.))
bp.legendDecorator.textSize = 0.045
if simulation:
bp.titles.append('Simulation')
bp.showBinWidthY = False
bp.logY = False
bp.normalized = False
bp.normalizeByBinWidth = False
bp.yVariable = Variable(yLabel)
bp.yVariable.binning.low = yLow
bp.yVariable.binning.up = yHigh
# Plot and store
bp.draw()
bp.saveAsAll(os.path.join(outFolder, bp.title))
def __init__(self,
title='DataMcPlot',
xVariable=None,
yVariableUp=var_Events,
yVariableDown=Variable('Syst/Nom',
binning=Binning(40, 0.6, 1.4)),
upperFraction=0.7,
lowerFraction=0.3):
DoublePlot.__init__(self, title, xVariable, yVariableUp, yVariableDown,
upperFraction, lowerFraction)
from ROOT import TF1
self.dataHist = None
self.upMcRatioHist = None
self.nomMcRatioHist = None
self.downMcRatioHist = None
self.upMcHist = None
self.nomMcHist = None
self.downMcHist = None
self.dataMcRatioHist = None
self.baseLine = TF1('%s_baseLine' % self.title, '1',
xVariable.binning.low, xVariable.binning.up)
self.mcErrorStyle = self.defaultMcErrorStyle
self.baseLineStyle = self.defaultBaseLineStyle
self.systlist = []
def __init__(self,
title='DataMcPlot',
xVariable=None,
yVariableUp=var_Events,
yVariableDown=Variable('Data/MC',
binning=Binning(40, 0.6, 1.4)),
upperFraction=0.7,
lowerFraction=0.3):
DoublePlot.__init__(self, title, xVariable, yVariableUp, yVariableDown,
upperFraction, lowerFraction)
from ROOT import TF1
#@param dataHist Data on main plot (need to change to TAsymErrors?)
#@param sumMcHist MC error on main plot
#@param sumMcRatioHist MC error on ratio plot
#@param dataMcRatioHist Data on ratio plot
self.dataHist = None
self.sumMcHist = None
self.sumSystMcHist = None
self.sumMcRatioHist = None
self.dataMcRatioHist = None
self.baseLine = TF1('%s_baseLine' % self.title, '1',
xVariable.binning.low, xVariable.binning.up)
self.mcErrorStyle = self.defaultMcErrorStyle
self.baseLineStyle = self.defaultBaseLineStyle
"Region 2",
cut=selections[0] +
sel_p[i_p] +
cut_option_region2,
luminosity=lumi,
weight=tmp_weight)
sys.stdout.write('.')
sys.stdout.flush()
h_var_r1.SetLineColor(kRed)
h_var_r1.SetMarkerColor(kRed)
h_var_r2.SetLineColor(kBlue)
h_var_r2.SetMarkerColor(kBlue)
bp = BasicPlot(
'Q-G-Separation' + sel_p_suffix[i_p] + '_' +
var.name + cut_option_suffix, var)
bp.yVariable = Variable("Events with quark match")
bp.yVariable.binning.low = 0
bp.yVariable.binning.up = None
bp.showBinWidthY = False
bp.addHistogram(h_var_r1, 'E', copy=True)
bp.addHistogram(h_var_r2, 'E', copy=True)
bp.titles.append(
'#sqrt{{s}} = 13 TeV, #scale[0.5]{{#int}}Ldt = {0:.2f} fb^{{-1}}, '
.format(lumi / 1000.))
bp.draw()
bp.saveAsAll(os.path.join("plots/", bp.title))
# print quark rate
h_var_tot_r1 = process.getHistogram(var,
"Region 1",
cut=selections[3] +
sel_p[i_p] +
def testSystematicsCalculator():
from plotting.AtlasStyle import Style
from plotting.Cut import Cut
from plotting.Dataset import Dataset
from plotting.DataMcRatioPlot import DataMcRatioPlot
from plotting.DoublePlot import DoublePlot
from plotting.HistogramStore import HistogramStore
from plotting.Systematics import Systematics
from plotting.Tools import divideGraphs
from plotting.Variable import Binning, Variable
from ROOT import TF1, kViolet, kCyan, kBlack, kDashed
cut = Cut()
luminosity = 36.2
f_zpeak = TF1('z-peak', 'TMath::Voigt((1./[0])*x-91.2, [1], 2.5)')
f_zpeak.SetParNames('TES', 'TER')
f_zpeak.SetParameter('TES', 1.0)
f_zpeak.SetParameter('TER', 10.)
f_cont = TF1('continuum', '[0]*1./x')
f_cont.SetParNames('TES')
f_cont.SetParameter('TES', 1.0)
f_zpeak.SetParameter('TER', 10.)
var = Variable('dimuon_mass',
title='#it{m_{#tau#tau}}',
unit='GeV',
binning=Binning(20, 50., 150.))
store = HistogramStore('testHistogramStore.root')
z_jets = Dataset('z_jets',
'#it{Z}+jets',
style=Style(kCyan),
crossSection=0.0004)
continuum = Dataset('continuum',
'Others',
style=Style(kViolet),
crossSection=0.002)
sysLumi = Systematics.scaleSystematics('sysLumi', 'Lumi', 1.031, 0.968,
1.0)
sysTES = Systematics.treeSystematics('sysTES', 'TES', 'tes_up', 'tes_down')
sysTER = Systematics.treeSystematics('sysTER', 'TER', 'ter_up', 'ter_down')
mcStat = 500000
datasets = [continuum, z_jets]
functions = {z_jets: f_zpeak, continuum: f_cont}
for dataset in datasets:
dataset.addSystematics(sysTES)
dataset.addSystematics(sysLumi)
h = var.createHistogram(dataset.title)
f = functions[dataset]
h.FillRandom(f.GetName(), mcStat)
store.putHistogram(dataset, dataset.nominalSystematics, var, cut, h)
h.Reset()
f.SetParameter('TES', 1.02)
h.FillRandom(f.GetName(), mcStat)
store.putHistogram(dataset, sysTES.up, var, cut, h)
h.Reset()
f.SetParameter('TES', 0.98)
h.FillRandom(f.GetName(), mcStat)
store.putHistogram(dataset, sysTES.down, var, cut, h)
f.SetParameter('TES', 1.0)
z_jets.addSystematics(sysTER)
h.Reset()
f_zpeak.SetParameter('TER', 13)
h.FillRandom(f_zpeak.GetName(), mcStat)
store.putHistogram(z_jets, sysTER.up, var, cut, h)
h.Reset()
f.SetParameter('TER', 7)
h.FillRandom(f_zpeak.GetName(), mcStat)
store.putHistogram(z_jets, sysTER.down, var, cut, h)
p = DataMcRatioPlot('testPlot', var)
for dataset in datasets:
dataset.histogramStore = store
p.addHistogram(
dataset.getHistogram(var, cut=cut, luminosity=luminosity))
systGraph = calculateSystematicsGraph(datasets, var, luminosity=luminosity)
systGraph.SetTitle('Combined Systematics')
p.defaultCombinedErrorStyle.apply(systGraph)
p.setMCSystematicsGraph(systGraph)
p.draw()
p.saveAs('test.pdf')
p1 = DoublePlot('testPlot1',
var,
yVariableDown=Variable('Ratio',
binning=Binning(low=0.8, up=1.2)))
p1.plotDown.yVariable.binning.nDivisions = 205
nominalHist = None
systematicsSet = SystematicsSet()
for dataset in datasets:
systematicsSet |= dataset.combinedSystematicsSet
h = dataset.getHistogram(var, cut=cut, luminosity=luminosity)
if nominalHist:
nominalHist.Add(h)
else:
nominalHist = h
nominalHist.SetLineColor(kBlack)
nominalHist.SetTitle('Nominal')
p1.plotUp.addGraph(systGraph, '2')
p1.plotUp.addHistogram(nominalHist)
rSystGraph = systGraph.Clone()
rSystGraph.SetTitle()
p1.plotDown.addGraph(rSystGraph, '2')
divideGraphs(rSystGraph, nominalHist)
lineColor = 1
for systematics in systematicsSet:
lineColor += 1
upHist = None
downHist = None
# collect all up and down histograms for all datasets
for dataset in datasets:
upH = dataset.getHistogram(var,
cut=cut,
luminosity=luminosity,
systematicVariation=systematics.up)
downH = dataset.getHistogram(var,
cut=cut,
luminosity=luminosity,
systematicVariation=systematics.down)
downH.SetLineColor(lineColor)
downH.SetLineStyle(kDashed)
if upH:
if upHist:
upHist.Add(upH)
else:
upHist = upH
if downH:
if downHist:
downHist.Add(downH)
else:
downHist = downH
upHist.SetLineColor(lineColor)
upHist.SetTitle(systematics.title)
downHist.SetLineColor(lineColor)
downHist.SetLineStyle(kDashed)
downHist.SetTitle('')
rUpHist = upHist.Clone()
rUpHist.Divide(nominalHist)
rUpHist.SetTitle('')
rDownHist = downHist.Clone()
rDownHist.Divide(nominalHist)
rDownHist.SetTitle('')
p1.plotUp.addHistogram(upHist)
p1.plotUp.addHistogram(downHist)
p1.plotDown.addHistogram(rUpHist)
p1.plotDown.addHistogram(rDownHist)
p1.draw()
raw_input()
# subtract other backgrounds from data
h_tmp = process.getHistogram(
var,
process.title,
luminosity=lumi,
cut=selection,
weightExpression=weight_expression)
sys.stdout.write('.')
sys.stdout.flush()
h_data.Add(h_tmp, -1)
print "read all histograms for {0}".format(var.name)
# calculating scale factor data/MC for the given Variable
h_sf = var.createHistogram('SF')
h_sf.Divide(h_data, h_mc, 1, 1, 'B')
# plotting the scale factor
bp_sf = BasicPlot('SF_' + var.name, var, Variable('Scale Factor'))
bp_sf.titles.append(
'#sqrt{{s}} = 13 TeV, #scale[0.5]{{#int}}Ldt = {0:.2f} fb^{{-1}}, '
.format(lumi / 1000.))
bp_sf.addHistogram(h_sf, 'E', copy=True)
bp_sf.draw()
bp_sf.saveAsAll(os.path.join(outFolder, bp_sf.title))
# storing histogram in root file
from ROOT import TFile, TObject
filename = outFolder + '/SF_' + var.name + '.root'
rootfile = TFile.Open(filename, 'update')
if rootfile.IsOpen():
print "writing in file {}".format(filename)
rootfile.cd()
histogram = h_sf.Clone(var.name)
histogram.SetTitle(var.name)
from plotting.BasicPlot import BasicPlot, LegendElement
from plotting.DoublePlot import DoublePlot
from plotting.Variable import Binning, Variable, var_Events
from plotting.Tools import histToGraph, combineStatsAndSystematics, addGraphs, divideGraphs, resetGraph,\
divideHistograms, createOutOfRangeArrows
import uuid
from copy import copy
var_dataMc = Variable('Data / Model', binning=Binning(low=0.7, up=1.3))
var_dataMc.binning.nDivisions = 205
class DataMcRatioPlot(DoublePlot):
from AtlasStyle import Style
from ROOT import kRed, kSpring, kGray, TColor
defaultStatErrorTitle = 'Stat. Uncertainty'
defaultSystErrorTitle = 'Syst. Uncertainty'
defaultCombinedErrorTitle = 'Stat #oplus Syst'
defaultStatErrorStyle = Style(TColor.GetColorTransparent(kSpring, 0.3),
lineWidth=0,
fillStyle=1000,
markerStyle=0)
defaultSystErrorStyle = Style(kGray + 3,
lineWidth=0,
fillStyle=3354,
markerStyle=0)
defaultCombinedErrorStyle = Style(kGray + 3,
lineWidth=0,
fillStyle=3354,
markerStyle=0)
for i_set in range(n_sets): # data or mc plot ?
if i_type == 2: # SF plots have a different naming convention
bp = BasicPlot( 'FakeRate_'+var.name+name_type[i_type]+sel_p_suffix[p], var )
else:
bp = BasicPlot( 'FakeRate_'+var.name+name_type[i_type]+sel_p_suffix[p]+name_set[i_set], var )
bp.showBinWidthY = False
if name_type[i_type] == '_SF': # Draw a line at 1 for SF plots
h_tmp = var.createHistogram( '' )
for i_bin in range( h_tmp.GetNbinsX() + 2 ):
h_tmp.SetBinContent( i_bin, 1 )
h_tmp.SetBinError( i_bin, 0 )
h_tmp.SetLineColor( kGray )
bp.addHistogram( h_tmp, 'E' )
for i in range(id_range[i_type]): # Loop over different IDs
histo_set[len(name_set)*i_type+i_set][i].SetLineColor( sel_colors[i] )
histo_set[len(name_set)*i_type+i_set][i].SetMarkerColor( sel_colors[i] )
histo_set[len(name_set)*i_type+i_set][i].SetMarkerStyle( sel_marker[i] )
bp.addHistogram( histo_set[len(name_set)*i_type+i_set][i], 'E', copy=True )
bp.titles.append( '#sqrt{{s}} = 13 TeV, #scale[0.5]{{#int}}Ldt = {0:.2f} fb^{{-1}}'.format(lumi/1000.) )
bp.legendDecorator.textSize = 0.045
bp.normalizeByBinWidth = normByWidth[i_type]
bp.yVariable = Variable( yLabel[i_type] )
bp.logY = logScale[i_type]
bp.normalized = False
if i_type == 1 or i_type == 2: # For FR and SF plots start y-axis at 0
bp.yVariable.binning.low = 0
bp.draw()
bp.saveAsAll( os.path.join( "plots/", bp.title ) )
# --------------------
print 'everything is done!'
# create some dummy tree
rndm = TRandom3()
size = array('f', [0])
energy = array('f', [0])
t = TTree('tree', 'My Tree')
t.Branch('size', size, 'size/F')
t.Branch('energy', energy, 'energy/F')
for entry in xrange(10000):
size[0] = rndm.Poisson(3)
energy[0] = rndm.Landau(size[0] * 2.5, size[0])
t.Fill()
# define a variable object for each branch
sizeVar = Variable('size',
title='Cluster Size',
binning=Binning(10, 1, 11, range(1, 11)))
energyVar = Variable('energy',
title='Hit Energy',
unit='MeV',
binning=Binning(50, 0, 100))
# create a plot using the TreePlot class
treePlotTest = TreePlot('TreePlot Test',
sizeVar,
Variable('Entries'),
tree=t)
treePlotTest.addCut('No Cut')
treePlotTest.addCut('Energy > 15 MeV', 'energy > 15')
treePlotTest.draw()
h_mc.append(h_id)
sys.stdout.write('.')
sys.stdout.flush()
print "\tgot all{0} histograms for {1}".format(
sel_p_names[p], var.name)
# Plotting
# --------
if do_plots:
bp = BasicPlot(var.name + sel_p_suffix[p], var)
bp.legendDecorator.textSize = 0.045
bp.showBinWidthY = False
for i in range(
len(selections)): # Loop over different selections
h_mc[i].SetLineColor(sel_colors[i])
h_mc[i].SetMarkerColor(sel_colors[i])
h_mc[i].SetMarkerStyle(sel_marker[i])
bp.addHistogram(h_mc[i], 'E', copy=True)
bp.titles.append(
'Simulation, #sqrt{{s}} = 13 TeV, #scale[0.5]{{#int}}Ldt = {0:.2f} fb^{{-1}}'
.format(lumi / 1000.))
bp.normalizeByBinWidth = False
bp.normalized = True
bp.yVariable = Variable('Normalized')
#bp.yVariable = Variable( 'Events' )
bp.logY = logBool[i_var]
bp.draw()
bp.saveAsAll(os.path.join(outFolder, bp.title))
print "\t\tDone plotting {0}".format(var.name)
# --------------------
print 'everything is done!'
h1 = TH1D('hTest1', 'First Test', 40, -4, 4)
h1.FillRandom('gaus', 1000)
h1.SetLineColor(kRed)
h2 = TH1D('hTest2', 'Second Test', 40, -4, 4)
h2.FillRandom('gaus', 500)
h2.SetLineColor(kBlue)
h3 = TH1D('hTest3', 'Data', 40, -4, 4)
h3.FillRandom('gaus', 1500)
h3.SetLineColor(kBlack)
f = TF1('fTest', 'gaus', -4, 4)
f.SetLineColor(kGreen + 2)
xVar = Variable('Invariant Mass', unit='GeV')
basicTest = BasicPlot('basicTest', xVar, var_Normalized)
h = basicTest.addHistogram(h1, 'HIST', copy=True)
basicTest.addHistogram(h2, 'E0', copy=True)
basicTest.addFitFunction(h, f, legendTitle='Fit to First')
basicTest.titles.append('My title')
basicTest.titles.append('My second title')
basicTest.normalized = True
basicTest.draw()
basicTest.saveIn()
stackedTest = BasicPlot('stackedTest', xVar)
stackedTest.addHistogram(h3, 'E')
stackedTest.addHistogram(h1, stacked=True)
stackedTest.addHistogram(h2, stacked=True)
def TemplateFit(filename,
data,
mc_q,
mc_g,
w_q=None,
w_g=None,
pull_widths=[1, 1],
doPlots=True):
n_mc = 2
# Define MC samples
mc = TObjArray(n_mc)
mc.Add(mc_q)
mc.Add(mc_g)
# Names
mc_type = []
mc_type.append('Quarks')
mc_type.append('Gluons')
# Perform Fit
fit = TFractionFitter(data, mc, "q")
if w_q and w_g:
fit.SetWeight(0, w_q)
fit.SetWeight(1, w_g)
fit.Constrain(0, 0.0, 1.0) #quarks
fit.Constrain(1, 0.0, 1.0) #gluons
fit.Fit()
# Printing results
val_q = ROOT.Double()
err_q = ROOT.Double()
val_g = ROOT.Double()
err_g = ROOT.Double()
fit.GetResult(0, val_q, err_q)
fit.GetResult(1, val_g, err_g)
err_q = err_q * pull_widths[
0] # correcting the error for the width of the pull plot
err_g = err_g * pull_widths[
1] # correcting the error for the width of the pull plot
for i in range(n_mc):
val = ROOT.Double()
err = ROOT.Double()
fit.GetResult(i, val, err)
out_file.write("fit result {}: {}, {}\n".format(mc_type[i], val, err))
out_file.write("X2 = {}\n".format(fit.GetChisquare()))
out_file.write("NDF = {}\n".format(fit.GetNDF()))
red_chi = fit.GetChisquare() / fit.GetNDF()
out_file.write("red. X2 = {}\n".format(red_chi))
out_file.write("\n")
if doPlots:
print "storing plot as {}".format(filename)
# Preparing Histograms
h_fit = fit.GetPlot()
h_q = fit.GetMCPrediction(0)
h_g = fit.GetMCPrediction(1)
h_fit.SetTitle("Fit")
h_q.SetTitle("Quarks")
h_g.SetTitle("Gluons")
h_fit.SetLineColor(kGreen)
h_q.SetLineColor(kRed)
h_g.SetLineColor(kBlue)
h_q.SetMarkerColor(kRed)
h_g.SetMarkerColor(kBlue)
# Scaling to the fit result
int_fit = h_fit.Integral()
int_q = h_q.Integral()
int_g = h_g.Integral()
h_q.Sumw2()
h_g.Sumw2()
h_q.Scale(val_q * int_fit / int_q)
h_g.Scale(val_g * int_fit / int_g)
# Checking fit vs. templates
h_check = h_fit.Clone('Fit - Templates Check')
h_check.Add(h_q, -1)
h_check.Add(h_g, -1)
check_maxBin = h_check.GetMaximumBin()
out_file.write(
"Maximal bin of fit minus templates divided by content of that bin in fit: {} / {}\n\n"
.format(h_fit.GetBinContent(check_maxBin),
h_check.GetBinContent(check_maxBin)))
# Plotting results
bp = BasicPlot(filename, var_tau0_width)
bp.addHistogram(h_q, 'E', copy=True)
bp.addHistogram(h_g, 'E', copy=True)
bp.addHistogram(h_fit, 'HIST', copy=True)
bp.addHistogram(data, 'E', copy=True)
bp.titles.append(
'Quarks: {:.3} #pm {:.2}, Gluons: {:.3} #pm {:.2}'.format(
val_q, err_q, val_g, err_g))
bp.titles.append(
'#sqrt{{s}} = 13 TeV, #scale[0.5]{{#int}}Ldt = {0:.2f} fb^{{-1}}'.
format(lumi / 1000.))
bp.titles.append('#chi^{{2}}/ndf: {:.3}'.format(red_chi))
bp.yVariable = Variable("Events")
bp.legendDecorator.textSize = 0.045
bp.normalizeByBinWidth = False
bp.showBinWidthY = False
bp.normalized = False
bp.logY = False
bp.yVariable.binning.low = 0 # start y-axis at 0
bp.draw()
bp.saveAsAll(os.path.join(outFolder, bp.title))
return fit
barLength = 20
fraction = current / float(total)
nBlocks = int(round(barLength * fraction))
t = '\r[{0}] ({1}/{2}) {3:50}'.format(
'#' * nBlocks + '-' * (barLength - nBlocks), current, total, text)
sys.stdout.write(t)
sys.stdout.flush()
if fraction >= 1:
print ''
if __name__ == '__main__':
from plotting.Variable import Variable, Binning
from plotting.BasicPlot import BasicPlot
var = Variable(
'ditau_tau0_decay_mode', 'ditau_tau0_decay_mode',
'Decay Mode (#tau_{0})', '',
Binning(6, 0, 6, ['1p0n', '1p1n', '1pXn', '3p0n', '3pXn', 'Other']))
h = var.createHistogram('h_test')
h.Fill(2)
h.Fill(3)
h.Fill(2)
h.Fill(0)
h.Fill(2)
g = histToGraph(h, 'g_test')
g.SetLineColor(2)
#g = addGraphs( g, g, True )
p = BasicPlot('test', var)
def PullPlot(filename,
h_data,
h_quarks,
h_gluons,
w_quarks=None,
w_gluons=None,
pull_widths=[1, 1]):
# Creating a pull-plot
# --------------------
ratio_q = []
error_q = []
ratio_g = []
error_g = []
n_runs = 10000
# getting fit results for toy experiments
for i in range(1, n_runs + 1):
if i == 1: print " starting loop"
h_tmp = var.createHistogram(str(i))
h_tmp.FillRandom(h_data)
filename_tmp = filename + '_' + str(i)
out_file.write(str(i) + ":\n")
fit = TemplateFit(filename,
h_tmp,
h_quarks,
h_gluons,
w_quarks,
w_gluons,
pull_widths,
doPlots=False)
val_q = ROOT.Double()
err_q = ROOT.Double()
val_g = ROOT.Double()
err_g = ROOT.Double()
fit.GetResult(0, val_q, err_q)
fit.GetResult(1, val_g, err_g)
del fit
err_q = err_q * pull_widths[
0] # correcting the error for the width of the pull plot
err_g = err_g * pull_widths[
1] # correcting the error for the width of the pull plot
ratio_q.append(val_q)
error_q.append(err_q)
ratio_g.append(val_g)
error_g.append(err_g)
if i % (n_runs / 10) == 0 or i == 1 or i == n_runs:
print " {}\tQ: {} +- {}\tG: {} +- {}".format(
i, val_q, err_q, val_g, err_g)
# creating pull histogram for quarks
h_pull = var_pull.createHistogram()
ratio_q_mean = sum(ratio_q) / len(ratio_q)
for i in range(n_runs):
tmp = (ratio_q[i] - ratio_q_mean) / error_q[i]
h_pull.Fill(tmp)
fit_result = h_pull.Fit('gaus', 'QS')
f_gaus = h_pull.GetFunction('gaus')
v_q_mu = fit_result.Parameter(1)
v_q_mu_err = fit_result.ParError(1)
v_q_sigma = fit_result.Parameter(2)
v_q_sigma_err = fit_result.ParError(2)
chi = fit_result.Chi2()
ndf = fit_result.Ndf()
#red_chi = chi / ndf
filename_tmp = filename + '_PullPlot_q'
bp = BasicPlot(filename_tmp, var_pull)
bp.titles.append(
'Fit Results: #mu = {:05.3f}#pm{:05.3f}, #sigma = {:05.3f}#pm{:05.3f}'.
format(v_q_mu, v_q_mu_err, v_q_sigma, v_q_sigma_err))
bp.titles.append('#chi^{{2}}/ndf: {:.3}/{}'.format(chi, ndf))
bp.addHistogram(h_pull, 'E', copy=True)
bp.yVariable = Variable("Events")
bp.normalizeByBinWidth = False
bp.showBinWidthY = False
bp.normalized = False
bp.logY = False
bp.yVariable.binning.low = 0 # start y-axis at 0
bp.draw()
bp.saveAsAll(os.path.join(outFolder, bp.title))
del h_pull
del bp
# creating pull histogram for gluons
h_pull = var_pull.createHistogram()
ratio_g_mean = sum(ratio_g) / len(ratio_g)
for i in range(n_runs):
tmp = (ratio_g[i] - ratio_g_mean) / error_g[i]
h_pull.Fill(tmp)
fit_result = h_pull.Fit('gaus', 'QS')
f_gaus = h_pull.GetFunction('gaus')
v_g_mu = fit_result.Parameter(1)
v_g_mu_err = fit_result.ParError(1)
v_g_sigma = fit_result.Parameter(2)
v_g_sigma_err = fit_result.ParError(2)
chi = fit_result.Chi2()
ndf = fit_result.Ndf()
#red_chi = chi / ndf
filename_tmp = filename + '_PullPlot_g'
bp = BasicPlot(filename_tmp, var_pull)
bp.titles.append(
'Fit Results: #mu = {:05.3f}#pm{:05.3f}, #sigma = {:05.3f}#pm{:05.3f}'.
format(v_g_mu, v_g_mu_err, v_g_sigma, v_g_sigma_err))
bp.titles.append('#chi^{{2}}/ndf: {:.3}/{}'.format(chi, ndf))
bp.addHistogram(h_pull, 'E', copy=True)
bp.yVariable = Variable("Events")
bp.normalizeByBinWidth = False
bp.showBinWidthY = False
bp.normalized = False
bp.logY = False
bp.yVariable.binning.low = 0 # start y-axis at 0
bp.draw()
bp.saveAsAll(os.path.join(outFolder, bp.title))
return [v_q_sigma, v_g_sigma]
from array import array
rndm = TRandom3()
pT0 = array('f', [0])
pT1 = array('f', [0])
t = TTree('tree', 'tree')
t.Branch('tau_0_pt', pT0, 'tau_0_pt/F')
t.Branch('tau_1_pt', pT1, 'tau_1_pt/F')
sumOfWeights = 0.
for entry in xrange(10000):
pT0[0] = rndm.Gaus(60, 15)
pT1[0] = rndm.Gaus(50, 10)
t.Fill()
binning = Binning(50, 0, 100)
var_tau_0_pt = Variable('tau_0_pt',
title='p_{T}(#tau_{0})',
unit='GeV',
binning=binning)
var_tau_1_pt = Variable('tau_1_pt',
title='p_{T}(#tau_{1})',
unit='GeV',
binning=binning)
var_tau_pt = CombinedVariable('tau_0_pt',
'p_{T}(#tau)',
'GeV',
binning,
variables=[var_tau_0_pt, var_tau_1_pt])
p = BasicPlot('Test Plot', var_tau_pt)
p.addHistogram(
var_tau_pt.createHistogramFromTree(t, 'Any Tau', style=blackLine),
'E0')
if __name__ == '__main__':
from ROOT import TTree, TRandom3
from array import array
from plotting.Variable import Variable, Binning
from AtlasStyle import redLine, blueLine, greenLine
# create some dummy tree
rndm = TRandom3()
size = array( 'f', [0] )
energy = array( 'f', [0] )
t = TTree( 'tree', 'My Tree' )
t.Branch( 'size', size, 'size/F' )
t.Branch( 'energy', energy, 'energy/F' )
for entry in xrange( 10000 ):
size[0] = rndm.Poisson( 3 )
energy[0] = rndm.Landau( size[0]*2.5, size[0] )
t.Fill()
# define a variable object for each branch
sizeVar = Variable( 'size', title='Cluster Size', binning=Binning(10, 1, 11, range(1,11)) )
energyVar = Variable( 'energy', title='Hit Energy', unit='MeV', binning=Binning(50, 0, 100) )
p = BasicPlot( 'test', sizeVar, Variable( 'RMS(E)', unit = 'MeV' ) )
measure = HalfWidth()
measure.selection = Truncate( 0.68 )
g = p.addGraph( resolutionGraph( t, sizeVar, energyVar, '', measure ) )
p.draw()
g.Draw()
raw_input( 'Continue?' )
bin_pt_lino = VariableBinning([50, 80, 120])
bin_pt_equal = Binning(10, 20, 120)
bin_pt_fine = Binning(24, 0, 120)
bin_eta = VariableBinning(
[-2.5, -1.52, -1.37, -1.1, -0.05, 0.05, 1.1, 1.37, 1.52, 2.5])
bin_eta_equal = Binning(15, -3, 3)
bin_phi = Binning(11, -3.15, 3.15)
bin_bdt = Binning(20, 0, 1)
#===========#
# Variables #
#===========#
# Variable( name, variable, x-axis title, unit, binning )
var_run_number = Variable('run_number', 'run_number', 'Run Number', '',
Binning(100, 250000, 350000))
var_pull = Variable('pull', 'pull', 'Pull', '', Binning(70, -3.5, 3.5))
var_weight_mc = Variable('weight_mc', 'weight_mc', 'weight (MC)', '',
Binning(500, -2500, 2500))
var_weight_pileup = Variable('weight_pileup', 'weight_pileup',
'weight (Pileup)', '', Binning(11, -5, 5))
var_weight_total = Variable('weight_total', 'weight_total', 'weight (Total)',
'', Binning(500, -2500, 2500))
var_weight_ZptSF = Variable('weight_ZptSF', 'SF_dilepton_pt_vect',
'weight (ZptSF)', '', Binning(40, 0, 2))
var_n_jets = Variable('n_jets', 'n_jets', '# jets', '',
Binning(13, -0.5, 12.5))
var_n_electrons = Variable('n_electrons', 'n_electrons', '# electrons', '',
Binning(13, -0.5, 12.5))
