def buildNtuple4l(channel):
"Build a tree for storing important values"
strToProcess = "struct structSelect_t {"
strForBranch = ""
strToProcess += "Int_t passTight;"
strForBranch += "passTight/I:"
strToProcess += "Int_t passLoose;"
strForBranch += "passLoose/I:"
for ne in range(5):
for nm in range(5-ne):
strToProcess += "Int_t pass_%i%i;" %(ne,nm)
strForBranch += "pass_%i%i/I:" %(ne,nm)
strToProcess += "};"
strForBranch = strForBranch[:-1] # remove trailing :
rt.gROOT.ProcessLine(strToProcess)
rt.gROOT.ProcessLine(
"struct structEvent_t {\
Int_t evt;\
Int_t run;\
Int_t lumi;\
Int_t nvtx;\
Float_t lep_scale;\
Float_t trig_scale;\
Float_t pu_weight;\
};");
rt.gROOT.ProcessLine(
"struct structChannel_t {\
Char_t channel[5];\
};");
rt.gROOT.ProcessLine(
"struct struct4l_t {\
Float_t mass;\
Float_t sT;\
Float_t met;\
Float_t metPhi;\
Int_t jetVeto20;\
Int_t jetVeto30;\
Int_t jetVeto40;\
Int_t bjetVeto20;\
Int_t bjetVeto30;\
Int_t muonVeto5;\
Int_t muonVeto10Loose;\
Int_t muonVeto15;\
Int_t elecVeto10;\
};");
rt.gROOT.ProcessLine(
"struct structH_t {\
Float_t mass;\
Float_t sT;\
Float_t dPhi;\
Float_t Pt1;\
Float_t Eta1;\
Float_t Phi1;\
Float_t Pt2;\
Float_t Eta2;\
Float_t Phi2;\
Int_t Chg1;\
Int_t Chg2;\
};");
rt.gROOT.ProcessLine(
"struct structHChar_t {\
Char_t Flv[3];\
};");
rt.gROOT.ProcessLine(
"struct structLepton_t {\
Float_t Pt;\
Float_t Eta;\
Float_t Phi;\
Float_t Iso;\
Int_t Chg;\
};");
rt.gROOT.ProcessLine(
"struct structLepChar_t {\
Char_t Flv[2];\
};");
tree = rt.TTree(channel,'H++H-- 4l')
structSelect = rt.structSelect_t()
structEvent = rt.structEvent_t()
structChannel = rt.structChannel_t()
struct4l = rt.struct4l_t()
structH1 = rt.structH_t()
structH2 = rt.structH_t()
structH1f = rt.structHChar_t()
structH2f = rt.structHChar_t()
structZ1 = rt.structH_t()
structZ1f = rt.structHChar_t()
structZ2 = rt.structH_t()
structZ2f = rt.structHChar_t()
structTTf = rt.structHChar_t()
structL1 = rt.structLepton_t()
structL2 = rt.structLepton_t()
structL3 = rt.structLepton_t()
structL4 = rt.structLepton_t()
structL1f = rt.structLepChar_t()
structL2f = rt.structLepChar_t()
structL3f = rt.structLepChar_t()
structL4f = rt.structLepChar_t()
tree.Branch('select',structSelect,strForBranch)
tree.Branch('event',structEvent,'evt/I:run:lumi:nvtx:lep_scale/F:trig_scale:pu_weight')
tree.Branch('channel',rt.AddressOf(structChannel,'channel'),'channel/C')
tree.Branch('4l',struct4l,'mass/F:sT:met:metPhi:jetVeto20/I:jetVeto30:jetVeto40:bjetVeto20:bjetVeto30:muonVeto5:muonVeto10Loose:muonVeto15:elecVeto10')
tree.Branch('h1',structH1,'mass/F:sT:dPhi:Pt1:Eta1:Phi1:Pt2:Eta2:Phi2:Chg1/I:Chg2')
tree.Branch('h2',structH2,'mass/F:sT:dPhi:Pt1:Eta1:Phi1:Pt2:Eta2:Phi2:Chg1/I:Chg2')
tree.Branch('h1Flv',rt.AddressOf(structH1f,'Flv'),'Flv/C')
tree.Branch('h2Flv',rt.AddressOf(structH2f,'Flv'),'Flv/C')
tree.Branch('z1',structZ1,'mass/F:sT:dPhi:Pt1:Eta1:Phi1:Pt2:Eta2:Phi2:Chg1/I:Chg2')
tree.Branch('z1Flv',rt.AddressOf(structZ1f,'Flv'),'Flv/C')
tree.Branch('z2',structZ2,'mass/F:sT:dPhi:Pt1:Eta1:Phi1:Pt2:Eta2:Phi2:Chg1/I:Chg2')
tree.Branch('z2Flv',rt.AddressOf(structZ2f,'Flv'),'Flv/C')
tree.Branch('ttFlv',rt.AddressOf(structTTf,'Flv'),'Flv/C')
tree.Branch('l1',structL1,'Pt/F:Eta:Phi:Iso:Chg/I')
tree.Branch('l2',structL2,'Pt/F:Eta:Phi:Iso:Chg/I')
tree.Branch('l3',structL3,'Pt/F:Eta:Phi:Iso:Chg/I')
tree.Branch('l4',structL4,'Pt/F:Eta:Phi:Iso:Chg/I')
tree.Branch('l1Flv',rt.AddressOf(structL1f,'Flv'),'Flv/C')
tree.Branch('l2Flv',rt.AddressOf(structL2f,'Flv'),'Flv/C')
tree.Branch('l3Flv',rt.AddressOf(structL3f,'Flv'),'Flv/C')
tree.Branch('l4Flv',rt.AddressOf(structL4f,'Flv'),'Flv/C')
return tree, structSelect, structEvent, structChannel, struct4l, structH1, structH2, structH1f, structH2f,\
structZ1, structZ1f, structZ2, structZ2f, structTTf, structL1, structL2, structL3, structL4,\
structL1f, structL2f, structL3f, structL4f
def buildNtuple(object_definitions,states,channelName,final_states,**kwargs):
'''
A function to build an initial state ntuple for AnalyzerBase.py
'''
alternateIds = kwargs.pop('altIds',[])
doVBF = kwargs.pop('doVBF',False)
doMetUnc = kwargs.pop('doMetUnc',False)
finalStateObjects = 'emtjgn'
structureDict = {}
structOrder = []
# count objects
nl = 0
nj = 0
np = 0
for key in states[0]:
val = object_definitions[key]
for obj in val:
if obj=='n': continue
else:
if obj in 'emt':
nl += 1
if obj == 'j':
nj += 1
if obj == 'g':
np += 1
# some common things
baseMetVars = ['met','metPhi','mT']
metVars = []
metVars += baseMetVars
baseLepMetVars = ['mass','Pt','sT','dPhi']
lepMetVars = []
if doMetUnc:
for s in ['JetRes','JetEn','MuonEn','ElectronEn','TauEn','UnclusteredEn','PhotonEn']:
for d in ['Up','Down']:
for m in baseMetVars:
metVars += ['{0}{1}{2}'.format(m,s,d)]
for m in baseLepMetVars:
lepMetVars += ['{0}{1}{2}'.format(m,s,d)]
lepFloats = ['Pt', 'Eta', 'Phi', 'Iso', 'Dxy', 'Dz', 'SigmaIEtaIEta', 'DEtaIn', 'DPhiIn', 'HOverE', 'OoEmOoP', 'TriggeringMVA', 'NonTriggeringMVA', 'NormalizedChi2', 'JetPt', 'JetBTag']
for t in ['','_up','_down']:
for l in ['Loose','Tight']:
lepFloats += ['LepScale{0}{1}'.format(l,t)]
lepFloats += ['LepEff{0}'.format(t)]
lepFloats += ['LepFake{0}'.format(t)]
lepInts = ['Chg', 'PassLoose', 'PassTight', 'GenPdgId', 'MotherGenPdgId', 'ChargeConsistent', 'ExpectedMissingInnerHits', 'PassConversionVeto', 'IsGlobalMuon', 'IsPFMuon', 'IsTrackerMuon', 'ValidMuonHits', 'MatchedStations', 'ValidPixelHits', 'TrackerLayers']
# define selection bools
numObjs = len(final_states[0])
allowedObjects = ''
for fsObj in finalStateObjects:
for fs in final_states:
if fsObj in fs:
allowedObjects += fsObj
break
numObjTypes = len(allowedObjects)
selectVars = {}
selectVars['I'] = ['passTight','passLoose']
for trig in ['DoubleMuon','DoubleEG','MuonEG','EGMuon']:
selectVars['I'] += ['pass{0}'.format(trig)]
for altId in alternateIds:
selectVars['I'] += ['pass_{0}'.format(altId)]
selectName = 'structSelect_t'
selectStruct, selectStrForBranch = getStruct(selectName,selectVars)
structureDict['select'] = [selectStruct, selectStruct, selectStrForBranch]
structOrder += ['select']
# define common root classes
eventVars = {}
eventVars['I'] = ['run','lumi','nvtx','GenNUP','trig_prescale']
eventVars['l'] = ['evt'] # ULong64
eventVars['F'] = ['gen_weight','charge_uncertainty']
for v in ['lep_scale','lep_scale_e','lep_scale_m','pu_weight','fakerate','trig_scale','lepeff']:
for t in ['','_up','_down']:
eventVars['F'] += ['{0}{1}'.format(v,t)]
eventName = 'structEvent_t'
eventStruct, eventStrForBranch = getStruct(eventName,eventVars)
structOrder += ['event']
structureDict['event'] = [eventStruct,eventStruct,eventStrForBranch]
# add channels
if not hasattr(rt,'structChannel_t'):
rt.gROOT.ProcessLine(
"struct structChannel_t {\
Char_t channel[9];\
};");
channelStruct = rt.structChannel_t()
structureDict['channel'] = [channelStruct, rt.AddressOf(channelStruct,'channel'),'channel/C']
structOrder += ['channel']
genChannelStruct = rt.structChannel_t()
structureDict['genChannel'] = [genChannelStruct, rt.AddressOf(genChannelStruct,'channel'),'channel/C']
structOrder += ['genChannel']
fakeChannelStruct = rt.structChannel_t()
structureDict['fakeChannel'] = [fakeChannelStruct, rt.AddressOf(fakeChannelStruct,'channel'),'channel/C']
structOrder += ['fakeChannel']
# add final state structs
fsVars = {}
fsVars['F'] = ['mass','eta','phi','sT']
fsVars['F'] += metVars
fsVars['F'] += ['leadJetPt','leadJetEta','leadJetPhi','leadJetPUMVA']
fsVars['I'] = ['jetVeto20','jetVeto30','jetVeto40']
fsVars['I'] += ['elecVetoLoose','elecVetoTight','muonVetoLoose','muonVetoTight']
for pt in ['20','30']:
for l in ['Loose','Medium','Tight']:
fsVars['I'] += ['bjetVeto{0}{1}'.format(pt,l)]
if doVBF:
fsVars['F'] += ['vbfMass','vbfPt','vbfPt1','vbfPt2','vbfEta1','vbfEta2']
fsVars['I'] += ['centralJetVeto20','centralJetVeto30']
fsName = 'structFinalState_t'
fsStruct, fsStrForBranch = getStruct(fsName,fsVars)
structureDict['finalstate'] = [fsStruct, fsStruct, fsStrForBranch]
structOrder += ['finalstate']
# add object struct
objVars = {}
objVars['F'] = lepFloats
objVars['I'] = lepInts
objName = 'structObject_t'
if not hasattr(rt,'structObjChar_t'):
rt.gROOT.ProcessLine(
"struct structObjChar_t {\
Char_t Flv[2];\
};");
lepCount = 0
jetCount = 0
phoCount = 0
for key in states[0]:
val = object_definitions[key]
for obj in val:
if obj=='n': continue
else:
objStruct, objStrForBranch = getStruct(objName,objVars)
flvStruct = rt.structObjChar_t()
if obj in 'emt':
charName = 'l'
lepCount += 1
objCount = lepCount
if obj == 'j':
charName = 'j'
jetCount += 1
objCount = jetCount
if obj == 'g':
charName = 'g'
phoCount += 1
objCount = phoCount
structureDict['%s%i' % (charName, objCount)] = [objStruct, objStruct, objStrForBranch]
structureDict['%s%iFlv' % (charName, objCount)] = [flvStruct, rt.AddressOf(flvStruct,'Flv'),'Flv/C']
structOrder += ['%s%i' % (charName, objCount)]
structOrder += ['%s%iFlv' % (charName, objCount)]
# define objects for each initial state
for state in states:
for key in state:
val = object_definitions[key]
stateVars = {'I':[],'F':[]}
stateName = 'struct{0}_t'.format(key.upper())
stateVars['F'] += ['mass','Pt','sT','dPhi']
if 'n' not in val:
stateVars['F'] += ['dR']
objCount = 0
for obj in val:
if obj == 'n':
#stateVars['F'] += metVars
stateVars['F'] += lepMetVars
else:
objCount += 1
for v in lepFloats:
stateVars['F'] += ['{0}{1}'.format(v,objCount)]
for v in lepInts:
stateVars['I'] += ['{0}{1}'.format(v,objCount)]
# manually add the W Z deltaRs for now
if key == 'w1':
stateVars['F'] += ['dR1_z1_1','dR1_z1_2','mll_z1_1','mll_z1_2','dR1_leadJet']
for altId in alternateIds:
stateVars['I'] += ['pass_{0}_{1}'.format(altId, objCount)]
initialStruct, initialStrForBranch = getStruct(stateName,stateVars)
structureDict[key] = [initialStruct, initialStruct, initialStrForBranch]
structOrder += [key]
if not hasattr(rt,'structInitialChar_t'):
rt.gROOT.ProcessLine(
"struct structInitialChar_t {\
Char_t Flv[3];\
};");
for key in object_definitions:
initialFlvStruct = rt.structInitialChar_t()
structureDict['%sFlv' % key] = [initialFlvStruct,rt.AddressOf(initialFlvStruct,'Flv'),'Flv/C']
structOrder += ['%sFlv' % key]
# now create the tree
tree = rt.TTree(channelName,channelName)
allBranches = {}
for key in structOrder:
val = structureDict[key]
tree.Branch(key,val[1],val[2])
allBranches[key] = val[0]
return (tree, allBranches)
